MonthlyAccountCalcService.java
Copyright Notice: This article is an original work licensed under the CC 4.0 BY-NC-ND license.
If you wish to repost this article, please include the original source link and this copyright notice.
Source link: https://v2know.com/article/1270
這篇文章主要展示了一個 Java 服務類 MonthlyAccountCalcService 的原始程式碼，並介紹其核心功能：每月報酬與所得稅的計算邏輯。文章內容以完整程式碼呈現，並配有清晰註解與結構化設計。主要重點如下：
-
職責描述：負責按月計算報酬（reward）、費用償付（restitute），以及根據業務規則自動計算源泉所得稅（withholding tax）。
-
關鍵方法：
-
calcMonthlyAccount(...)：主要入口，執行針對目標調查記錄（TResearchRecord）的計算，並重新計算同月份其他相關記錄，最後統一處理源泉扣稅邏輯。 -
calcForResearchRecord(...)：逐一計算各項報酬與償付金額，合計總報酬與成本，並在啟用所得稅計算時，進行源泉扣稅處理。 -
withholdingTaxDeduct(...)：在存在多筆記錄時，依照排序及規則，將總源泉稅額合理分配到各個調查記錄。
-
-
源泉稅計算細節：依據不同年度（如 2015 年以前、2016–2017 年、2018 年後等）使用對應的計算規則，並考慮稅表種類（甲／乙／丙）及扶養人數等業務條件。
-
技術亮點：使用
ScriptEngineManager呼叫 JavaScript 引擎執行動態公式計算，並廣泛應用 Seasar 框架的工具與結構來進行屬性映射與資料處理。
Original:
package jp.tokyo.metro.tstt.service;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import org.apache.commons.lang3.StringUtils;
import org.seasar.framework.beans.util.BeanMap;
import org.seasar.framework.beans.util.BeanUtil;
import org.seasar.framework.util.StringUtil;
import jp.tokyo.metro.tstt.dto.MonthAccountCalcMDailyAmountDto;
import jp.tokyo.metro.tstt.dto.MonthAccountCalcResultDto;
import jp.tokyo.metro.tstt.dto.MonthAccountCalcSelectTResearchRecordDto;
import jp.tokyo.metro.tstt.dto.MonthAccountCalcTResearchRecordDto;
import jp.tokyo.metro.tstt.dto.MonthAccountCalcTWithholdingTaxTableDto;
import jp.tokyo.metro.tstt.entity.TResearchRecord;
import jp.tokyo.metro.tstt.entity.TWithholdingTaxTable;
import jp.tokyo.metro.tstt.util.Constants;
import jp.tokyo.metro.tstt.util.TsttUtil;
public class MonthlyAccountCalcService extends AppService implements Constants {
// 区切り文字
private final String DELIM = "@";
// 計算で使用するスクリプトエンジン
private ScriptEngineManager manager;
private ScriptEngine engine;
/**
* 月額計算処理を行う。
*
* @param inputEntity 画面の入力値
* @param rewardCalcFlg 報酬金額１～１２と弁償金額１～１２の計算実施フラグ 0:計算しない 1:計算する
* @param taxCalcFlg 所得税計算実施フラグ 0:計算しない 1:計算する
* @return 計算結果
*/
public MonthAccountCalcResultDto calcMonthlyAccount(TResearchRecord inputEntity, String rewardCalcFlg,
String taxCalcFlg) throws Exception {
// 計算で使用するスクリプトエンジンを初期化
manager = new ScriptEngineManager();
engine = manager.getEngineByName("javascript");
// ［１］ 対象の調査実績に対する計算処理
MonthAccountCalcTResearchRecordDto targetTRR = createTargetResearchRecord(inputEntity);
MonthAccountCalcResultDto targetResult = calcForResearchRecord(targetTRR, rewardCalcFlg, taxCalcFlg);
if (targetResult.result == 0) {
// ［２］ 同じ月の他の調査の実績を全て再計算する
List<MonthAccountCalcResultDto> otherResults = calcOtherRearchRecord(inputEntity);
// 同じ月の他の調査全ての計算が成功した場合
if (calcSuccessed(otherResults)) {
// ［３］ 源泉徴収額引当処理
withholdingTaxDeduct(targetTRR, targetResult, otherResults);
targetResult.otherResearchRecord = otherResults;
} else {
// 同じ月の他の調査いずれかが計算失敗していた場合は対象の調査実績も失敗とする
targetResult.result = -1;
}
}
return targetResult;
}
/**
* 対象調査実績のデータを取得・設定する
*
* @param inputEntity 画面の入力値
* @return 対象調査実績のデータ
*/
private MonthAccountCalcTResearchRecordDto createTargetResearchRecord(TResearchRecord inputEntity) {
// 画面より渡って来た調査名コード、処理月、調査員番号を元にして、計算対象データを取得する。
// ②[SQL ２．計算対象情報取得]を実施して、計算対象データを取得する。
MonthAccountCalcTResearchRecordDto targetTRR = getTResearchRecord(inputEntity);
// 取得した計算対象データに対して、画面から同じ項目に値が渡って来ている場合、その値に置き換える。
setTResearchRecordDto(inputEntity, targetTRR, true);
return targetTRR;
}
/**
* 対象調査実績に対して同年・同月・同調査員・別調査の調査実績を取得し計算を行う
*
* @param inputEntity 画面の入力値
* @return 計算結果
* @throws Exception 何かの例外
*/
private List<MonthAccountCalcResultDto> calcOtherRearchRecord(TResearchRecord inputEntity) throws Exception {
List<MonthAccountCalcTResearchRecordDto> otherTRRs = getOtherTResearchRecord(inputEntity);
List<MonthAccountCalcResultDto> otherResults = new ArrayList<MonthAccountCalcResultDto>();
for (MonthAccountCalcTResearchRecordDto trr : otherTRRs) {
setTResearchRecordDto(inputEntity, trr, false);
otherResults.add(calcForResearchRecord(trr, FLAG_ON, FLAG_ON));
}
return otherResults;
}
/**
* 対象調査員の報酬額合計に対する源泉徴収額を取得する
*
* @param targetTRR 対象調査実績
* @param targetResult 対象調査実績の計算結果
* @param otherResults 対象調査実績以外の調査実績の計算結果
* @return 源泉徴収額
*/
private BigDecimal calcTotalWithHoldingTax(MonthAccountCalcTResearchRecordDto targetTRR,
MonthAccountCalcResultDto targetResult, List<MonthAccountCalcResultDto> otherResults) {
BigDecimal sumRewardAmount = BigDecimal.ZERO;
sumRewardAmount = sumRewardAmount.add(convNull(targetResult.rewardAmount));
for (MonthAccountCalcResultDto result : otherResults) {
sumRewardAmount = sumRewardAmount.add(convNull(result.rewardAmount));
}
return calcTaxWithholding(targetTRR, sumRewardAmount);
}
/**
* 月額計算処理を行う。（調査実績単位）
*
* @param selectTRRDto 計算対象調査実績
* @param rewardCalcFlg 報酬金額１～１２と弁償金額１～１２の計算実施フラグ 0:計算しない 1:計算しない
* @param taxCalcFlg 所得税計算実施フラグ 0:計算しない 1:計算する
* @return 計算結果
*/
private MonthAccountCalcResultDto calcForResearchRecord(MonthAccountCalcTResearchRecordDto selectTRRDto,
String rewardCalcFlg, String taxCalcFlg) throws Exception {
// 処理結果格納用
MonthAccountCalcResultDto resDto = new MonthAccountCalcResultDto();
// 発生フラグのインデント設定
int occurFlgIndex = Integer.valueOf(selectTRRDto.performYm.substring(4)).intValue();
if (occurFlgIndex > 4) {
occurFlgIndex -= 5;
} else {
occurFlgIndex += 7;
}
// 計算で使用する値格納
HashMap<String, BigDecimal> calcValMap = new HashMap<String, BigDecimal>();
// 計算用のマップに詰め替え
setCalcMap(selectTRRDto, calcValMap);
// 詰め替えた結果を格納用DTOに設定
BeanUtil.copyProperties(selectTRRDto, resDto);
resDto.rewardAmount1 = null;
resDto.rewardAmount2 = null;
resDto.rewardAmount3 = null;
resDto.rewardAmount4 = null;
resDto.rewardAmount5 = null;
resDto.rewardAmount6 = null;
resDto.rewardAmount7 = null;
resDto.rewardAmount8 = null;
resDto.rewardAmount9 = null;
resDto.rewardAmount10 = null;
resDto.rewardAmount11 = null;
resDto.rewardAmount12 = null;
resDto.restituteAmount1 = null;
resDto.restituteAmount2 = null;
resDto.restituteAmount3 = null;
resDto.restituteAmount4 = null;
resDto.restituteAmount5 = null;
resDto.restituteAmount6 = null;
resDto.restituteAmount7 = null;
resDto.restituteAmount8 = null;
resDto.restituteAmount9 = null;
resDto.restituteAmount10 = null;
resDto.restituteAmount11 = null;
resDto.restituteAmount12 = null;
resDto.rewardAmount = BigDecimal.ZERO;
resDto.costRestituteAmount = BigDecimal.ZERO;
//上記で置き換えたデータを元に全データに対して以下の処理を行う
char[] researchFlgArray = selectTRRDto.researchPerformMonthFlg.toCharArray();
char researchFlg = researchFlgArray[occurFlgIndex];
//調査実績月フラグにて、処理年月に該当するフラグが立っていない場合は終了。
if (researchFlg == '1') {
//以下の報酬計算を実施する。（報酬１～１２に対して実施する）
// 報酬計算フラグがOFFの場合は、処理を飛ばす
if (rewardCalcFlg.equals(FLAG_ON)) {
//[報酬計算]--------------------------------------------------------------------
// 算出結果を格納（報酬金額１～１２）
HashMap<String, BigDecimal> calcResultReward = new HashMap<String, BigDecimal>();
if (calc(calcValMap, resDto, selectTRRDto.conbRewardOccurredFlg, selectTRRDto.conbCxFormula,
calcResultReward, occurFlgIndex, 0) != 0) {
// 計算結果エラー
resDto.result = -1;
return resDto;
}
// 計算した結果を設定
setRewardCalcResult(calcResultReward, resDto);
//以下の費用弁償計算を実施する。（費用弁償１～１２に対して実施する）
//[費用弁償計算]--------------------------------------------------------------------
// 算出結果を格納（費用弁償金額１～１２）
HashMap<String, BigDecimal> calcResultRestitute = new HashMap<String, BigDecimal>();
if (calc(calcValMap, resDto, selectTRRDto.conbRestituteOccuredFlg, selectTRRDto.conbDxFormula,
calcResultRestitute, occurFlgIndex, 1) != 0) {
// 計算結果エラー
resDto.result = -1;
return resDto;
}
// 計算した結果を設定
setRestituteCalcResult(calcResultRestitute, resDto);
} else {
// 値を再反映
BeanUtil.copyProperties(selectTRRDto, resDto);
}
// 報酬金額 設定
resDto.rewardAmount = sumRewardAmount(resDto);
// 費用弁償金額 設定
resDto.costRestituteAmount = sumRestituteAmount(resDto);
// 以下の所得税計算を実施する。
// 所得税計算フラグがOFFの場合は、処理を飛ばす
if (FLAG_ON.equals(taxCalcFlg)) {
//[所得税計算]--------------------------------------------------------------------
//ビジネスルール定義の計算ルールを元に、源泉徴収税額を算出する。
//算出した源泉徴収税額を所得税引去額に設定する。
resDto.incomeTaxTake = calcTaxWithholding(selectTRRDto, resDto.rewardAmount);
}
}
return resDto;
}
/**
* 源泉徴収額引当処理
*
* @param targetTRR 対象調査実績
* @param targetResult 対象調査実績の計算結果
* @param otherResults 対象調査実績以外の調査実績の計算結果
*/
private void withholdingTaxDeduct(MonthAccountCalcTResearchRecordDto targetTRR,
MonthAccountCalcResultDto targetResult, List<MonthAccountCalcResultDto> otherResults) {
// 源泉徴収額取得
BigDecimal totalWithholdingTax = calcTotalWithHoldingTax(targetTRR, targetResult, otherResults);
// 源泉徴収税額が1円以上の場合に処理を行う
if (totalWithholdingTax.compareTo(BigDecimal.ZERO) > 0) {
// 他調査実績が無い場合は対象調査実績に税を設定して終了
if (otherResults.size() == 0) {
targetResult.incomeTaxTake = totalWithholdingTax;
} else {
// 住民税額取得
BigDecimal residentTax = convNull(getResidentTax(targetTRR));
// 調査実績（計算後）を１つにまとめる
List<MonthAccountCalcResultDto> joinedResults = new ArrayList<MonthAccountCalcResultDto>();
joinedResults.add(targetResult);
joinedResults.addAll(otherResults);
Collections.sort(joinedResults, MonthlyAccountCalcComparator.getInstance());
// 引当処理
boolean first = true;
for (MonthAccountCalcResultDto trr : joinedResults) {
BigDecimal reward = null;
if (first) {
reward = convNull(trr.rewardAmount).subtract(residentTax);
first = false;
} else {
reward = convNull(trr.rewardAmount);
}
if (reward.compareTo(totalWithholdingTax) >= 0) {
trr.incomeTaxTake = totalWithholdingTax;
totalWithholdingTax = BigDecimal.ZERO;
} else {
trr.incomeTaxTake = reward;
totalWithholdingTax = totalWithholdingTax.subtract(reward);
}
}
}
}
}
/**
* 報酬金額１～１２の合算値を返す
* @param resDto
* @return
*/
private BigDecimal sumRewardAmount(MonthAccountCalcResultDto resDto) {
BigDecimal result = BigDecimal.ZERO;
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.rewardAmount1));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.rewardAmount2));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.rewardAmount3));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.rewardAmount4));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.rewardAmount5));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.rewardAmount6));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.rewardAmount7));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.rewardAmount8));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.rewardAmount9));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.rewardAmount10));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.rewardAmount11));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.rewardAmount12));
return result;
}
/**
* 弁償金額１～１２の合算値を返す
* @param resDto
* @return
*/
private BigDecimal sumRestituteAmount(MonthAccountCalcResultDto resDto) {
BigDecimal result = BigDecimal.ZERO;
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.restituteAmount1));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.restituteAmount2));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.restituteAmount3));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.restituteAmount4));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.restituteAmount5));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.restituteAmount6));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.restituteAmount7));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.restituteAmount8));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.restituteAmount9));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.restituteAmount10));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.restituteAmount11));
result = result.add(TsttUtil.convNullToZeroForBigDecimal(resDto.restituteAmount12));
return result;
}
/**
* 報酬定数１～１２の計算結果を設定
* @param valMap 計算結果
* @param resDto 結果格納用DTO
*/
private void setRewardCalcResult(HashMap<String, BigDecimal> valMap, MonthAccountCalcResultDto resDto) {
// 報酬金額１
if (valMap.containsKey("金額1")) {
resDto.rewardAmount1 = valMap.get("金額1");
}
// 報酬金額２
if (valMap.containsKey("金額2")) {
resDto.rewardAmount2 = valMap.get("金額2");
}
// 報酬金額３
if (valMap.containsKey("金額3")) {
resDto.rewardAmount3 = valMap.get("金額3");
}
// 報酬金額４
if (valMap.containsKey("金額4")) {
resDto.rewardAmount4 = valMap.get("金額4");
}
// 報酬金額５
if (valMap.containsKey("金額5")) {
resDto.rewardAmount5 = valMap.get("金額5");
}
// 報酬金額６
if (valMap.containsKey("金額6")) {
resDto.rewardAmount6 = valMap.get("金額6");
}
// 報酬金額７
if (valMap.containsKey("金額7")) {
resDto.rewardAmount7 = valMap.get("金額7");
}
// 報酬金額８
if (valMap.containsKey("金額8")) {
resDto.rewardAmount8 = valMap.get("金額8");
}
// 報酬金額９
if (valMap.containsKey("金額9")) {
resDto.rewardAmount9 = valMap.get("金額9");
}
// 報酬金額１０
if (valMap.containsKey("金額10")) {
resDto.rewardAmount10 = valMap.get("金額10");
}
// 報酬金額１１
if (valMap.containsKey("金額11")) {
resDto.rewardAmount11 = valMap.get("金額11");
}
// 報酬金額１２
if (valMap.containsKey("金額12")) {
resDto.rewardAmount12 = valMap.get("金額12");
}
}
/**
* 弁償定数１～１２の計算結果を設定
* @param valMap 計算結果
* @param resDto 結果格納用DTO
*/
private void setRestituteCalcResult(HashMap<String, BigDecimal> valMap, MonthAccountCalcResultDto resDto) {
// 弁償金額１
if (valMap.containsKey("金額1")) {
resDto.restituteAmount1 = valMap.get("金額1");
}
// 弁償金額２
if (valMap.containsKey("金額2")) {
resDto.restituteAmount2 = valMap.get("金額2");
}
// 弁償金額３
if (valMap.containsKey("金額3")) {
resDto.restituteAmount3 = valMap.get("金額3");
}
// 弁償金額４
if (valMap.containsKey("金額4")) {
resDto.restituteAmount4 = valMap.get("金額4");
}
// 弁償金額５
if (valMap.containsKey("金額5")) {
resDto.restituteAmount5 = valMap.get("金額5");
}
// 弁償金額６
if (valMap.containsKey("金額6")) {
resDto.restituteAmount6 = valMap.get("金額6");
}
// 弁償金額７
if (valMap.containsKey("金額7")) {
resDto.restituteAmount7 = valMap.get("金額7");
}
// 弁償金額８
if (valMap.containsKey("金額8")) {
resDto.restituteAmount8 = valMap.get("金額8");
}
// 弁償金額９
if (valMap.containsKey("金額9")) {
resDto.restituteAmount9 = valMap.get("金額9");
}
// 弁償金額１０
if (valMap.containsKey("金額10")) {
resDto.restituteAmount10 = valMap.get("金額10");
}
// 弁償金額１１
if (valMap.containsKey("金額11")) {
resDto.restituteAmount11 = valMap.get("金額11");
}
// 弁償金額１２
if (valMap.containsKey("金額12")) {
resDto.restituteAmount12 = valMap.get("金額12");
}
}
/**
* 源泉徴収税額を算出
* @param selectDto 調査実績情報格納
* @param sumRewardAmount 報酬金額
* @return 源泉徴収税額の算出結果
*/
private BigDecimal calcTaxWithholding(MonthAccountCalcTResearchRecordDto selectDto, BigDecimal sumRewardAmount) {
// 処理結果
BigDecimal result = BigDecimal.ZERO;
// 2016年（平成28年1月）より新たな源泉徴収税額となる為、
// 対象日によって計算方法を変える。
if (!StringUtil.isEmpty(selectDto.performYm) &&
Integer.valueOf(selectDto.performYm) <= 201512) {
// 2015年迄は旧来の計算式
result = calcTaxWithholdingUnder2015(selectDto, sumRewardAmount);
} else if (!StringUtil.isEmpty(selectDto.performYm) &&
Integer.valueOf(selectDto.performYm) >= 201601 && Integer.valueOf(selectDto.performYm) <= 201701) {
// 2016年1月から2017年1月迄はは新たな計算式
result = calcTaxWithholdingOver2016(selectDto, sumRewardAmount);
} else if (!StringUtil.isEmpty(selectDto.performYm) &&
Integer.valueOf(selectDto.performYm) >= 201702 && Integer.valueOf(selectDto.performYm) <= 201712) {
// 2017年2月から2017年12月迄はは新たな計算式
result = calcTaxWithholdingOver201702(selectDto, sumRewardAmount);
} else if (!StringUtil.isEmpty(selectDto.performYm) &&
Integer.valueOf(selectDto.performYm) >= 201801 && Integer.valueOf(selectDto.performYm) <= 201912){
// 2018年1月からは新たな計算式
result = calcTaxWithholdingOver2018(selectDto, sumRewardAmount);
} else{
//20191015変更 2020年以降のデータ計算
result = calcTaxWithholdingOver2020(selectDto, sumRewardAmount);
}
return result;
}
/**
* 源泉徴収税額を算出（2015年12月以前用）
* @param selectDto 調査実績情報格納
* @param sumRewardAmount 報酬金額
* @return 源泉徴収税額の算出結果
*/
private BigDecimal calcTaxWithholdingUnder2015(MonthAccountCalcTResearchRecordDto selectDto, BigDecimal sumRewardAmount) {
// 処理結果
BigDecimal result = BigDecimal.ZERO;
// 源泉徴収税額票の検索条件
MonthAccountCalcTWithholdingTaxTableDto condTWithoutTaxTbl = new MonthAccountCalcTWithholdingTaxTableDto();
// 年度
condTWithoutTaxTbl.year = selectDto.targetYear;
// 以上
condTWithoutTaxTbl.greaterEqual = sumRewardAmount;
// 未満
condTWithoutTaxTbl.lessThan = sumRewardAmount;
// 扶養人数
int dependentsNum = getDependentsNum(selectDto);
if (dependentsNum > 7) {
condTWithoutTaxTbl.dependentsCount = 7;
} else {
condTWithoutTaxTbl.dependentsCount = (short) dependentsNum;
}
// 源泉徴収税額の検索結果
TWithholdingTaxTable selectResult;
// 計算時に使用する一時格納用
BigDecimal temp;
// 対象としている調査の単発調査区分が「１：単発」でかつ、同時期に非単発の調査を行っていない場合
if (selectDto.oneoffResearchKbn.equals(ONEOFF_RESEARCH_KBN_ONE) && selectDto.countOffResearch == 0) {
// 税表区分
condTWithoutTaxTbl.taxTableKbn = TAX_CODE_HEI;
// 日額マスタから取得
MonthAccountCalcMDailyAmountDto mDailyAmountDto = selectBySqlFile(MonthAccountCalcMDailyAmountDto.class,
"/sql/MonthAccountCalcSelectMDailyAmount.sql").get(0);
// 「丙」では人数を検索条件としないため、nullを設定
condTWithoutTaxTbl.dependentsCount = null;
// 以上
condTWithoutTaxTbl.greaterEqual = mDailyAmountDto.dailyAmount;
// 未満
condTWithoutTaxTbl.lessThan = mDailyAmountDto.dailyAmount;
if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(9300)) < 0) {
// 日額が9300円未満 の場合
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(9300)) >= 0
&& mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(33000)) < 0) {
// 日額が9300円以上33000円未満の場合
// 源泉徴収税額表を取得
selectResult = selectBySqlFile(TWithholdingTaxTable.class,
"/sql/MonthAccountCalcSelectWithholdingTax.sql", condTWithoutTaxTbl).get(0);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(33000)) == 0) {
// 日額が33000円 の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 33000);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(33000)) > 0
&& mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(58000)) < 0) {
// 日額が33000円より大きく58000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 33000);
// （実際の報酬金額－33000）
temp = mDailyAmountDto.dailyAmount.subtract(new BigDecimal(33000));
// 24.504%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.24504")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = selectResult.taxAmount.add(temp);
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(58000)) == 0) {
// 日額が58000円 の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 58000);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(58000)) > 0) {
// 日額が58000円より大きい 場合
// （実際の報酬金額－58000）
temp = mDailyAmountDto.dailyAmount.subtract(new BigDecimal(58000));
// 33.693%を掛けた値を算出する。
temp = temp.multiply(new BigDecimal("0.33693")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で算出した値に8431円を加算した額を源泉徴収税額とする。
result = temp.add(new BigDecimal(8431));
}
} else if (selectDto.taxTableCode.equals(TAX_CODE_KOU)) {
// 税表区分
condTWithoutTaxTbl.taxTableKbn = TAX_CODE_KOU;
// 税表コードが甲
if (sumRewardAmount.compareTo(new BigDecimal(88000)) < 0) {
// 報酬金額が88000円未満の場合
} else {
if (sumRewardAmount.compareTo(new BigDecimal(88000)) >= 0
&& sumRewardAmount.compareTo(new BigDecimal(1010000)) < 0) {
// 報酬金額が88000円以上1010000円未満の場合
// 源泉徴収税額表を取得
selectResult = selectBySqlFile(TWithholdingTaxTable.class,
"/sql/MonthAccountCalcSelectWithholdingTax.sql", condTWithoutTaxTbl).get(0);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(1010000)) == 0) {
// 報酬金額が1010000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1010000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(1010000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(1250000)) < 0) {
// 報酬金額が1010000円より大きく1250000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1010000);
// （実際の報酬金額－1010000）
temp = sumRewardAmount.subtract(new BigDecimal(1010000));
// 32.1615%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.321615")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = temp.add(selectResult.taxAmount);
} else if (sumRewardAmount.compareTo(new BigDecimal(1250000)) == 0) {
// 報酬金額が1250000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1250000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(1250000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(1740000)) < 0) {
// 報酬金額が1250000円より大きく1740000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1250000);
// （実際の報酬金額－1250000）
temp = sumRewardAmount.subtract(new BigDecimal(1250000));
// 33.693%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.33693")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = (temp).add(selectResult.taxAmount);
} else if (sumRewardAmount.compareTo(new BigDecimal(1740000)) == 0) {
// 報酬金額が1740000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1740000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(1740000)) > 0) {
// 報酬金額が1740000円より大きい場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1740000);
// （実際の報酬金額－1740000）
temp = sumRewardAmount.subtract(new BigDecimal(1740000));
// 40.84%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.4084")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = (temp).add(selectResult.taxAmount);
}
// 扶養親族数が７人を超えた場合
if (dependentsNum > 7) {
// ７人を越えた分の扶養親族数 × 1610円を、上記で取得した源泉徴収税額より差引く
temp = new BigDecimal(dependentsNum - 7).multiply(new BigDecimal(1610));
result = result.subtract(temp);
}
}
// 税表コードが乙
} else if (selectDto.taxTableCode.equals(TAX_CODE_OTSU)) {
// 源泉徴収税額表を取得
// 「乙」では人数を検索条件としないため、nullを設定
condTWithoutTaxTbl.dependentsCount = null;
// 税表区分
condTWithoutTaxTbl.taxTableKbn = TAX_CODE_OTSU;
if (sumRewardAmount.compareTo(new BigDecimal(88000)) < 0) {
// 報酬金額が88000円未満の場合
// 報酬金額に3.063%を掛けた値を源泉徴収税額とする。
result = (sumRewardAmount).multiply(new BigDecimal("0.03063")).setScale(0, BigDecimal.ROUND_DOWN);
} else if (sumRewardAmount.compareTo(new BigDecimal(88000)) >= 0
&& sumRewardAmount.compareTo(new BigDecimal(1010000)) < 0) {
// 報酬金額が88000円以上1010000円未満の場合
// 該当する源泉徴収税額を取得する。
selectResult = selectBySqlFile(TWithholdingTaxTable.class,
"/sql/MonthAccountCalcSelectWithholdingTax.sql", condTWithoutTaxTbl).get(0);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(1010000)) == 0) {
// 報酬金額が1010000円の 場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1010000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(1010000)) > 0) {
// 報酬金額が1010000円より大きい 場合
// （実際の報酬金額－1010000）
temp = sumRewardAmount.subtract(new BigDecimal(1010000));
// 40.84%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.4084")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で算出した値に396700円を加算した額を源泉徴収税額とする。
result = temp.add(new BigDecimal(396700));
}
// 扶養親族数 × 1610円を、上記で取得した源泉徴収税額より差引く
temp = new BigDecimal(dependentsNum).multiply(new BigDecimal(1610));
result = result.subtract(temp);
}
if (result.compareTo(BigDecimal.ZERO) < 0) {
result = BigDecimal.ZERO;
}
return result;
}
/**
* 源泉徴収税額を算出（2016年01月以後用）
* @param selectDto 調査実績情報格納
* @param sumRewardAmount 報酬金額
* @return 源泉徴収税額の算出結果
*/
private BigDecimal calcTaxWithholdingOver2016(MonthAccountCalcTResearchRecordDto selectDto, BigDecimal sumRewardAmount) {
// 処理結果
BigDecimal result = BigDecimal.ZERO;
// 源泉徴収税額票の検索条件
MonthAccountCalcTWithholdingTaxTableDto condTWithoutTaxTbl = new MonthAccountCalcTWithholdingTaxTableDto();
// 年度
// 2016年（平成28年1月）より新たな源泉徴収税額となる為、
// 2016年1月～3月も2016年用を参照する様にする。
if (!StringUtil.isEmpty(selectDto.performYm) &&
201601 <= Integer.valueOf(selectDto.performYm) && Integer.valueOf(selectDto.performYm) <= 201603) {
condTWithoutTaxTbl.year = "2016";
} else {
condTWithoutTaxTbl.year = selectDto.targetYear;
}
// 以上
condTWithoutTaxTbl.greaterEqual = sumRewardAmount;
// 未満
condTWithoutTaxTbl.lessThan = sumRewardAmount;
// 扶養人数
int dependentsNum = getDependentsNum(selectDto);
if (dependentsNum > 7) {
condTWithoutTaxTbl.dependentsCount = 7;
} else {
condTWithoutTaxTbl.dependentsCount = (short) dependentsNum;
}
// 源泉徴収税額の検索結果
TWithholdingTaxTable selectResult;
// 計算時に使用する一時格納用
BigDecimal temp;
// 対象としている調査の単発調査区分が「１：単発」でかつ、同時期に非単発の調査を行っていない場合
if (selectDto.oneoffResearchKbn.equals(ONEOFF_RESEARCH_KBN_ONE) && selectDto.countOffResearch == 0) {
// 税表区分
condTWithoutTaxTbl.taxTableKbn = TAX_CODE_HEI;
// 日額マスタから取得
MonthAccountCalcMDailyAmountDto mDailyAmountDto = selectBySqlFile(MonthAccountCalcMDailyAmountDto.class,
"/sql/MonthAccountCalcSelectMDailyAmount.sql").get(0);
// 「丙」では人数を検索条件としないため、nullを設定
condTWithoutTaxTbl.dependentsCount = null;
// 以上
condTWithoutTaxTbl.greaterEqual = mDailyAmountDto.dailyAmount;
// 未満
condTWithoutTaxTbl.lessThan = mDailyAmountDto.dailyAmount;
if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(9300)) < 0) {
// 日額が9300円未満 の場合
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(9300)) >= 0
&& mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(33500)) < 0) {
// 日額が9300円以上33500円未満の場合
// 源泉徴収税額表を取得
selectResult = selectBySqlFile(TWithholdingTaxTable.class,
"/sql/MonthAccountCalcSelectWithholdingTax.sql", condTWithoutTaxTbl).get(0);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(33500)) == 0) {
// 日額が33500円 の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 33500);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(33500)) > 0
&& mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(57500)) < 0) {
// 日額が33500円より大きく57500円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 33500);
// （実際の報酬金額－33500）
temp = mDailyAmountDto.dailyAmount.subtract(new BigDecimal(33500));
// 25.525%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.25525")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = selectResult.taxAmount.add(temp);
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(57500)) == 0) {
// 日額が57500円 の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 57500);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(57500)) > 0
&& mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(118500)) < 0) {
// 日額が57500円より大きく118500円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 57500);
// （実際の報酬金額－57500）
temp = mDailyAmountDto.dailyAmount.subtract(new BigDecimal(57500));
// 33.693%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.33693")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = selectResult.taxAmount.add(temp);
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(118500)) == 0) {
// 日額が118500円 の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 118500);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(118500)) > 0) {
// 日額が118500円より大きい 場合
// （実際の報酬金額－118500）
temp = mDailyAmountDto.dailyAmount.subtract(new BigDecimal(118500));
// 40.84%を掛けた値を算出する。
temp = temp.multiply(new BigDecimal("0.4084")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で算出した値に29076円を加算した額を源泉徴収税額とする。
result = temp.add(new BigDecimal(29076));
}
} else if (selectDto.taxTableCode.equals(TAX_CODE_KOU)) {
// 税表区分
condTWithoutTaxTbl.taxTableKbn = TAX_CODE_KOU;
// 税表コードが甲
if (sumRewardAmount.compareTo(new BigDecimal(88000)) < 0) {
// 報酬金額が88000円未満の場合
} else {
if (sumRewardAmount.compareTo(new BigDecimal(88000)) >= 0
&& sumRewardAmount.compareTo(new BigDecimal(1010000)) < 0) {
// 報酬金額が88000円以上1010000円未満の場合
// 源泉徴収税額表を取得
selectResult = selectBySqlFile(TWithholdingTaxTable.class,
"/sql/MonthAccountCalcSelectWithholdingTax.sql", condTWithoutTaxTbl).get(0);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(1010000)) == 0) {
// 報酬金額が1010000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1010000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(1010000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(1720000)) < 0) {
// 報酬金額が1010000円より大きく1720000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1010000);
// （実際の報酬金額－1010000）
temp = sumRewardAmount.subtract(new BigDecimal(1010000));
// 33.693%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.33693")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = temp.add(selectResult.taxAmount);
} else if (sumRewardAmount.compareTo(new BigDecimal(1720000)) == 0) {
// 報酬金額が1720000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1720000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(1720000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(3560000)) < 0) {
// 報酬金額が1720000円より大きく3560000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1720000);
// （実際の報酬金額－1720000）
temp = sumRewardAmount.subtract(new BigDecimal(1720000));
// 40.84%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.4084")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = (temp).add(selectResult.taxAmount);
} else if (sumRewardAmount.compareTo(new BigDecimal(3560000)) == 0) {
// 報酬金額が3560000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 3560000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(3560000)) > 0) {
// 報酬金額が3560000円より大きい場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 3560000);
// （実際の報酬金額－3560000）
temp = sumRewardAmount.subtract(new BigDecimal(3560000));
// 45.945%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.45945")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = (temp).add(selectResult.taxAmount);
}
// 扶養親族数が７人を超えた場合
if (dependentsNum > 7) {
// ７人を越えた分の扶養親族数 × 1610円を、上記で取得した源泉徴収税額より差引く
temp = new BigDecimal(dependentsNum - 7).multiply(new BigDecimal(1610));
result = result.subtract(temp);
}
}
} else if (selectDto.taxTableCode.equals(TAX_CODE_OTSU)) {
// 税表コードが乙
// 税表区分
condTWithoutTaxTbl.taxTableKbn = TAX_CODE_OTSU;
// 「乙」では人数を検索条件としないため、nullを設定
condTWithoutTaxTbl.dependentsCount = null;
if (sumRewardAmount.compareTo(new BigDecimal(88000)) < 0) {
// 報酬金額が88000円未満の場合
// 報酬金額に3.063%を掛けた値を源泉徴収税額とする。
result = (sumRewardAmount).multiply(new BigDecimal("0.03063")).setScale(0, BigDecimal.ROUND_DOWN);
} else if (sumRewardAmount.compareTo(new BigDecimal(88000)) >= 0
&& sumRewardAmount.compareTo(new BigDecimal(1010000)) < 0) {
// 報酬金額が88000円以上1010000円未満の場合
// 該当する源泉徴収税額を取得する。
selectResult = selectBySqlFile(TWithholdingTaxTable.class,
"/sql/MonthAccountCalcSelectWithholdingTax.sql", condTWithoutTaxTbl).get(0);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(1010000)) == 0) {
// 報酬金額が1010000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1010000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(1010000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(1720000)) < 0) {
// 報酬金額が1010000円より大きく1720000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1010000);
// （実際の報酬金額－1010000）
temp = sumRewardAmount.subtract(new BigDecimal(1010000));
// 40.84%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.4084")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = (temp).add(selectResult.taxAmount);
} else if (sumRewardAmount.compareTo(new BigDecimal(1720000)) == 0) {
// 報酬金額が1720000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1720000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(1720000)) > 0) {
// 報酬金額が1720000円より大きい 場合
// （実際の報酬金額－1720000）
temp = sumRewardAmount.subtract(new BigDecimal(1720000));
// 45.945%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.45945")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で算出した値に687600円を加算した額を源泉徴収税額とする。
result = temp.add(new BigDecimal(687600));
}
// 扶養親族数 × 1610円を、上記で取得した源泉徴収税額より差引く
temp = new BigDecimal(dependentsNum).multiply(new BigDecimal(1610));
result = result.subtract(temp);
}
if (result.compareTo(BigDecimal.ZERO) < 0) {
result = BigDecimal.ZERO;
}
return result;
}
/**
* 源泉徴収税額を算出（2017年02月以後用）
* @param selectDto 調査実績情報格納
* @param sumRewardAmount 報酬金額
* @return 源泉徴収税額の算出結果
*/
private BigDecimal calcTaxWithholdingOver201702(MonthAccountCalcTResearchRecordDto selectDto, BigDecimal sumRewardAmount) {
// 処理結果
BigDecimal result = BigDecimal.ZERO;
// 源泉徴収税額票の検索条件
MonthAccountCalcTWithholdingTaxTableDto condTWithoutTaxTbl = new MonthAccountCalcTWithholdingTaxTableDto();
// 年度
// 2017年（平成29年2月）より新たな源泉徴収税額となる為、
// 2017年2月～3月も2017年用を参照する様にする。
if (!StringUtil.isEmpty(selectDto.performYm) &&
201702 <= Integer.valueOf(selectDto.performYm) && Integer.valueOf(selectDto.performYm) <= 201703) {
condTWithoutTaxTbl.year = "2017";
} else {
condTWithoutTaxTbl.year = selectDto.targetYear;
}
// 以上
condTWithoutTaxTbl.greaterEqual = sumRewardAmount;
// 未満
condTWithoutTaxTbl.lessThan = sumRewardAmount;
// 扶養人数
int dependentsNum = getDependentsNum(selectDto);
if (dependentsNum > 7) {
condTWithoutTaxTbl.dependentsCount = 7;
} else {
condTWithoutTaxTbl.dependentsCount = (short) dependentsNum;
}
// 源泉徴収税額の検索結果
TWithholdingTaxTable selectResult;
// 計算時に使用する一時格納用
BigDecimal temp;
// 対象としている調査の単発調査区分が「１：単発」でかつ、同時期に非単発の調査を行っていない場合
if (selectDto.oneoffResearchKbn.equals(ONEOFF_RESEARCH_KBN_ONE) && selectDto.countOffResearch == 0) {
// 税表区分
condTWithoutTaxTbl.taxTableKbn = TAX_CODE_HEI;
// 日額マスタから取得
MonthAccountCalcMDailyAmountDto mDailyAmountDto = selectBySqlFile(MonthAccountCalcMDailyAmountDto.class,
"/sql/MonthAccountCalcSelectMDailyAmount.sql").get(0);
// 「丙」では人数を検索条件としないため、nullを設定
condTWithoutTaxTbl.dependentsCount = null;
// 以上
condTWithoutTaxTbl.greaterEqual = mDailyAmountDto.dailyAmount;
// 未満
condTWithoutTaxTbl.lessThan = mDailyAmountDto.dailyAmount;
if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(9300)) < 0) {
// 日額が9300円未満の場合
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(9300)) >= 0
&& mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(28000)) < 0) {
// 日額が9300円以上28000円未満の場合
// 源泉徴収税額表を取得
selectResult = selectBySqlFile(TWithholdingTaxTable.class,
"/sql/MonthAccountCalcSelectWithholdingTax.sql", condTWithoutTaxTbl).get(0);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(28000)) == 0) {
// 日額が28000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 28000);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(28000)) > 0
&& mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(32000)) < 0) {
// 日額が28000円より大きく32000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 28000);
// （実際の報酬金額－28000）
temp = mDailyAmountDto.dailyAmount.subtract(new BigDecimal(28000));
// 20.42%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.2042")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = selectResult.taxAmount.add(temp);
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(32000)) == 0) {
// 日額が32000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 32000);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(32000)) > 0
&& mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(57000)) < 0) {
// 日額が32000円より大きく57000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 32000);
// （実際の報酬金額－32000）
temp = mDailyAmountDto.dailyAmount.subtract(new BigDecimal(32000));
// 24.504%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.24504")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = selectResult.taxAmount.add(temp);
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(57000)) == 0) {
// 日額が57000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 57000);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(57000)) > 0
&& mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(118500)) < 0) {
// 日額が57000円より大きく118500円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 57000);
// （実際の報酬金額－57000）
temp = mDailyAmountDto.dailyAmount.subtract(new BigDecimal(57000));
// 33.693%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.33693")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = selectResult.taxAmount.add(temp);
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(118500)) == 0) {
// 日額が118500円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 118500);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(118500)) > 0) {
// 日額が118500円より大きい場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 118500);
// （実際の報酬金額－118500）
temp = mDailyAmountDto.dailyAmount.subtract(new BigDecimal(118500));
// 40.84%を掛けた値を算出する。
temp = temp.multiply(new BigDecimal("0.4084")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = selectResult.taxAmount.add(temp);
}
} else if (selectDto.taxTableCode.equals(TAX_CODE_KOU)) {
// 税表区分
condTWithoutTaxTbl.taxTableKbn = TAX_CODE_KOU;
// 税表コードが甲
if (sumRewardAmount.compareTo(new BigDecimal(88000)) < 0) {
// 報酬金額が88000円未満の場合
} else {
if (sumRewardAmount.compareTo(new BigDecimal(88000)) >= 0
&& sumRewardAmount.compareTo(new BigDecimal(860000)) < 0) {
// 報酬金額が88000円以上860000円未満の場合
// 源泉徴収税額表を取得
selectResult = selectBySqlFile(TWithholdingTaxTable.class,
"/sql/MonthAccountCalcSelectWithholdingTax.sql", condTWithoutTaxTbl).get(0);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(860000)) == 0) {
// 報酬金額が860000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 860000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(860000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(970000)) < 0) {
// 報酬金額が860000円より大きく970000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 860000);
// （実際の報酬金額－860000）
temp = sumRewardAmount.subtract(new BigDecimal(860000));
// 23.483%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.23483")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = temp.add(selectResult.taxAmount);
} else if (sumRewardAmount.compareTo(new BigDecimal(970000)) == 0) {
// 報酬金額が970000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 970000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(970000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(1720000)) < 0) {
// 報酬金額が970000円より大きく1720000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 970000);
// （実際の報酬金額－970000）
temp = sumRewardAmount.subtract(new BigDecimal(970000));
// 33.693%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.33693")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = (temp).add(selectResult.taxAmount);
} else if (sumRewardAmount.compareTo(new BigDecimal(1720000)) == 0) {
// 報酬金額が1720000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1720000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(1720000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(3550000)) < 0) {
// 報酬金額が1720000円より大きく3550000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1720000);
// （実際の報酬金額－1720000）
temp = sumRewardAmount.subtract(new BigDecimal(1720000));
// 40.84%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.4084")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = (temp).add(selectResult.taxAmount);
} else if (sumRewardAmount.compareTo(new BigDecimal(3550000)) == 0) {
// 報酬金額が3550000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 3550000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(3550000)) > 0) {
// 報酬金額が3550000円より大きい場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 3550000);
// （実際の報酬金額－3550000）
temp = sumRewardAmount.subtract(new BigDecimal(3550000));
// 45.945%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.45945")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = (temp).add(selectResult.taxAmount);
}
// 扶養親族数が７人を超えた場合
if (dependentsNum > 7) {
// ７人を越えた分の扶養親族数 × 1610円を、上記で取得した源泉徴収税額より差引く
temp = new BigDecimal(dependentsNum - 7).multiply(new BigDecimal(1610));
result = result.subtract(temp);
}
}
} else if (selectDto.taxTableCode.equals(TAX_CODE_OTSU)) {
// 税表コードが乙
// 税表区分
condTWithoutTaxTbl.taxTableKbn = TAX_CODE_OTSU;
// 「乙」では人数を検索条件としないため、nullを設定
condTWithoutTaxTbl.dependentsCount = null;
if (sumRewardAmount.compareTo(new BigDecimal(88000)) < 0) {
// 報酬金額が88000円未満の場合
// 報酬金額に3.063%を掛けた値を源泉徴収税額とする。
result = (sumRewardAmount).multiply(new BigDecimal("0.03063")).setScale(0, BigDecimal.ROUND_DOWN);
} else if (sumRewardAmount.compareTo(new BigDecimal(88000)) >= 0
&& sumRewardAmount.compareTo(new BigDecimal(860000)) < 0) {
// 報酬金額が88000円以上860000円未満の場合
// 該当する源泉徴収税額を取得する。
selectResult = selectBySqlFile(TWithholdingTaxTable.class,
"/sql/MonthAccountCalcSelectWithholdingTax.sql", condTWithoutTaxTbl).get(0);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(860000)) == 0) {
// 報酬金額が860000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 860000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(860000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(1720000)) < 0) {
// 報酬金額が860000円より大きく1720000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 860000);
// （実際の報酬金額－860000）
temp = sumRewardAmount.subtract(new BigDecimal(860000));
// 40.84%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.4084")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = (temp).add(selectResult.taxAmount);
} else if (sumRewardAmount.compareTo(new BigDecimal(1720000)) == 0) {
// 報酬金額が1720000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1720000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(1720000)) > 0) {
// 報酬金額が1720000円より大きい 場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1720000);
// （実際の報酬金額－1720000）
temp = sumRewardAmount.subtract(new BigDecimal(1720000));
// 45.945%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.45945")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = temp.add(selectResult.taxAmount);
}
// 扶養親族数 × 1610円を、上記で取得した源泉徴収税額より差引く
temp = new BigDecimal(dependentsNum).multiply(new BigDecimal(1610));
result = result.subtract(temp);
}
if (result.compareTo(BigDecimal.ZERO) < 0) {
result = BigDecimal.ZERO;
}
return result;
}
/**
* 源泉徴収税額を算出（2018年01月以後用）
* @param selectDto 調査実績情報格納
* @param sumRewardAmount 報酬金額
* @return 源泉徴収税額の算出結果
*/
private BigDecimal calcTaxWithholdingOver2018(MonthAccountCalcTResearchRecordDto selectDto, BigDecimal sumRewardAmount) {
// 処理結果
BigDecimal result = BigDecimal.ZERO;
// 源泉徴収税額票の検索条件
MonthAccountCalcTWithholdingTaxTableDto condTWithoutTaxTbl = new MonthAccountCalcTWithholdingTaxTableDto();
// 年度
// 2018年（平成30年1月）より新たな源泉徴収税額となるが、
// 2017年度版と変わらない為、2018年1月～4月は継続して2017年用を使用する様にする。（年度切替は5月に実施）
if (!StringUtil.isEmpty(selectDto.performYm) &&
201801 <= Integer.valueOf(selectDto.performYm) && Integer.valueOf(selectDto.performYm) <= 201804) {
condTWithoutTaxTbl.year = "2017";
} else {
condTWithoutTaxTbl.year = selectDto.targetYear;
}
// 以上
condTWithoutTaxTbl.greaterEqual = sumRewardAmount;
// 未満
condTWithoutTaxTbl.lessThan = sumRewardAmount;
// 扶養人数
int dependentsNum = getDependentsNum2018(selectDto);
if (dependentsNum > 7) {
condTWithoutTaxTbl.dependentsCount = 7;
} else {
condTWithoutTaxTbl.dependentsCount = (short) dependentsNum;
}
// 源泉徴収税額の検索結果
TWithholdingTaxTable selectResult;
// 計算時に使用する一時格納用
BigDecimal temp;
// 対象としている調査の単発調査区分が「１：単発」でかつ、同時期に非単発の調査を行っていない場合
if (selectDto.oneoffResearchKbn.equals(ONEOFF_RESEARCH_KBN_ONE) && selectDto.countOffResearch == 0) {
// 税表区分
condTWithoutTaxTbl.taxTableKbn = TAX_CODE_HEI;
// 日額マスタから取得
MonthAccountCalcMDailyAmountDto mDailyAmountDto = selectBySqlFile(MonthAccountCalcMDailyAmountDto.class,
"/sql/MonthAccountCalcSelectMDailyAmount.sql").get(0);
// 「丙」では人数を検索条件としないため、nullを設定
condTWithoutTaxTbl.dependentsCount = null;
// 以上
condTWithoutTaxTbl.greaterEqual = mDailyAmountDto.dailyAmount;
// 未満
condTWithoutTaxTbl.lessThan = mDailyAmountDto.dailyAmount;
if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(9300)) < 0) {
// 日額が9300円未満の場合
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(9300)) >= 0
&& mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(28000)) < 0) {
// 日額が9300円以上28000円未満の場合
// 源泉徴収税額表を取得
selectResult = selectBySqlFile(TWithholdingTaxTable.class,
"/sql/MonthAccountCalcSelectWithholdingTax.sql", condTWithoutTaxTbl).get(0);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(28000)) == 0) {
// 日額が28000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 28000);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(28000)) > 0
&& mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(32000)) < 0) {
// 日額が28000円より大きく32000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 28000);
// （実際の報酬金額－28000）
temp = mDailyAmountDto.dailyAmount.subtract(new BigDecimal(28000));
// 20.42%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.2042")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = selectResult.taxAmount.add(temp);
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(32000)) == 0) {
// 日額が32000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 32000);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(32000)) > 0
&& mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(57000)) < 0) {
// 日額が32000円より大きく57000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 32000);
// （実際の報酬金額－32000）
temp = mDailyAmountDto.dailyAmount.subtract(new BigDecimal(32000));
// 24.504%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.24504")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = selectResult.taxAmount.add(temp);
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(57000)) == 0) {
// 日額が57000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 57000);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(57000)) > 0
&& mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(118500)) < 0) {
// 日額が57000円より大きく118500円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 57000);
// （実際の報酬金額－57000）
temp = mDailyAmountDto.dailyAmount.subtract(new BigDecimal(57000));
// 33.693%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.33693")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = selectResult.taxAmount.add(temp);
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(118500)) == 0) {
// 日額が118500円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 118500);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(118500)) > 0) {
// 日額が118500円より大きい場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 118500);
// （実際の報酬金額－118500）
temp = mDailyAmountDto.dailyAmount.subtract(new BigDecimal(118500));
// 40.84%を掛けた値を算出する。
temp = temp.multiply(new BigDecimal("0.4084")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = selectResult.taxAmount.add(temp);
}
} else if (selectDto.taxTableCode.equals(TAX_CODE_KOU)) {
// 税表区分
condTWithoutTaxTbl.taxTableKbn = TAX_CODE_KOU;
// 税表コードが甲
if (sumRewardAmount.compareTo(new BigDecimal(88000)) < 0) {
// 報酬金額が88000円未満の場合
} else {
if (sumRewardAmount.compareTo(new BigDecimal(88000)) >= 0
&& sumRewardAmount.compareTo(new BigDecimal(860000)) < 0) {
// 報酬金額が88000円以上860000円未満の場合
// 源泉徴収税額表を取得
selectResult = selectBySqlFile(TWithholdingTaxTable.class,
"/sql/MonthAccountCalcSelectWithholdingTax.sql", condTWithoutTaxTbl).get(0);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(860000)) == 0) {
// 報酬金額が860000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 860000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(860000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(970000)) < 0) {
// 報酬金額が860000円より大きく970000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 860000);
// （実際の報酬金額－860000）
temp = sumRewardAmount.subtract(new BigDecimal(860000));
// 23.483%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.23483")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = temp.add(selectResult.taxAmount);
} else if (sumRewardAmount.compareTo(new BigDecimal(970000)) == 0) {
// 報酬金額が970000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 970000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(970000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(1720000)) < 0) {
// 報酬金額が970000円より大きく1720000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 970000);
// （実際の報酬金額－970000）
temp = sumRewardAmount.subtract(new BigDecimal(970000));
// 33.693%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.33693")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = (temp).add(selectResult.taxAmount);
} else if (sumRewardAmount.compareTo(new BigDecimal(1720000)) == 0) {
// 報酬金額が1720000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1720000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(1720000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(3550000)) < 0) {
// 報酬金額が1720000円より大きく3550000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1720000);
// （実際の報酬金額－1720000）
temp = sumRewardAmount.subtract(new BigDecimal(1720000));
// 40.84%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.4084")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = (temp).add(selectResult.taxAmount);
} else if (sumRewardAmount.compareTo(new BigDecimal(3550000)) == 0) {
// 報酬金額が3550000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 3550000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(3550000)) > 0) {
// 報酬金額が3550000円より大きい場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 3550000);
// （実際の報酬金額－3550000）
temp = sumRewardAmount.subtract(new BigDecimal(3550000));
// 45.945%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.45945")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = (temp).add(selectResult.taxAmount);
}
// 扶養親族数が７人を超えた場合
if (dependentsNum > 7) {
// ７人を越えた分の扶養親族数 × 1610円を、上記で取得した源泉徴収税額より差引く
temp = new BigDecimal(dependentsNum - 7).multiply(new BigDecimal(1610));
result = result.subtract(temp);
}
}
} else if (selectDto.taxTableCode.equals(TAX_CODE_OTSU)) {
// 税表コードが乙
// 税表区分
condTWithoutTaxTbl.taxTableKbn = TAX_CODE_OTSU;
// 「乙」では人数を検索条件としないため、nullを設定
condTWithoutTaxTbl.dependentsCount = null;
if (sumRewardAmount.compareTo(new BigDecimal(88000)) < 0) {
// 報酬金額が88000円未満の場合
// 報酬金額に3.063%を掛けた値を源泉徴収税額とする。
result = (sumRewardAmount).multiply(new BigDecimal("0.03063")).setScale(0, BigDecimal.ROUND_DOWN);
} else if (sumRewardAmount.compareTo(new BigDecimal(88000)) >= 0
&& sumRewardAmount.compareTo(new BigDecimal(860000)) < 0) {
// 報酬金額が88000円以上860000円未満の場合
// 該当する源泉徴収税額を取得する。
selectResult = selectBySqlFile(TWithholdingTaxTable.class,
"/sql/MonthAccountCalcSelectWithholdingTax.sql", condTWithoutTaxTbl).get(0);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(860000)) == 0) {
// 報酬金額が860000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 860000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(860000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(1720000)) < 0) {
// 報酬金額が860000円より大きく1720000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 860000);
// （実際の報酬金額－860000）
temp = sumRewardAmount.subtract(new BigDecimal(860000));
// 40.84%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.4084")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = (temp).add(selectResult.taxAmount);
} else if (sumRewardAmount.compareTo(new BigDecimal(1720000)) == 0) {
// 報酬金額が1720000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1720000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(1720000)) > 0) {
// 報酬金額が1720000円より大きい 場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1720000);
// （実際の報酬金額－1720000）
temp = sumRewardAmount.subtract(new BigDecimal(1720000));
// 45.945%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.45945")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = temp.add(selectResult.taxAmount);
}
// 扶養親族数 × 1610円を、上記で取得した源泉徴収税額より差引く
temp = new BigDecimal(dependentsNum).multiply(new BigDecimal(1610));
result = result.subtract(temp);
}
if (result.compareTo(BigDecimal.ZERO) < 0) {
result = BigDecimal.ZERO;
}
return result;
}
/**
* 源泉徴収税額を算出（2020年01月以後用）
* @param selectDto 調査実績情報格納
* @param sumRewardAmount 報酬金額
* @return 源泉徴収税額の算出結果
*/
private BigDecimal calcTaxWithholdingOver2020(MonthAccountCalcTResearchRecordDto selectDto, BigDecimal sumRewardAmount) {
// 処理結果
BigDecimal result = BigDecimal.ZERO;
// 源泉徴収税額票の検索条件
MonthAccountCalcTWithholdingTaxTableDto condTWithoutTaxTbl = new MonthAccountCalcTWithholdingTaxTableDto();
// 年度
// 2020年（令和2年）より新たな源泉徴収税額となる
if (!StringUtil.isEmpty(selectDto.performYm) &&
202001 <= Integer.valueOf(selectDto.performYm) && Integer.valueOf(selectDto.performYm) <= 202004) {
condTWithoutTaxTbl.year = "2020";
} else {
condTWithoutTaxTbl.year = selectDto.targetYear;
}
// 以上
condTWithoutTaxTbl.greaterEqual = sumRewardAmount;
// 未満
condTWithoutTaxTbl.lessThan = sumRewardAmount;
// 扶養人数
int dependentsNum = getDependentsNum2018(selectDto);
if (dependentsNum > 7) {
condTWithoutTaxTbl.dependentsCount = 7;
} else {
condTWithoutTaxTbl.dependentsCount = (short) dependentsNum;
}
// 源泉徴収税額の検索結果
TWithholdingTaxTable selectResult;
// 計算時に使用する一時格納用
BigDecimal temp;
// 対象としている調査の単発調査区分が「１：単発」でかつ、同時期に非単発の調査を行っていない場合
if (selectDto.oneoffResearchKbn.equals(ONEOFF_RESEARCH_KBN_ONE) && selectDto.countOffResearch == 0) {
// 税表区分
condTWithoutTaxTbl.taxTableKbn = TAX_CODE_HEI;
// 日額マスタから取得
MonthAccountCalcMDailyAmountDto mDailyAmountDto = selectBySqlFile(MonthAccountCalcMDailyAmountDto.class,
"/sql/MonthAccountCalcSelectMDailyAmount.sql").get(0);
// 「丙」では人数を検索条件としないため、nullを設定
condTWithoutTaxTbl.dependentsCount = null;
// 以上
condTWithoutTaxTbl.greaterEqual = mDailyAmountDto.dailyAmount;
// 未満
condTWithoutTaxTbl.lessThan = mDailyAmountDto.dailyAmount;
if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(9300)) < 0) {
// 日額が9300円未満の場合
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(9300)) >= 0
&& mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(24000)) < 0) {
// 日額が9300円以上24000円未満の場合
// 源泉徴収税額表を取得
selectResult = selectBySqlFile(TWithholdingTaxTable.class,
"/sql/MonthAccountCalcSelectWithholdingTax.sql", condTWithoutTaxTbl).get(0);
result = selectResult.taxAmount;
}else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(24000)) == 0) {
// 日額が24000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 24000);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(24000)) > 0
&& mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(26000)) < 0) {
// 日額が24000円より大きく26000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 24000);
// （実際の報酬金額－24000）
temp = mDailyAmountDto.dailyAmount.subtract(new BigDecimal(24000));
//10.21%をかけた値を算出
temp = temp.multiply(new BigDecimal("0.1021")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = selectResult.taxAmount.add(temp);
}else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(26000)) == 0) {
// 日額が26000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 26000);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(26000)) > 0
&& mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(32000)) < 0) {
// 26000円より大きく32000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 26000);
// （実際の報酬金額－26000）
temp = mDailyAmountDto.dailyAmount.subtract(new BigDecimal(26000));
// 20.42%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.2042")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = selectResult.taxAmount.add(temp);
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(32000)) == 0) {
// 日額が32000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 32000);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(32000)) > 0
&& mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(57000)) < 0) {
// 日額が32000円より大きく57000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 32000);
// （実際の報酬金額－32000）
temp = mDailyAmountDto.dailyAmount.subtract(new BigDecimal(32000));
// 25.525%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.25525")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = selectResult.taxAmount.add(temp);
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(57000)) == 0) {
// 日額が57000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 57000);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(57000)) > 0
&& mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(116500)) < 0) {
// 57000円より大きく116500円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 57000);
// （実際の報酬金額－57000）
temp = mDailyAmountDto.dailyAmount.subtract(new BigDecimal(57000));
// 33.693%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.33693")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = selectResult.taxAmount.add(temp);
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(116500)) == 0) {
// 日額が116500円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 116500);
result = selectResult.taxAmount;
} else if (mDailyAmountDto.dailyAmount.compareTo(new BigDecimal(116500)) > 0) {
// 日額が116500円より大きい場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 116500);
// （実際の報酬金額－116500）
temp = mDailyAmountDto.dailyAmount.subtract(new BigDecimal(116500));
// 40.84%を掛けた値を算出する。
temp = temp.multiply(new BigDecimal("0.4084")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = selectResult.taxAmount.add(temp);
}
} else if (selectDto.taxTableCode.equals(TAX_CODE_KOU)) {
// 税表区分
condTWithoutTaxTbl.taxTableKbn = TAX_CODE_KOU;
// 税表コードが甲
if (sumRewardAmount.compareTo(new BigDecimal(88000)) < 0) {
// 報酬金額が88000円未満の場合
} else {
if (sumRewardAmount.compareTo(new BigDecimal(88000)) >= 0
&& sumRewardAmount.compareTo(new BigDecimal(740000)) < 0) {
// 報酬金額が88000円以上740000円未満の場合
// 源泉徴収税額表を取得
selectResult = selectBySqlFile(TWithholdingTaxTable.class,
"/sql/MonthAccountCalcSelectWithholdingTax.sql", condTWithoutTaxTbl).get(0);
result = selectResult.taxAmount;
} else if(sumRewardAmount.compareTo(new BigDecimal(740000)) == 0){
// 報酬金額が740000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 740000);
result = selectResult.taxAmount;
}else if (sumRewardAmount.compareTo(new BigDecimal(740000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(780000)) < 0) {
// 報酬金額が740000円より大きく780000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 740000);
// （実際の報酬金額－740000）
temp = sumRewardAmount.subtract(new BigDecimal(740000));
// 20.42%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.2042")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = temp.add(selectResult.taxAmount);
} else if (sumRewardAmount.compareTo(new BigDecimal(780000)) == 0) {
// 報酬金額が780000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 780000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(780000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(950000)) < 0) {
// 報酬金額が780000円より大きく950000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 780000);
// （実際の報酬金額－780000）
temp = sumRewardAmount.subtract(new BigDecimal(780000));
// 23.483%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.23483")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = temp.add(selectResult.taxAmount);
} else if (sumRewardAmount.compareTo(new BigDecimal(950000)) == 0) {
// 報酬金額が950000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 950000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(950000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(1700000)) < 0) {
// 報酬金額が950000円より大きく1700000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 950000);
// （実際の報酬金額－950000）
temp = sumRewardAmount.subtract(new BigDecimal(950000));
// 33.693%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.33693")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = (temp).add(selectResult.taxAmount);
} else if (sumRewardAmount.compareTo(new BigDecimal(1700000)) == 0) {
// 報酬金額が1700000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1700000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(1700000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(2170000)) < 0) {
// 報酬金額が1700000円より大きく2170000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1700000);
// （実際の報酬金額－1700000）
temp = sumRewardAmount.subtract(new BigDecimal(1700000));
// 40.84%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.4084")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = (temp).add(selectResult.taxAmount);
} else if (sumRewardAmount.compareTo(new BigDecimal(2170000)) == 0) {
// 報酬金額が2170000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 2170000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(2170000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(2210000)) < 0) {
// 報酬金額が2170000円より大きく2210000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 2170000);
// （実際の報酬金額－2170000）
temp = sumRewardAmount.subtract(new BigDecimal(2170000));
// 40.84%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.4084")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = (temp).add(selectResult.taxAmount);
} else if (sumRewardAmount.compareTo(new BigDecimal(2210000)) == 0) {
// 報酬金額が2210000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 2210000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(2210000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(2250000)) < 0) {
// 報酬金額が2210000円より大きく2250000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 2210000);
// （実際の報酬金額－2210000）
temp = sumRewardAmount.subtract(new BigDecimal(2210000));
// 40.84%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.4084")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = (temp).add(selectResult.taxAmount);
} else if (sumRewardAmount.compareTo(new BigDecimal(2250000)) == 0) {
// 報酬金額が2250000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 2250000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(2250000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(3500000)) < 0) {
// 報酬金額が2250000円より大きく3500000円未満の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 2250000);
// （実際の報酬金額－2250000）
temp = sumRewardAmount.subtract(new BigDecimal(2250000));
// 40.84%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.4084")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = (temp).add(selectResult.taxAmount);
} else if (sumRewardAmount.compareTo(new BigDecimal(3500000)) == 0) {
// 報酬金額が3500000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 3500000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(3500000)) > 0) {
// 報酬金額が3500000円より大きい場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 3500000);
// （実際の報酬金額－3500000）
temp = sumRewardAmount.subtract(new BigDecimal(3500000));
// 45.945%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.45945")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = (temp).add(selectResult.taxAmount);
}
// 扶養親族数が７人を超えた場合
if (dependentsNum > 7) {
// ７人を越えた分の扶養親族数 × 1610円を、上記で取得した源泉徴収税額より差引く
temp = new BigDecimal(dependentsNum - 7).multiply(new BigDecimal(1610));
result = result.subtract(temp);
}
}
} else if (selectDto.taxTableCode.equals(TAX_CODE_OTSU)) {
// 税表コードが乙
// 税表区分
condTWithoutTaxTbl.taxTableKbn = TAX_CODE_OTSU;
// 「乙」では人数を検索条件としないため、nullを設定
condTWithoutTaxTbl.dependentsCount = null;
if (sumRewardAmount.compareTo(new BigDecimal(88000)) < 0) {
// 報酬金額が88000円未満の場合
// 報酬金額に3.063%を掛けた値を源泉徴収税額とする。
result = (sumRewardAmount).multiply(new BigDecimal("0.03063")).setScale(0, BigDecimal.ROUND_DOWN);
} else if (sumRewardAmount.compareTo(new BigDecimal(88000)) >= 0
&& sumRewardAmount.compareTo(new BigDecimal(740000)) < 0) {
// 報酬金額が88000円以上740000円以下の場合
// 該当する源泉徴収税額を取得する。
selectResult = selectBySqlFile(TWithholdingTaxTable.class,
"/sql/MonthAccountCalcSelectWithholdingTax.sql", condTWithoutTaxTbl).get(0);
result = selectResult.taxAmount;
} else if(sumRewardAmount.compareTo(new BigDecimal(740000)) == 0){
// 報酬金額が740000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 740000);
result = selectResult.taxAmount;
}
else if (sumRewardAmount.compareTo(new BigDecimal(740000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(1700000)) < 0) {
// 報酬金額が740000円より大きく1700000円未満の場合
// 該当する源泉徴収税額を取得する。
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 740000);
// （実際の報酬金額－740000）
temp = sumRewardAmount.subtract(new BigDecimal(740000));
// 40.84%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.4084")).setScale(0, BigDecimal.ROUND_DOWN);
result = temp.add(selectResult.taxAmount);
} else if (sumRewardAmount.compareTo(new BigDecimal(1700000)) == 0) {
// 報酬金額が1700000円の場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1700000);
result = selectResult.taxAmount;
} else if (sumRewardAmount.compareTo(new BigDecimal(1700000)) > 0
&& sumRewardAmount.compareTo(new BigDecimal(3500000)) < 0) {
// 報酬金額が1700000円より大きく3500000円未満の場合
// 該当する源泉徴収税額を取得する。
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1700000);
// （実際の報酬金額－1700000）
temp = sumRewardAmount.subtract(new BigDecimal(1700000));
// 45.945%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.45945")).setScale(0, BigDecimal.ROUND_DOWN);
result = temp.add(selectResult.taxAmount);
}else if (sumRewardAmount.compareTo(new BigDecimal(3500000)) >= 0) {
// 報酬金額が3500000円より大きい 場合
// 源泉徴収税額表を取得
selectResult = findWithholdingTaxByAmount(condTWithoutTaxTbl, 1700000);
// （実際の報酬金額－1700000）
temp = sumRewardAmount.subtract(new BigDecimal(1700000));
// 45.945%を掛けた値を算出
temp = temp.multiply(new BigDecimal("0.45945")).setScale(0, BigDecimal.ROUND_DOWN);
// 上記で取得した源泉徴収税額に加算する。
result = temp.add(selectResult.taxAmount);
}
// 扶養親族数 × 1610円を、上記で取得した源泉徴収税額より差引く
temp = new BigDecimal(dependentsNum).multiply(new BigDecimal(1610));
result = result.subtract(temp);
}
if (result.compareTo(BigDecimal.ZERO) < 0) {
result = BigDecimal.ZERO;
}
return result;
}
/**
* 源泉徴収税額表のレコードを取得する<br/>
* （主に金額を直接指定して取得する場合に使用する）
*
* @param condition 本来の源泉徴収税額表検索条件
* @param amount 指定金額
* @return 源泉徴収税額表レコード
*/
private TWithholdingTaxTable findWithholdingTaxByAmount(MonthAccountCalcTWithholdingTaxTableDto condition,
int amount) {
// 源泉徴収税額表を取得
condition.equal = new BigDecimal(amount);
TWithholdingTaxTable result = selectOneBySqlFile(TWithholdingTaxTable.class,
"/sql/MonthAccountCalcSelectWithholdingTaxByAmount.sql", condition);
condition.equal = null;
return result;
}
/**
* 扶養親族等の数を取得（2017年12月迄用）
* @param selectDto 調査実績情報格納
* @return 扶養親族等の数
*/
private int getDependentsNum(MonthAccountCalcTResearchRecordDto selectDto) {
int num = 0;
// 扶養親族配偶者
String strDependentsRelSpouse = "";
if (!StringUtil.isEmpty(selectDto.dependentsRelSpouse)) {
strDependentsRelSpouse = selectDto.dependentsRelSpouse;
}
switch (strDependentsRelSpouse) {
case "1":
num = num + 1;
break;
case "2":
num = num + 1;
break;
case "3":
num = num + 3;
break;
case "4":
num = num + 3;
break;
case "5":
num = num + 2;
break;
case "6":
num = num + 2;
break;
case "7":
num = num + 2;
break;
case "8":
num = num + 2;
break;
default:
break;
}
// 扶養親族その他
num = num + TsttUtil.convNullToZeroForInt(selectDto.dependentsRelOther);
// 扶養親族障害者
num = num + TsttUtil.convNullToZeroForInt(selectDto.dependentsRelDisabilities);
// 扶養親族同居特障
num = num + TsttUtil.convNullToZeroForInt(selectDto.dependentsRelLodger);
// 自己控除該当
String strSelfDeductApplicable = "";
if (!StringUtil.isEmpty(selectDto.selfDeductApplicable)) {
strSelfDeductApplicable = selectDto.selfDeductApplicable;
}
switch (strSelfDeductApplicable) {
case "0":
break;
case "1":
num = num + 1;
break;
case "2":
num = num + 1;
break;
case "3":
num = num + 1;
break;
case "4":
num = num + 1;
break;
case "5":
num = num + 2;
break;
case "6":
num = num + 2;
break;
case "7":
num = num + 2;
break;
case "8":
num = num + 2;
break;
case "9":
num = num + 2;
break;
case "A":
num = num + 3;
break;
case "B":
num = num + 3;
break;
case "C":
num = num + 1;
break;
case "D":
num = num + 2;
break;
case "E":
num = num + 2;
break;
case "F":
num = num + 2;
break;
case "G":
num = num + 3;
break;
case "H":
num = num + 3;
break;
default:
break;
}
return num;
}
/**
* 扶養親族等の数を取得（2018年1月以降用）
* @param selectDto 調査実績情報格納
* @return 扶養親族等の数
*/
private int getDependentsNum2018(MonthAccountCalcTResearchRecordDto selectDto) {
int num = 0;
// 源泉控除対象配偶者
String strWithholdingDeductionSpouse = "";
if (!StringUtil.isEmpty(selectDto.withholdingDeductionSpouse)) {
strWithholdingDeductionSpouse = selectDto.withholdingDeductionSpouse;
}
switch (strWithholdingDeductionSpouse) {
case "1":
num = num + 1;
break;
default:
break;
}
// 同一生計配偶者（旧:扶養親族配偶者）
String strDependentsRelSpouse = "";
if (!StringUtil.isEmpty(selectDto.dependentsRelSpouse)) {
strDependentsRelSpouse = selectDto.dependentsRelSpouse;
}
switch (strDependentsRelSpouse) {
case "1":
num = num + 0;
break;
case "2":
num = num + 0;
break;
case "3":
num = num + 2;
break;
case "4":
num = num + 2;
break;
case "5":
num = num + 1;
break;
case "6":
num = num + 1;
break;
case "7":
num = num + 1;
break;
case "8":
num = num + 1;
break;
default:
break;
}
// 扶養親族その他
num = num + TsttUtil.convNullToZeroForInt(selectDto.dependentsRelOther);
// 扶養親族障害者
num = num + TsttUtil.convNullToZeroForInt(selectDto.dependentsRelDisabilities);
// 扶養親族同居特障
num = num + TsttUtil.convNullToZeroForInt(selectDto.dependentsRelLodger);
// 自己控除該当
String strSelfDeductApplicable = "";
if (!StringUtil.isEmpty(selectDto.selfDeductApplicable)) {
strSelfDeductApplicable = selectDto.selfDeductApplicable;
}
switch (strSelfDeductApplicable) {
case "0":
break;
case "1":
num = num + 1;
break;
case "2":
num = num + 1;
break;
case "3":
num = num + 1;
break;
case "4":
num = num + 1;
break;
case "5":
num = num + 2;
break;
case "6":
num = num + 2;
break;
case "7":
num = num + 2;
break;
case "8":
num = num + 2;
break;
case "9":
num = num + 2;
break;
case "A":
num = num + 3;
break;
case "B":
num = num + 3;
break;
case "C":
num = num + 1;
break;
case "D":
num = num + 2;
break;
case "E":
num = num + 2;
break;
case "F":
num = num + 2;
break;
case "G":
num = num + 3;
break;
case "H":
num = num + 3;
break;
default:
break;
}
return num;
}
/**
* 計算で使用する情報を計算用Mapに設定
* @param selectDto 調査実績情報格納
* @param calcMap 計算用情報格納
*/
private void setCalcMap(MonthAccountCalcTResearchRecordDto selectDto, HashMap<String, BigDecimal> calcMap) {
// 調査区数１
calcMap.put(CONST_RESEARCH_AREA_COUNT1, selectDto.researchAreaCount1);
// 調査区数２
calcMap.put(CONST_RESEARCH_AREA_COUNT2, selectDto.researchAreaCount2);
// 実地調査②
calcMap.put(CONST_RESEARCH_AREA_COUNT3, selectDto.researchAreaCount3);
// 調査区数３
calcMap.put(CONST_RESEARCH_AREA_COUNT4, selectDto.researchAreaCount4);
// 地図１
calcMap.put(CONST_MAP1, selectDto.map1);
// 地図２
calcMap.put(CONST_MAP2, selectDto.map2);
// 持ち数１
calcMap.put(CONST_HAVING_COUNT1, selectDto.havingCount1);
// 持ち数２
calcMap.put(CONST_HAVING_COUNT2, selectDto.havingCount2);
// ３区
calcMap.put(CONST_THREE_WARD, selectDto.threeWard);
// ３区以外
calcMap.put(CONST_THREE_WARD_OTHER, selectDto.threeWardOther);
// フリーワード１_値
calcMap.put(CONST_FREEWORD1_LANG, selectDto.freeword1Val);
// フリーワード２_値
calcMap.put(CONST_FREEWORD2_LANG, selectDto.freeword2Val);
// フリーワード３_値
calcMap.put(CONST_FREEWORD3_LANG, selectDto.freeword3Val);
// フリーワード４_値
calcMap.put(CONST_FREEWORD4_LANG, selectDto.freeword4Val);
// 報酬金額１
calcMap.put(CONST_REWARD_CONST1, selectDto.rewardConst1);
// 報酬金額２
calcMap.put(CONST_REWARD_CONST2, selectDto.rewardConst2);
// 報酬金額３
calcMap.put(CONST_REWARD_CONST3, selectDto.rewardConst3);
// 報酬金額４
calcMap.put(CONST_REWARD_CONST4, selectDto.rewardConst4);
// 報酬金額５
calcMap.put(CONST_REWARD_CONST5, selectDto.rewardConst5);
// 報酬金額６
calcMap.put(CONST_REWARD_CONST6, selectDto.rewardConst6);
// 報酬金額７
calcMap.put(CONST_REWARD_CONST7, selectDto.rewardConst7);
// 報酬金額８
calcMap.put(CONST_REWARD_CONST8, selectDto.rewardConst8);
// 報酬金額９
calcMap.put(CONST_REWARD_CONST9, selectDto.rewardConst9);
// 報酬金額１０
calcMap.put(CONST_REWARD_CONST10, selectDto.rewardConst10);
// 報酬金額１１
calcMap.put(CONST_REWARD_CONST11, selectDto.rewardConst11);
// 報酬金額１２
calcMap.put(CONST_REWARD_CONST12, selectDto.rewardConst12);
// 費用弁償金額１
calcMap.put(CONST_RESTITUTE_CONST1, selectDto.restituteConst1);
// 費用弁償金額２
calcMap.put(CONST_RESTITUTE_CONST2, selectDto.restituteConst2);
// 費用弁償金額３
calcMap.put(CONST_RESTITUTE_CONST3, selectDto.restituteConst3);
// 費用弁償金額４
calcMap.put(CONST_RESTITUTE_CONST4, selectDto.restituteConst4);
// 費用弁償金額５
calcMap.put(CONST_RESTITUTE_CONST5, selectDto.restituteConst5);
// 費用弁償金額６
calcMap.put(CONST_RESTITUTE_CONST6, selectDto.restituteConst6);
// 費用弁償金額７
calcMap.put(CONST_RESTITUTE_CONST7, selectDto.restituteConst7);
// 費用弁償金額８
calcMap.put(CONST_RESTITUTE_CONST8, selectDto.restituteConst8);
// 費用弁償金額９
calcMap.put(CONST_RESTITUTE_CONST9, selectDto.restituteConst9);
// 費用弁償金額１０
calcMap.put(CONST_RESTITUTE_CONST10, selectDto.restituteConst10);
// 費用弁償金額１１
calcMap.put(CONST_RESTITUTE_CONST11, selectDto.restituteConst11);
// 費用弁償金額１２
calcMap.put(CONST_RESTITUTE_CONST12, selectDto.restituteConst12);
}
/**
* 計算処理
* @param calcMap 計算に使用する値を格納（KEY:カラムの論理名,VALUE:カラムの値）
* @param selectDto 検索結果（調査実績情報）
* @param calcResultValMap 金額１～１２の計算結果を格納
* @param occurFlgIndex 発生フラグの添字
* @param rewardCostRestituteFlg 報酬費用の判定フラグ 0:報酬、1:費用
* @return 処理結果を返す 0：正常 0以外：エラー
*/
private int calc(HashMap<String, BigDecimal> calcMap, MonthAccountCalcResultDto selectDto,
String conbOccuredFlg, String conbFormula, HashMap<String, BigDecimal> calcResultValMap, int occurFlgIndex
, int rewardCostRestituteFlg) {
int result = 0;
// 発生フラグ１～１２
String[] occurredFlgArray = StringUtil.split(conbOccuredFlg, DELIM);
// 計算式（フラグ）１～１２
String[] formulaArray1to12 = StringUtil.split(conbFormula, DELIM);
// 計算式格納
String[] formulaArray;
// 計算式
String formula;
// 計算式（最終的な計算式として使用）
StringBuilder strbFormula = new StringBuilder();
BigDecimal calcResult = BigDecimal.ZERO;
// 発生フラグを1文字ずつ配列に格納
char occrredCharArray[];
for (int i = 0; i < occurredFlgArray.length; i++) {
//報酬発生フラグにて、処理年月に該当するフラグが立っていない場合、次の報酬へ
if (!occurredFlgArray[i].equals("null")) {
occrredCharArray = occurredFlgArray[i].toCharArray();
if (TsttUtil.FLAG_ON.equals(String.valueOf(occrredCharArray[occurFlgIndex]))) {
//計算式をカンマにて分割し、項目と算術式に切り分ける
formulaArray = formulaArray1to12[i].split(",");
//切り分けた項目を、該当する項目の値に置き換える。
for (int j = 0; j < formulaArray.length; j++) {
formula = formulaArray[j];
if (calcMap.containsKey(formula)) {
// 数値を設定
strbFormula.append(calcMap.get(formula));
} else {
// 演算子を設定
strbFormula.append(formula);
}
}
//置き換えた値を元に計算を実施する
//例） 報酬金額１に10000、調査区数１に2が入っていた場合
// 10000 * 2 = 20000 が、この調査の報酬結果となる。
try {
String calcFor = "Math.floor(" + strbFormula.toString() + ")";
calcResult = new BigDecimal(engine.eval(calcFor).toString());
strbFormula = new StringBuilder();
// マイナスの場合はエラーとする
if (calcResult.compareTo(BigDecimal.ZERO) < 0) {
result = 1;
return result;
}
} catch (Exception ex) {
// 計算処理に失敗
result = 1;
return result;
}
calcResultValMap.put("金額" + (i + 1), calcResult);
} else {
// 実績削除判定処理
deleteResearchCode(selectDto, i, rewardCostRestituteFlg);
}
}
}
return result;
}
/**
* 任免しているが、チェックをいれていない任免情報の実績は作成しない
* @param selectDto
* @param index
*/
private void deleteResearchCode(MonthAccountCalcResultDto selectDto, int index, int rewardCostRestituteFlg) {
if (rewardCostRestituteFlg == 0) {
switch (index) {
case 0:
selectDto.rewardCode1 = "";
selectDto.rewardFormula1 = "";
selectDto.rewardAmount1 = null;
break;
case 1:
selectDto.rewardCode2 = "";
selectDto.rewardFormula2 = "";
selectDto.rewardAmount2 = null;
break;
case 2:
selectDto.rewardCode3 = "";
selectDto.rewardFormula3 = "";
selectDto.rewardAmount3 = null;
break;
case 3:
selectDto.rewardCode4 = "";
selectDto.rewardFormula4 = "";
selectDto.rewardAmount4 = null;
break;
case 4:
selectDto.rewardCode5 = "";
selectDto.rewardFormula5 = "";
selectDto.rewardAmount5 = null;
break;
case 5:
selectDto.rewardCode6 = "";
selectDto.rewardFormula6 = "";
selectDto.rewardAmount6 = null;
break;
case 6:
selectDto.rewardCode7 = "";
selectDto.rewardFormula7 = "";
selectDto.rewardAmount7 = null;
break;
case 7:
selectDto.rewardCode8 = "";
selectDto.rewardFormula8 = "";
selectDto.rewardAmount8 = null;
break;
case 8:
selectDto.rewardCode9 = "";
selectDto.rewardFormula9 = "";
selectDto.rewardAmount9 = null;
break;
case 9:
selectDto.rewardCode10 = "";
selectDto.rewardFormula10 = "";
selectDto.rewardAmount10 = null;
break;
case 10:
selectDto.rewardCode11 = "";
selectDto.rewardFormula11 = "";
selectDto.rewardAmount11 = null;
break;
case 11:
selectDto.rewardCode12 = "";
selectDto.rewardFormula12 = "";
selectDto.rewardAmount12 = null;
break;
}
} else {
switch (index) {
case 0:
selectDto.restituteCode1 = "";
selectDto.restituteFormula1 = "";
selectDto.restituteAmount1 = null;
break;
case 1:
selectDto.restituteCode2 = "";
selectDto.restituteFormula2 = "";
selectDto.restituteAmount2 = null;
break;
case 2:
selectDto.restituteCode3 = "";
selectDto.restituteFormula3 = "";
selectDto.restituteAmount3 = null;
break;
case 3:
selectDto.restituteCode4 = "";
selectDto.restituteFormula4 = "";
selectDto.restituteAmount4 = null;
break;
case 4:
selectDto.restituteCode5 = "";
selectDto.restituteFormula5 = "";
selectDto.restituteAmount5 = null;
break;
case 5:
selectDto.restituteCode6 = "";
selectDto.restituteFormula6 = "";
selectDto.restituteAmount6 = null;
break;
case 6:
selectDto.restituteCode7 = "";
selectDto.restituteFormula7 = "";
selectDto.restituteAmount7 = null;
break;
case 7:
selectDto.restituteCode8 = "";
selectDto.restituteFormula8 = "";
selectDto.restituteAmount8 = null;
break;
case 8:
selectDto.restituteCode9 = "";
selectDto.restituteFormula9 = "";
selectDto.restituteAmount9 = null;
break;
case 9:
selectDto.restituteCode10 = "";
selectDto.restituteFormula10 = "";
selectDto.restituteAmount10 = null;
break;
case 10:
selectDto.restituteCode11 = "";
selectDto.restituteFormula11 = "";
selectDto.restituteAmount11 = null;
break;
case 11:
selectDto.restituteCode12 = "";
selectDto.restituteFormula12 = "";
selectDto.restituteAmount12 = null;
break;
}
}
}
/**
*
* @param inputEntity 入力情報
* @param selectDto 検索結果（調査実績情報）
* @param isMainRecord 対象調査実績を対象とするのかどうか
*/
private void setTResearchRecordDto(TResearchRecord inputEntity, MonthAccountCalcTResearchRecordDto selectDto,
boolean isMainRecord) {
if (isMainRecord) {
// 調査区数１
if (null != (inputEntity.researchAreaCount1)) {
selectDto.researchAreaCount1 = inputEntity.researchAreaCount1;
}
// 調査区数２
if (null != (inputEntity.researchAreaCount2)) {
selectDto.researchAreaCount2 = inputEntity.researchAreaCount2;
}
// 実地調査②（調査区数3）
if (null != (inputEntity.researchAreaCount3)) {
selectDto.researchAreaCount3 = inputEntity.researchAreaCount3;
}
// 調査区数３
if (null != (inputEntity.researchAreaCount4)) {
selectDto.researchAreaCount4 = inputEntity.researchAreaCount4;
}
// 地図１
if (null != (inputEntity.map1)) {
selectDto.map1 = inputEntity.map1;
}
// 地図２
if (null != (inputEntity.map2)) {
selectDto.map2 = inputEntity.map2;
}
// 持ち数１
if (null != (inputEntity.havingCount1)) {
selectDto.havingCount1 = inputEntity.havingCount1;
}
// 持ち数２
if (null != (inputEntity.havingCount2)) {
selectDto.havingCount2 = inputEntity.havingCount2;
}
// ３区
if (null != (inputEntity.threeWard)) {
selectDto.threeWard = inputEntity.threeWard;
}
// ３区以外
if (null != (inputEntity.threeWardOther)) {
selectDto.threeWardOther = inputEntity.threeWardOther;
}
// フリーワード１_値
if (null != (inputEntity.freeword1Val)) {
selectDto.freeword1Val = inputEntity.freeword1Val;
}
// フリーワード２_値
if (null != (inputEntity.freeword2Val)) {
selectDto.freeword2Val = inputEntity.freeword2Val;
}
// フリーワード３_値
if (null != (inputEntity.freeword3Val)) {
selectDto.freeword3Val = inputEntity.freeword3Val;
}
// フリーワード４_値
if (null != (inputEntity.freeword4Val)) {
selectDto.freeword4Val = inputEntity.freeword4Val;
}
// 報酬金額１
if (null != (inputEntity.rewardAmount1)) {
selectDto.rewardAmount1 = inputEntity.rewardAmount1;
}
// 報酬金額２
if (null != (inputEntity.rewardAmount2)) {
selectDto.rewardAmount2 = inputEntity.rewardAmount2;
}
// 報酬金額３
if (null != (inputEntity.rewardAmount3)) {
selectDto.rewardAmount3 = inputEntity.rewardAmount3;
}
// 報酬金額４
if (null != (inputEntity.rewardAmount4)) {
selectDto.rewardAmount4 = inputEntity.rewardAmount4;
}
// 報酬金額５
if (null != (inputEntity.rewardAmount5)) {
selectDto.rewardAmount5 = inputEntity.rewardAmount5;
}
// 報酬金額６
if (null != (inputEntity.rewardAmount6)) {
selectDto.rewardAmount6 = inputEntity.rewardAmount6;
}
// 報酬金額７
if (null != (inputEntity.rewardAmount7)) {
selectDto.rewardAmount7 = inputEntity.rewardAmount7;
}
// 報酬金額８
if (null != (inputEntity.rewardAmount8)) {
selectDto.rewardAmount8 = inputEntity.rewardAmount8;
}
// 報酬金額９
if (null != (inputEntity.rewardAmount9)) {
selectDto.rewardAmount9 = inputEntity.rewardAmount9;
}
// 報酬金額１０
if (null != (inputEntity.rewardAmount10)) {
selectDto.rewardAmount10 = inputEntity.rewardAmount10;
}
// 報酬金額１１
if (null != (inputEntity.rewardAmount11)) {
selectDto.rewardAmount11 = inputEntity.rewardAmount11;
}
// 報酬金額１２
if (null != (inputEntity.rewardAmount12)) {
selectDto.rewardAmount12 = inputEntity.rewardAmount12;
}
// 費用弁償金額１
if (null != (inputEntity.restituteAmount1)) {
selectDto.restituteAmount1 = inputEntity.restituteAmount1;
}
// 費用弁償金額２
if (null != (inputEntity.restituteAmount2)) {
selectDto.restituteAmount2 = inputEntity.restituteAmount2;
}
// 費用弁償金額３
if (null != (inputEntity.restituteAmount3)) {
selectDto.restituteAmount3 = inputEntity.restituteAmount3;
}
// 費用弁償金額４
if (null != (inputEntity.restituteAmount4)) {
selectDto.restituteAmount4 = inputEntity.restituteAmount4;
}
// 費用弁償金額５
if (null != (inputEntity.restituteAmount5)) {
selectDto.restituteAmount5 = inputEntity.restituteAmount5;
}
// 費用弁償金額６
if (null != (inputEntity.restituteAmount6)) {
selectDto.restituteAmount6 = inputEntity.restituteAmount6;
}
// 費用弁償金額７
if (null != (inputEntity.restituteAmount7)) {
selectDto.restituteAmount7 = inputEntity.restituteAmount7;
}
// 費用弁償金額８
if (null != (inputEntity.restituteAmount8)) {
selectDto.restituteAmount8 = inputEntity.restituteAmount8;
}
// 費用弁償金額９
if (null != (inputEntity.restituteAmount9)) {
selectDto.restituteAmount9 = inputEntity.restituteAmount9;
}
// 費用弁償金額１０
if (null != (inputEntity.restituteAmount10)) {
selectDto.restituteAmount10 = inputEntity.restituteAmount10;
}
// 費用弁償金額１１
if (null != (inputEntity.restituteAmount11)) {
selectDto.restituteAmount11 = inputEntity.restituteAmount11;
}
// 費用弁償金額１２
if (null != (inputEntity.restituteAmount12)) {
selectDto.restituteAmount12 = inputEntity.restituteAmount12;
}
// 所得税引去額
if (null != (inputEntity.incomeTaxTake)) {
selectDto.incomeTaxTake = inputEntity.incomeTaxTake;
}
}
// 報酬計算式（コード）１～１２を「＠」で文字列結合
selectDto.conbRewardFormula = selectDto.rewardFormula1 + DELIM + selectDto.rewardFormula2 + DELIM
+ selectDto.rewardFormula3 + DELIM + selectDto.rewardFormula4 + DELIM + selectDto.rewardFormula5
+ DELIM + selectDto.rewardFormula6 + DELIM + selectDto.rewardFormula7 + DELIM
+ selectDto.rewardFormula8 + DELIM + selectDto.rewardFormula9 + DELIM + selectDto.rewardFormula10
+ DELIM + selectDto.rewardFormula11 + DELIM + selectDto.rewardFormula12;
// 報酬計算式１～１２を「＠」で文字列結合
selectDto.conbCxFormula = selectDto.cs1formula + DELIM + selectDto.cs2formula + DELIM + selectDto.cs3formula
+ DELIM + selectDto.cs4formula + DELIM + selectDto.cs5formula + DELIM + selectDto.cs6formula + DELIM
+ selectDto.cs7formula + DELIM + selectDto.cs8formula + DELIM + selectDto.cs9formula + DELIM
+ selectDto.cs10formula + DELIM + selectDto.cs11formula + DELIM + selectDto.cs12formula;
// 報酬発生フラグ１～１２を「＠」で文字列結合
selectDto.conbRewardOccurredFlg = selectDto.rewardOccurredFlg1 + DELIM + selectDto.rewardOccurredFlg2 + DELIM
+ selectDto.rewardOccurredFlg3 + DELIM + selectDto.rewardOccurredFlg4 + DELIM
+ selectDto.rewardOccurredFlg5 + DELIM + selectDto.rewardOccurredFlg6 + DELIM
+ selectDto.rewardOccurredFlg7 + DELIM + selectDto.rewardOccurredFlg8 + DELIM
+ selectDto.rewardOccurredFlg9 + DELIM + selectDto.rewardOccurredFlg10 + DELIM
+ selectDto.rewardOccurredFlg11 + DELIM + selectDto.rewardOccurredFlg12;
// 弁償計算式（コード）１～１２を「＠」で文字列結合
selectDto.conbRestituteFormula = selectDto.restituteFormula1 + DELIM + selectDto.restituteFormula2 + DELIM
+ selectDto.restituteFormula3 + DELIM + selectDto.restituteFormula4 + DELIM
+ selectDto.restituteFormula5 + DELIM + selectDto.restituteFormula6 + DELIM
+ selectDto.restituteFormula7 + DELIM + selectDto.restituteFormula8 + DELIM
+ selectDto.restituteFormula9 + DELIM + selectDto.restituteFormula10 + DELIM
+ selectDto.restituteFormula11 + DELIM + selectDto.restituteFormula12;
// 弁償計算式１～１２を「＠」で文字列結合
selectDto.conbDxFormula = selectDto.dx1formula + DELIM + selectDto.dx2formula + DELIM + selectDto.dx3formula
+ DELIM + selectDto.dx4formula + DELIM + selectDto.dx5formula + DELIM + selectDto.dx6formula + DELIM
+ selectDto.dx7formula + DELIM + selectDto.dx8formula + DELIM + selectDto.dx9formula + DELIM
+ selectDto.dx10formula + DELIM + selectDto.dx11formula + DELIM + selectDto.dx12formula;
// 弁償発生フラグ１～１２を「＠」で文字列結合
selectDto.conbRestituteOccuredFlg = selectDto.restituteOccuredFlg1 + DELIM + selectDto.restituteOccuredFlg2
+ DELIM + selectDto.restituteOccuredFlg3 + DELIM + selectDto.restituteOccuredFlg4 + DELIM
+ selectDto.restituteOccuredFlg5 + DELIM + selectDto.restituteOccuredFlg6 + DELIM
+ selectDto.restituteOccuredFlg7 + DELIM + selectDto.restituteOccuredFlg8 + DELIM
+ selectDto.restituteOccuredFlg9 + DELIM + selectDto.restituteOccuredFlg10 + DELIM
+ selectDto.restituteOccuredFlg11 + DELIM + selectDto.restituteOccuredFlg12;
}
/**
* 調査実績を取得
*/
private MonthAccountCalcTResearchRecordDto getTResearchRecord(TResearchRecord inputEntity) {
MonthAccountCalcSelectTResearchRecordDto conditionDto = new MonthAccountCalcSelectTResearchRecordDto(
inputEntity);
return selectOneBySqlFile(MonthAccountCalcTResearchRecordDto.class,
"/sql/MonthAccountCalcSelectTResearchData.sql", conditionDto);
}
/**
* 引数のエンティティが表す調査実績をもとに別調査・同年・同月・同調査員の調査実績を取得する
*
* @param inputEntity 調査実績情報（検索条件）
* @return 調査実績一覧
*/
private List<MonthAccountCalcTResearchRecordDto> getOtherTResearchRecord(TResearchRecord inputEntity) {
MonthAccountCalcSelectTResearchRecordDto conditionDto = new MonthAccountCalcSelectTResearchRecordDto(
inputEntity);
return selectBySqlFile(MonthAccountCalcTResearchRecordDto.class,
"/sql/MonthAccountCalcSelectOtherTResearchData.sql", conditionDto);
}
/**
* 住民税徴収を取得する
*
* @param targetTRR 対象調査実績情報
* @return 住民税
*/
private BigDecimal getResidentTax(MonthAccountCalcTResearchRecordDto targetTRR) {
// 処理月を設定
targetTRR.targetMonth = targetTRR.performYm.substring(4);
// 読み込み実施
List<BeanMap> result = selectBySqlFile(BeanMap.class, "/sql/MonthAccountCalcSelectResidentTax.sql", targetTRR);
if (result.size() > 0) {
return (BigDecimal) result.get(0).get("paymentAmount");
} else {
return BigDecimal.ZERO;
}
}
/**
* BigDecimalのnullをZEROに変換する
*
* @param dec BigDecimal値
* @return nullをZEROに変換したもの
*/
private BigDecimal convNull(BigDecimal dec) {
if (dec == null) {
return BigDecimal.ZERO;
} else {
return dec;
}
}
/**
* 全ての計算処理が正常終了しているか確認する
*
* @param calcResults 計算結果（配列）
* @return true:全ての計算処理が正常終了／false:いずれかの計算処理が失敗
*/
private boolean calcSuccessed(List<MonthAccountCalcResultDto> calcResults) {
for (MonthAccountCalcResultDto calcResult : calcResults) {
if (calcResult.result != 0) {
return false;
}
}
return true;
}
/**
* 計算結果並べ替え用Comparator
*
* @author TRUMP SOFT M.Fujita
*/
private static class MonthlyAccountCalcComparator implements Comparator<MonthAccountCalcResultDto> {
private static MonthlyAccountCalcComparator instance = null;
public static MonthlyAccountCalcComparator getInstance() {
if (instance == null) {
instance = new MonthlyAccountCalcComparator();
}
return instance;
}
private MonthlyAccountCalcComparator() {
// NOP(Singleton)
}
@Override
public int compare(MonthAccountCalcResultDto a, MonthAccountCalcResultDto b) {
if (StringUtils.equals(a.oneoffResearchKbn, b.oneoffResearchKbn)) {
if (a.rewardAmount.compareTo(b.rewardAmount) == 0) {
if (StringUtils.equals(a.researchCode, b.researchCode)) {
return 0;
} else {
return a.researchCode.compareTo(b.researchCode);
}
} else {
return -a.rewardAmount.compareTo(b.rewardAmount);
}
} else if (ONEOFF_RESEARCH_KBN_NOT_ONE.equals(a.oneoffResearchKbn)) {
return -1;
} else {
return 1;
}
}
}
}
This article was last edited at