jiuzhoutong/websrc/com/kingdee/eas/custom/compensation/handler/IncomeTaxDeclareListHandlerEx.java

package com.kingdee.eas.custom.compensation.handler;

import cn.com.servyou.dto.ApiResponse;
import cn.com.servyou.dto.AsyncResult;
import cn.com.servyou.dto.declare.CompanyDeclareRequest;
import cn.com.servyou.dto.tax.ComplexIncome;
import cn.com.servyou.dto.tax.ComplexIncomeRequest;
import cn.com.servyou.dto.tax.DetailCompanyEmployee;
import cn.com.servyou.dto.tax.NormalSalarySpecIncome;
import cn.com.servyou.rmi.client.ClientProxyFactory;
import cn.com.servyou.service.DeclarationRequest;
import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.collect.Maps;
import com.kingdee.bos.BOSException;
import com.kingdee.bos.Context;
import com.kingdee.bos.dao.ormapping.ObjectUuidPK;
import com.kingdee.bos.metadata.entity.*;
import com.kingdee.bos.metadata.query.util.CompareType;
import com.kingdee.bos.util.EASResource;
import com.kingdee.eas.base.permission.UserInfo;
import com.kingdee.eas.basedata.hraux.NationalityInfo;
import com.kingdee.eas.basedata.person.PersonCollection;
import com.kingdee.eas.basedata.person.PersonFactory;
import com.kingdee.eas.basedata.person.PersonInfo;
import com.kingdee.eas.common.EASBizException;
import com.kingdee.eas.custom.shuiyou.interfacelog.LogInfoInfo;
import com.kingdee.eas.custom.shuiyou.task.TaskCatalogEnum;
import com.kingdee.eas.custom.shuiyou.uitls.ISYUtilsFacade;
import com.kingdee.eas.custom.shuiyou.uitls.SYUtilsFacadeFactory;
import com.kingdee.eas.custom.shuiyou.utils.ClientProxyFactoryUtils;
import com.kingdee.eas.hr.ats.AtsUtil;
import com.kingdee.eas.hr.rec.GenderEnum;
import com.kingdee.eas.util.app.DbUtil;
import com.kingdee.jdbc.rowset.IRowSet;
import com.kingdee.shr.base.syssetting.context.SHRContext;
import com.kingdee.shr.base.syssetting.exception.SHRWebException;
import com.kingdee.shr.base.syssetting.exception.ShrWebBizException;
import com.kingdee.shr.base.syssetting.web.dynamic.util.DynamicUtil;
import com.kingdee.shr.base.syssetting.web.dynamic.util.MD5;
import com.kingdee.shr.base.syssetting.web.json.JSONUtils;
import com.kingdee.shr.base.syssetting.web.util.UserUtil;
import com.kingdee.shr.compensation.*;
import com.kingdee.shr.compensation.app.incomeTax.*;
import com.kingdee.shr.compensation.app.tax.*;
import com.kingdee.shr.compensation.app.tax.base.TaxIncomeItemInfo;
import com.kingdee.shr.compensation.app.tax.base.TaxItemInfo;
import com.kingdee.shr.compensation.app.taxCal.ITaxCalConfigDetail;
import com.kingdee.shr.compensation.app.taxCal.TaxCalConfigDetailCollection;
import com.kingdee.shr.compensation.app.taxCal.TaxCalConfigDetailFactory;
import com.kingdee.shr.compensation.app.taxCal.TaxCalConfigDetailInfo;
import com.kingdee.shr.compensation.util.*;
import com.kingdee.shr.compensation.web.handler.tax.IncomeTaxDeclareListHandler;
import com.kingdee.shr.compensation.web.handler.tax.dto.TaxDeclarExcelRowDTO;
import com.kingdee.shr.compensation.web.handler.tax.dto.TaxDeclareDTO;
import com.kingdee.shr.dydeploy.web.executeSql.ExceptionUtils;
import com.kingdee.util.StringUtils;
import org.apache.log4j.Logger;
import org.apache.poi.hssf.usermodel.*;
import org.springframework.ui.ModelMap;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.math.BigDecimal;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.*;


/**
 * @author qingwu
 * @date 2024/9/18
 * @apiNote 个税申报扩展
 */
public class IncomeTaxDeclareListHandlerEx extends IncomeTaxDeclareListHandler {
    private static final Logger LOG = Logger.getLogger(IncomeTaxDeclareListHandlerEx.class);

    private Context ctx = SHRContext.getInstance().getContext();

    private ObjectMapper mapper = new ObjectMapper();

    /**
     * 个税申报
     *
     * @param request
     * @param response
     * @param modelMap
     */
    @Override
    public void taxDeclareAction(HttpServletRequest request, HttpServletResponse response, ModelMap modelMap) throws BOSException, SHRWebException {
        LOG.error("taxDeclareAction-----------start-----------");
        Context ctx = SHRContext.getInstance().getContext();
        try {
            boolean isHaveTaxService = CmpTaxUtil.isHaveTaxService(ctx);
            //if (!isHaveTaxService) {
            //    throw new ShrWebBizException(EASResource.getString("com.kingdee.shr.compensation.resource.CommonResource", "label136", ctx.getLocale()));
            //} else {
            String selectedId = request.getParameter("selectedId");
            Map<String, Object> resultMap = new HashMap();
            Map<String, Object> declareData = this.getDeclareData(ctx, selectedId);
            Map<String, Object> paramMap = new HashMap();
            paramMap.put("declaData", declareData.get("WATI_TO_DECLARE"));
            LOG.error("paramMap-----------" + paramMap);
            try {
                //纳税单位
                List<String> advanceDeclareInfo = (List) declareData.get("advanceDeclareInfo");
                LOG.error("advanceDeclareInfo------------" + advanceDeclareInfo);
                if (!advanceDeclareInfo.isEmpty()) {
                    throw new ShrWebBizException(this.combineError(advanceDeclareInfo));
                }
                //个税审批 审批状态=审批通过的数据
                List<IncomeTaxDeclarInfo> waitToDeclareList = (List) paramMap.get("declaData");
                if (waitToDeclareList.size() <= 0) {
                    resultMap.put("success", false);
                    resultMap.put("excel", "");
                    resultMap.put("hasErrData", true);
                    resultMap.put("hasCheckDataErr", true);
                    resultMap.put("info", "不可重复声申报！！");
                    JSONUtils.SUCCESS(resultMap);
                    return;
                }
                //检查纳税申报数据
                Map<String, Object> checkResultMap = this.checkTaxDeclareData(ctx, request, waitToDeclareList);
                Boolean hasErr = (Boolean) checkResultMap.get("hasErrData");
                if (hasErr != null && hasErr) {
                    resultMap.put("success", false);
                    resultMap.put("excel", checkResultMap.get("excel"));
                    resultMap.put("hasErrData", true);
                    resultMap.put("hasCheckDataErr", true);
                    resultMap.put("info", "");
                    JSONUtils.SUCCESS(resultMap);
                    return;
                }
                String errMsg = this.checkTaxCalStatus(ctx, waitToDeclareList);
                if (null != errMsg) {
                    resultMap.put("success", false);
                    resultMap.put("dataError", true);
                    resultMap.put("errMsg", errMsg);
                    JSONUtils.SUCCESS(resultMap);
                    return;
                }

                checkResultMap = this.checkIncomeTaxIssue(ctx, waitToDeclareList);
                if (checkResultMap != null) {
                    checkResultMap.put("success", false);
                    JSONUtils.SUCCESS(checkResultMap);
                    return;
                }

                //errMsg = this.checkReductionItems(ctx, waitToDeclareList);
                //if (null != errMsg) {
                //    resultMap.put("success", false);
                //    resultMap.put("reductionError", true);
                //    resultMap.put("errMsg", errMsg);
                //    JSONUtils.SUCCESS(resultMap);
                //    return;
                //}

                //Map<String, Object> taxDeclareResult = IncomeTaxDeclareFacadeFactory.getLocalInstance(ctx).taxDeclare(paramMap);
                //调佣税友纳税申报
                Map<String, Object> taxDeclareResult = callShuiYouTaxDeclare(paramMap);
                Boolean isSuccess = (Boolean) taxDeclareResult.get("success");
                resultMap.put("success", isSuccess);
                resultMap.put("excel", "");
                resultMap.put("hasErrData", !isSuccess);
                resultMap.put("hasCheckDataErr", false);
                resultMap.put("info", declareData.get("info"));
            } catch (Exception var17) {
                var17.printStackTrace();
                LOG.error(var17.getMessage(), var17);
                resultMap.put("success", false);
                resultMap.put("excel", "");
                resultMap.put("hasErrData", true);
                resultMap.put("hasCheckDataErr", false);
                resultMap.put("info", declareData.get("info"));
                resultMap.put("errorMsg", var17.getMessage());
            }
            LOG.error("taxDeclareAction-----------end-----------");
            JSONUtils.SUCCESS(resultMap);
            //}
        } catch (JsonProcessingException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }


    /**
     * 调佣税友纳税申报
     *
     * @param paramMap
     * @return
     */
    public Map<String, Object> callShuiYouTaxDeclare(Map paramMap) throws JsonProcessingException, BOSException {
        LOG.error("callShuiYouTaxDeclare--------------------paramMap" + paramMap);
        Map<String, Object> resultMap = new HashMap();
        resultMap.put("success", true);
        resultMap.put("msg", "");
        List<IncomeTaxDeclarInfo> waitToDeclareList = (List) paramMap.get("declaData");
        Map<String, Object> requestParamMap = new HashMap();
        List<Object[]> paramList = new ArrayList();
       // LogInfoInfo logInfoCall = new LogInfoInfo();
        //日志
       // logInfoCall.setEntrance(this.getClass().getName());//入口
        Long timestampLong = System.currentTimeMillis();
        UserInfo userInfo = (UserInfo)ctx.get("UserInfo");
       // logInfoCall.setCreator(userInfo);
        Timestamp timestamp = new Timestamp(timestampLong);
       // logInfoCall.setCreateTime(timestamp);
       // logInfoCall.setLastUpdateTime(timestamp);
       // logInfoCall.setLastUpdateUser(userInfo);
       // logInfoCall.setBizDate(timestamp);
        ISYUtilsFacade localInstance = SYUtilsFacadeFactory.getLocalInstance(ctx);
        try {
            if (waitToDeclareList != null && waitToDeclareList.size() > 0) {
                for (int i = 0; i < waitToDeclareList.size(); i++) {
                    LogInfoInfo logInfo = new LogInfoInfo();
                    //日志
                    logInfo.setEntrance(this.getClass().getName());//入口
                    logInfo.setCreator(userInfo);
                    logInfo.setCreateTime( new Timestamp(System.currentTimeMillis()));
                    logInfo.setLastUpdateTime( new Timestamp(System.currentTimeMillis()));
                    logInfo.setLastUpdateUser(userInfo);
                    logInfo.setBizDate(timestamp);

                    IncomeTaxDeclarInfo taxDeclarInfo = waitToDeclareList.get(i);
                    IIncomeTaxDeclar iId = IncomeTaxDeclarFactory.getLocalInstance(ctx);
                    SelectorItemCollection sc = new SelectorItemCollection();
                    sc.add(new SelectorItemInfo("declareStatus"));
                    taxDeclarInfo.setDeclareStatus(TaxDeclareStatusEnum.DECLARE_PROCESSING);
                    iId.updatePartial(taxDeclarInfo,sc);
                    JSONObject param = new JSONObject();
                    param.put("taxDeclarId", taxDeclarInfo.getId().toString());
                    param.put("taxDeclarBatchNo", taxDeclarInfo.getBatchNo());
                    //纳税单位
                    TaxUnitInfo taxUnitInfo = TaxUnitFactory.getLocalInstance(ctx).getTaxUnitInfo(new ObjectUuidPK(taxDeclarInfo.getTaxUnit().getId().toString()));
                    //客户端代理工厂
                    ClientProxyFactory clientProxyFactory = ClientProxyFactoryUtils.getClientProxyFactory();
                    //算税请求接口
                    DeclarationRequest declarationRequest = clientProxyFactory.getDeclarationRequest();
                    //获取请求参数
                    CompanyDeclareRequest declareRequestParameter = getDeclareRequestParameter(taxUnitInfo, taxDeclarInfo);
                    LOG.error("declareRequestParameter-----------------" + mapper.writeValueAsString(declareRequestParameter));
                    ApiResponse<AsyncResult> apiResponse = declarationRequest.importData(declareRequestParameter);
                    LOG.error("asyncResultApiResponse-----getCode-------" + apiResponse.getHead().getCode());
                    LOG.error("asyncResultApiResponse-----getMsg--------" + apiResponse.getHead().getMsg());
                    resultMap.put("msg", mapper.writeValueAsString(declareRequestParameter));
                    logInfo.setInParameter(mapper.writeValueAsString(declareRequestParameter));
                    if (apiResponse.getHead().getCode().equals("00000000")) {
                        Map<String,Object> msg = new HashMap<String,Object>();
                        msg.put("Head",apiResponse.getHead());
                        msg.put("Body",apiResponse.getBody());
                        logInfo.setOutParameter(mapper.writeValueAsString(msg));//回参

                        AsyncResult body = apiResponse.getBody();
                        String requestId = body.getRequestId();
                        LOG.error("requestId-----" + requestId);
                        LOG.error("apiResponse-----" + mapper.writeValueAsString(apiResponse));
                        //查询反算反馈结果
                        ISYUtilsFacade isyUtilsFacade = SYUtilsFacadeFactory.getLocalInstance(ctx);
                        //backTask(url,requestId,回调osf服务,自定义参数,任务类型)
                        //isyUtilsFacade.backTask(isyUtilsFacade.getConfig().get("ip") + "/gateway/iit/reverseCalculateTax/getASynIndividualIncomeTaxFeedback", requestId, "synIndividualIncomeTaxService", jsonObject.toString(), TaskCatalogEnum.CAL_GET);
                        JSONObject json = new JSONObject();
                        json.put("requestId", requestId);
                        json.put("param", param.toJSONString());
                        isyUtilsFacade.addTask("synIncomeTaxDeclareService", json.toJSONString(), TaskCatalogEnum.TAX, "");
                    }else {
                        Map<String,Object> msg = new HashMap<String,Object>();
                        msg.put("Head",apiResponse.getHead());
                        msg.put("Body",apiResponse.getBody());
                        logInfo.setErrorInfo(mapper.writeValueAsString(msg));//错误信息
                    }
                    logInfo.setInterfaceAddress(i+"/gateway/iit/report/importData");//接口地址
                    logInfo.setInterfaceName("POST");//接口名
                    localInstance.log(logInfo);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            resultMap.put("success", false);
            resultMap.put("msg", e.getMessage());
            //logInfoCall. setOutParameter( ExceptionUtils.getStackTrace(e));//回参
        }finally {
//            logInfoCall.setInterfaceAddress("/gateway/iit/report/send");//接口地址
//            logInfoCall.setInterfaceName("POST");//接口名
//            try {
//                if (waitToDeclareList != null && !waitToDeclareList.isEmpty()) {
//                    logInfoCall.setInParameter(JSONUtils.convertObjectToJson(ctx, waitToDeclareList));
//                }
//            }catch (Exception e){
//                e.printStackTrace();
//            }
//            localInstance.log(logInfoCall);
        }
        return resultMap;

    }

    /**
     * 获取请求参数
     * 注意:
     * 1.解除劳动合同一次性补偿金、全年一次性奖金所得，不能单独申报，需要同正常工资薪金一起申报。
     * 2.解除劳动合同一次性补偿金、稿酬所得，由于税务规则需要，解除劳动合同一次性补偿金、稿酬所得必须填写免税附表。
     *
     * @param taxUnitInfo
     * @param taxDeclarInfo
     * @return
     */
    private CompanyDeclareRequest getDeclareRequestParameter(TaxUnitInfo taxUnitInfo,
                                                             IncomeTaxDeclarInfo taxDeclarInfo
    ) throws BOSException, JsonProcessingException, EASBizException, SQLException {
        LOG.error("getDeclareRequestParameter-----------taxDeclarInfo-----" + taxDeclarInfo);
        CompanyDeclareRequest declareRequestPara = new CompanyDeclareRequest();
        Map<String, Object> requestParamMap = new HashMap();
        //随机id
        String bizNo = UUID.randomUUID().toString();
        LOG.error("bizNo:" + bizNo);
        //外部业务订单号*
        declareRequestPara.setBizNo(bizNo);
        //企业名称*
        declareRequestPara.setName(taxUnitInfo.getName());
        //税号*
        declareRequestPara.setTaxNo(taxUnitInfo.getTaxNumber());
        //行政区划代码*
        declareRequestPara.setArea(taxUnitInfo.getAreaCode());
        //登记序号
        declareRequestPara.setRegistrationNumber(taxUnitInfo.getRegNumber());
        String declPassword = taxUnitInfo.getDeclPassword();
        //申报密码

        if (StringUtils.isEmpty(declPassword)) {
            //实名账号
            declareRequestPara.setRealNameAccount(taxUnitInfo.getString("realAccount"));
            //实名密码
            declareRequestPara.setRealNamePassword(Base64Utils.decode(taxUnitInfo.getRealPassword()));
            //密码类型
            declareRequestPara.setPasswordType("2");
        }else {

            String sbmm = new String(Base64Utils.decode(declPassword));

            declareRequestPara.setDeclarePassword(sbmm);
            //密码类型
            declareRequestPara.setPasswordType("0");
        }

        //所得月份
        String yearMonth = taxDeclarInfo.getYearMonth();
        String replaceYearMonth = yearMonth.replace("-", "");
        LOG.error("replaceYearMonth----------------" + replaceYearMonth);
        //税款所属期YYYYMM*
        declareRequestPara.setMonth(replaceYearMonth);

        //离职日期处理策略 1、不传或传1，代表离职日期自动清空，即人员状态由“非正常”变更为“正常”时，离职日期字段自动清空，默认逻辑。
        //2、传2离职日期不自动清空，即人员状态由“非正常”变更为“正常”时，离职日期不自动清空，客户如需清空需对离职日期字段传入空字符串。
        //declareRequestPara.setResignDateStrategy();
        //批次号
        String batchNo = taxDeclarInfo.getBatchNo();
        LOG.error("taxCalConfigDetailCollection--------taxDeclarInfo---------" + taxDeclarInfo);
        //个税应用+税款计算最终拆分明细表
        ITaxCalConfigDetail taxCalConfigDetail = TaxCalConfigDetailFactory.getLocalInstance(ctx);
        TaxCalConfigDetailCollection taxCalConfigDetailCollection = taxCalConfigDetail.getTaxCalConfigDetailCollection("select *,incomeItem.*, person.* where batchNo = '" + batchNo + "' and state = '20'");
        LOG.error("taxCalConfigDetailCollection-----------------" + taxCalConfigDetailCollection.size());
        //员工信息ID
        Set personIds = new HashSet();
        if (taxCalConfigDetailCollection.size() > 0) {
            for (int i = 0; i < taxCalConfigDetailCollection.size(); i++) {
                TaxCalConfigDetailInfo taxCalConfigDetailInfo = taxCalConfigDetailCollection.get(i);
                //员工信息
                PersonInfo personInfo = taxCalConfigDetailInfo.getPerson();
                personIds.add(personInfo.getId().toString());
            }
        }

        Map<String, String> paramDataMap = Maps.newHashMap();
        paramDataMap.put("taxUnitId",taxUnitInfo.getId().toString());
        paramDataMap.put("batchNo",batchNo);
        Map<String, List<Map<String, Object>>> caluDataMap = getCaluData(ctx, paramDataMap,this.getTaxItemMap(ctx));
        //综合所得
        //综合所得对象
        ComplexIncomeRequest complexIncomeRequest = new ComplexIncomeRequest();
        declareRequestPara.setComplexIncomeRequest(complexIncomeRequest);
        //是否离线算薪
        //complexIncomeRequest.setIsOffLineCalculateTax();
        //减免方式
        //complexIncomeRequest.setDeductionMode();
        //减免比例
        //complexIncomeRequest.setRatio();
        //减免限额
        //complexIncomeRequest.setLimitAmount();
        //正常工资薪金对象
        NormalSalarySpecIncome normalSalarySpecIncome = getNormalSalarySpecIncome(caluDataMap);
        complexIncomeRequest.setNormalSalarySpecIncome(normalSalarySpecIncome);
        //全年一次性奖金收入列表
        List<ComplexIncome> annualOneTimeBonusIncomeList = getAnnualOneTimeBonusIncomeList(caluDataMap);
        complexIncomeRequest.setAnnualOneTimeBonusIncome(annualOneTimeBonusIncomeList);
        //一般劳务报酬所得列表
        List<ComplexIncome> laborRemunerationIncome = getLaborRemunerationIncome(caluDataMap);
        complexIncomeRequest.setLaborRemunerationIncome(laborRemunerationIncome);
        //解除劳动合同一次性补偿金列表
        List<ComplexIncome> compensateIncome = getCompensateIncome(caluDataMap);
        complexIncomeRequest.setCompensateIncome(compensateIncome);
        //企业员工列表
        List<DetailCompanyEmployee> companyEmployeeList = getCompanyEmployeeList(personIds,taxUnitInfo);
        declareRequestPara.setCompanyEmployeeList(companyEmployeeList);
        return declareRequestPara;
    }
    /**
     * 解除劳动合同一次性补偿金列表
     *
     * @param caluDataMap
     * @return
     */
    private List<ComplexIncome> getCompensateIncome(
            Map<String, List<Map<String, Object>>> caluDataMap) {
        List<ComplexIncome> compensateIncome = new ArrayList<ComplexIncome>();
        List<Map<String, Object>> list = caluDataMap.get("jcldhtlb");
        for (int i = 0; list != null && i < list.size(); i++) {
            //个税应用+税款计算初算明细表
            Map<String, Object> map = list.get(i);
            ComplexIncome complexIncome = new ComplexIncome();
            //姓名*
            complexIncome.setName((String) map.get("personName"));
            //证件类型名称*
            complexIncome.setLicenseType((String) map.get("cardType"));
            //证件号码*
            complexIncome.setLicenseNumber((String) map.get("cardNumber"));
            //当期收入额*  一次性补偿
            complexIncome.setIncome((BigDecimal) map.get("ycxbc"));
            //免税收入
            complexIncome.setExemptIncome((BigDecimal) map.get("mssd"));
            //其他
            //complexIncome.setOther(BigDecimal.ZERO);
            //减免税额      无
            complexIncome.setTaxDeduction((BigDecimal) map.get("jmse"));
            //备注
            //complexIncome.setRemark("");
            //所得项目名称*
            complexIncome.setIncomeItemName("一般劳务报酬所得");
            //准予扣除的捐赠额      无
            complexIncome.setDeductibleDonation((BigDecimal) map.get("zykcjze"));
            compensateIncome.add(complexIncome);
        }
        return compensateIncome;
    }

    /**
     * 一般劳务报酬所得列表
     *
     * @param caluDataMap
     * @return
     */
    private List<ComplexIncome> getLaborRemunerationIncome(Map<String, List<Map<String, Object>>> caluDataMap) {
        List<ComplexIncome> laborRemunerationIncome = new ArrayList<>();
        List<Map<String, Object>> list = caluDataMap.get("lwbclb");
        for (int i = 0; list != null && i < list.size(); i++) {
            Map<String, Object> map = list.get(i);
            ComplexIncome complexIncome = new ComplexIncome();
            //姓名*
            complexIncome.setName((String) map.get("personName"));
            //证件类型名称*
            complexIncome.setLicenseType((String) map.get("cardType"));
            //证件号码*
            complexIncome.setLicenseNumber((String) map.get("cardNumber"));
            //是否明细申报
            //complexIncome.setIsDetailedDeclaration("");
            //当期收入额*
            complexIncome.setIncome((BigDecimal) map.get("sre"));
            //免税收入
            complexIncome.setExemptIncome((BigDecimal) map.get("mssd"));
            //商业健康保险
            complexIncome.setCommercialHealthInsurance((BigDecimal) map.get("syjkbx"));
            //税延养老保险
            complexIncome.setExtensionEndowmentInsurance((BigDecimal) map.get("syylbx"));
            //其他
            //complexIncome.setOther(BigDecimal.ZERO);
            //减免税额
            complexIncome.setTaxDeduction((BigDecimal) map.get("jmse"));
            //备注
            //complexIncome.setRemark("");
            //减除费用
            // complexIncome.setDeductionAmount(BigDecimal.ZERO);
            //应纳税额
            //complexIncome.setPayableAmount(BigDecimal.ZERO);
            //税率
            //complexIncome.setTaxRate(BigDecimal.ZERO);
            //所得项目名称*
            complexIncome.setIncomeItemName("一般劳务报酬所得");
            //允许扣除的税费
            complexIncome.setTaxDeductible((BigDecimal) map.get("yxkcsf"));
            laborRemunerationIncome.add(complexIncome);
        }
        return laborRemunerationIncome;
    }


    /**
     * 全年一次性奖金收入列表
     *
     * @return
     */
    private List<ComplexIncome> getAnnualOneTimeBonusIncomeList(
            Map<String, List<Map<String, Object>>> caluDataMap) {
        List<ComplexIncome> annualOneTimeBonusIncome = new ArrayList<>();
        List<Map<String, Object>> list = caluDataMap.get("qnycxjjlb");
        for (int i = 0; list != null && i < list.size(); i++) {
            Map<String, Object> map = list.get(i);
            ComplexIncome complexIncome = new ComplexIncome();
            //姓名*
            complexIncome.setName((String) map.get("personName"));
            //证件类型名称*
            complexIncome.setLicenseType((String) map.get("cardType"));
            //证件号码*
            complexIncome.setLicenseNumber((String) map.get("cardNumber"));
            //批次号(一月多次发薪)
            //complexIncome.setBatchNo(0);
            //当期收入额*
            complexIncome.setIncome((BigDecimal) map.get("sre"));
            //免税收入
            complexIncome.setExemptIncome((BigDecimal) map.get("mssd"));
            //其他
            //complexIncome.setOther(BigDecimal.ZERO);
            //减免税额
            complexIncome.setTaxDeduction((BigDecimal) map.get("jmse"));
            //备注
            //complexIncome.setRemark("");
            //所得项目名称*
            complexIncome.setIncomeItemName("全年一次性奖金收入");
            //准予扣除的捐赠额
            complexIncome.setDeductibleDonation((BigDecimal) map.get("zykcjze"));
            annualOneTimeBonusIncome.add(complexIncome);
        }
        return annualOneTimeBonusIncome;
    }

    /**
     * 获取正常工资薪金参数
     *
     * @return
     */
    private NormalSalarySpecIncome getNormalSalarySpecIncome
    (Map<String, List<Map<String, Object>>> caluDataMap) {
        //正常工资薪金对象
        NormalSalarySpecIncome normalSalarySpecIncome = new NormalSalarySpecIncome();
        //企业人员列表*
        List<DetailCompanyEmployee> companyEmployeeList = getCompanyEmployeeList(caluDataMap);
        normalSalarySpecIncome.setCompanyEmployeeList(companyEmployeeList);
        //正常工资薪金是否需要专项*
        normalSalarySpecIncome.setZcgzxjsfxyzx("1");
        //正常工资薪金是否传入累计（申报/单月计算时使用）
        normalSalarySpecIncome.setZcgzxjsfcrlj("1");
        //支持上月传专项或者累计专项金额（仅对两月算税上月薪金列表算税数据生效）
        //normalSalarySpecIncome.setZcgzxjsfcrzx("");
        //是否已申报上月正常工资薪金（两个月算税场景）
        //normalSalarySpecIncome.setDeclaredLastMonth("");
        //批次号(一月多次发薪)
        //normalSalarySpecIncome.setBatchNo(0);
        //导入上月正常工资薪金(一月多次发薪)
        normalSalarySpecIncome.setImportLastMonthSalaryOption("");
        //是否需要人员申报
        normalSalarySpecIncome.setDeclareEmployeeOption("");
        //年金算税上限选项
        normalSalarySpecIncome.setAnnuityAndHouseProvidentFundOption("");
        //是否使用上月传入的应补退税额
        normalSalarySpecIncome.setMultiCalculateTaxUseRefundTax("");
        //个人养老金策略
        normalSalarySpecIncome.setPersonalPensionOption("1");
        //上月个人养老金策略
        normalSalarySpecIncome.setLastMonthPersonalPensionOption("");
        //离职日期处理策略
        normalSalarySpecIncome.setResignDateStrategy("");
        //是否使用已报送人员信息进行补全
        //normalSalarySpecIncome.setSfsybsrybq();
        //上月正常工资薪金(带专项)列表
        //normalSalarySpecIncome.setLastMonthNormalSalary();
        List<ComplexIncome> normalSalarySpec = new ArrayList<>();
        //正常工资薪金(带专项)列表*
        normalSalarySpecIncome.setNormalSalarySpec(normalSalarySpec);
        List<Map<String, Object>> list = caluDataMap.get("zcgzxjlb");
        for (int i = 0; list != null && i < list.size(); i++) {
            Map<String, Object> map = list.get(i);
            ComplexIncome complexIncome = new ComplexIncome();
            //姓名*
            complexIncome.setName((String) map.get("personName"));
            //证件类型名称*
            complexIncome.setLicenseType((String) map.get("cardType"));
            //证件号码*
            complexIncome.setLicenseNumber((String) map.get("cardNumber"));
            //是否明细申报
            //complexIncome.setIsDetailedDeclaration("");
            //当期收入额*
            complexIncome.setIncome((BigDecimal) map.get("sre"));
            //免税收入
            complexIncome.setExemptIncome((BigDecimal) map.get("mssd"));
            //基本养老保险
            complexIncome.setEndowmentInsurance((BigDecimal) map.get("jbylaobxf"));
            //基本医疗保险
            complexIncome.setMedicalInsurance((BigDecimal) map.get("jbylbxf"));
            //失业保险
            complexIncome.setUnemploymentInsurance((BigDecimal) map.get("sybxf"));
            //住房公积金
            complexIncome.setHouseProvidentFund((BigDecimal) map.get("zfgjj"));

            //子女教育支出
            complexIncome.setAccumulatedChildEducation((BigDecimal) map.get("znjyzc"));
            //继续教育支出
            complexIncome.setAccumulatedContinueEducation((BigDecimal) map.get("jxjyzc"));
            //婴幼儿照护支出
            complexIncome.setAccumulatedBabyCare((BigDecimal) map.get("yyezhfzc"));
            //累计个人养老金
            complexIncome.setAccumulatedPersonalPension((BigDecimal) map.get("grylj"));
            //房屋贷款支出
            complexIncome.setAccumulatedHouseLoan((BigDecimal) map.get("zfdklxzc"));
            //住房租金支出
            complexIncome.setAccumulatedHouseRent((BigDecimal) map.get("zfzjzc"));
            //赡养老人支出
            complexIncome.setAccumulatedSupportElder((BigDecimal) map.get("sylrzc"));
            //累计其他扣除
            complexIncome.setOtherDeductionSum((BigDecimal) map.get("zxkchj"));
            //累计继续教育
            complexIncome.setAccumulatedContinueEducation((BigDecimal) map.get("jxjyzc"));
            //累计专项附加扣除合计
            complexIncome.setSpecAttachDeductionSum((BigDecimal) map.get("zxfjkchj"));
            // 企业年金/职业年金
            complexIncome.setAnnuity((BigDecimal) map.get("nj"));
            //商业健康保险
            complexIncome.setCommercialHealthInsurance((BigDecimal) map.get("syjkbx"));
            //税延养老保险
            complexIncome.setExtensionEndowmentInsurance((BigDecimal) map.get("syylbx"));
            //其他
            //complexIncome.setOther(BigDecimal.ZERO);
            normalSalarySpec.add(complexIncome);
        }
        return normalSalarySpecIncome;
    }

    /**
     * 获取企业人员列表
     */
    private List<DetailCompanyEmployee> getCompanyEmployeeList(Map<String, List<Map<String, Object>>> caluDataMap) {
        List<DetailCompanyEmployee> companyEmployeeList = new ArrayList<>();
        List<Map<String, Object>> list = caluDataMap.get("zcgzxjlb");
        for (int i = 0; list != null && i < list.size(); i++) {
            Map<String, Object> map = list.get(i);
            DetailCompanyEmployee employee = new DetailCompanyEmployee();
            //姓名*
            employee.setName((String) map.get("personName"));
            //证件类型名称*
            employee.setLicenseType((String) map.get("cardType"));
            //证件号码*
            employee.setLicenseNumber((String) map.get("cardNumber"));
            //部门编号
            //employee.setDeptNo("");
            //工号
            employee.setEmployeeNumber((String) map.get("personNumber"));
            //所属期
            //employee.setPeriod("");
            //手机号码  中国籍必填；非中国籍首次入境时间超过一个月必填；
            employee.setPhone((String) map.get("phoneNumber"));
            //人员状态* 默认为正常，可选择正常/非正常
            employee.setState((String) map.get("personstatusName"));
            //是否雇员* 可选择雇员、保险营销员、证券经纪人、其他、实习学生（全日制学历教育）
            employee.setIsEmployee((String) map.get("employedtypeName"));
            //入职年度就业情况  当雇员保险营销员、证券经纪人时可选择：当年首次入职学生、当年首次入职其他人员。其他情况下填写默认为空
            employee.setFirstEmploymentSituation((String) map.get("situationName"));
            //受雇日期
            employee.setEmployedDate((String) map.get("employeddate"));
            //性别*   男/女
            employee.setGender((String) map.get("gender"));
            //出生日期* YYYY-MM-DD 需要和身份证上保持一致
            employee.setBirthday((String) map.get("birthday"));
            //国籍*
            employee.setNationality((String) map.get("nationalityName"));
            //人员地区* 境内/境外
            employee.setArea((String) map.get("isoversea"));
            //离职日期
            employee.setResignDate((String) map.get("departuredate"));
            //个人投资总额
            employee.setPersonInvestment((BigDecimal) map.get("investmenttotal"));
            //个人投资比例
            employee.setPersonInvestmentRatio((BigDecimal) map.get("investmentrate"));
            //是否残疾
            String isdisability = (String) map.get("isdisability");
            employee.setIsDisabled(isdisability);
            if ("是".equals(isdisability)) {
                //todo 残疾证件类型
                employee.setDisableCardTypeName("残疾证");
            }
            //是否烈属
            employee.setIsMartyr((String) map.get("ishero"));
            //是否孤老
            employee.setIsBereavedGaffer((String) map.get("isold"));
            //残疾证号
            employee.setDisableCardNumber((String) map.get("discardnumber"));
            //烈属证号
            employee.setMartyrCardNumber((String) map.get("herocardnumber"));
            //电子邮箱
            employee.setEmail((String) map.get("email"));
            //学历
            employee.setEducation((String) map.get("diploma"));
            //职务
            employee.setPosition((String) map.get("positionName"));
            //开户银行省份(名字)
            employee.setDepositBankProvinceName((String) map.get("bankcardprovince"));
            //开户银行
            employee.setDepositBank((String) map.get("bankcardprovince"));
            //银行账号
            employee.setBankAccount((String) map.get("account"));
            //居住省份
            employee.setResidentProvince((String) map.get("address"));
            //居住城市
            employee.setResidentCity((String) map.get("addresscity"));
            //居住区县
            employee.setResidentDistrict((String) map.get("addresscounty"));
            //居住街道
            employee.setResidentStreet((String) map.get("addressstreet"));
            //户籍省份
            employee.setCensusProvince((String) map.get("hometown"));
            //户籍城市
            employee.setCensusCity((String) map.get("hometowncity"));
            //户籍区县
            employee.setCensusDistrict((String) map.get("hometowncountry"));
            //户籍街道
            employee.setCensusStreet((String) map.get("hometownstreet"));
            //户籍详细地址
            employee.setCensusAddress((String) map.get("hometowndetailed"));
            //备注
            employee.setEmpRemark((String) map.get("desc"));
            //出生地
            employee.setBirthplace((String) map.get("birthplaceName"));
            //首次入境时间
            employee.setFirstEntryDate((String) map.get("entrydate"));
            //预计离境时间
            employee.setEstimatedDepartureDate((String) map.get("leavedate"));
            //联系地省份
            employee.setContactProvince((String) map.get("contactaddress"));
            //联系地城市
            employee.setContactCity((String) map.get("contactcity"));
            //联系地区县
            employee.setContactDistrict((String) map.get("contactcountry"));
            //联系地街道
            employee.setContactStreet((String) map.get("contactstreet"));
            //联系地详细地址
            employee.setContactStreet((String) map.get("contactdetailed"));
            //中文名
            employee.setChineseName((String) map.get("chinesename"));
            //涉税事项
            employee.setTaxRelatedReason((String) map.get("taxreason"));
            //其他证件号码
            employee.setOtherLicenseNumber((String) map.get("othercardnumber"));
            //其他证件类型    其他证件类型为：外国人永久居留身份证（外国人永久居留证），外国护照，中华人民共和国外国人工作许可证（A类），中华人民共和国外国人工作许可证（B类），中华人民共和国外国人工作许可证（C类）,中华人民共和国港澳居民居住证,中华人民共和国台湾居民居住证，中国护照，港澳居民来往内地通行证，台湾居民来往大陆通行证，其他证件号码必填
            employee.setOtherLicenseType((String) map.get("othercardtype"));
            //是否扣除减除费用（原是否主单位）
            employee.setIsMainUnits((String) map.get("deductfees"));
            companyEmployeeList.add(employee);
        }
        return companyEmployeeList;
    }
    /**
     * 获取个税项目
     *
     * @param ctx
     * @return
     * @throws BOSException
     */
    private  Map<String, String> getTaxItemMap(Context ctx) throws BOSException {
        Map<String, String> taxItemInitMap = new HashMap<>();
        //获取所有个税项目
        Set initSet = new HashSet();
        initSet.add("sre");//当期收入额
        initSet.add("mssd");//免税收入
        initSet.add("jbylaobxf");//基本养老保险
        initSet.add("jbylbxf");//基本医疗保险
        initSet.add("sybxf");//失业保险
        initSet.add("zfgjj");//住房公积金
        initSet.add("nj");//企业年金
        initSet.add("syjkbx");//商业健康保险
        initSet.add("zykcjze");//准予扣除的捐赠额
        initSet.add("jmse");//减免税额
        initSet.add("syylbx");//税延养老保险
        initSet.add("yxkcsf");//允许扣除的税费
        initSet.add("ycxbc");//一次性补偿

        initSet.add("znjyzc");  // 累计子女教育支出
        initSet.add("jxjyzc");  // 累计继续教育支出
        initSet.add("yyezhfzc");  // 累计婴幼儿照护支出
        initSet.add("grylj");  // 累计个人养老金
        initSet.add("zfdklxzc");  // 累计房屋贷款支出
        initSet.add("zfzjzc");  // 住房租金支出
        initSet.add("sylrzc");  // 赡养老人支出
        initSet.add("zxkchj");  // 累计其他扣除
        initSet.add("zxfjkchj");  // 累计专项附加扣除合计
        try {
            com.kingdee.shr.compensation.app.tax.base.TaxItemCollection itemColl = com.kingdee.shr.compensation.app.tax.base.TaxItemFactory.getLocalInstance(ctx)
                    .getTaxItemCollection("where number in (" + AtsUtil.convertSetToString(initSet) + ")");
            for (int i = 0; i < itemColl.size(); ++i) {
                TaxItemInfo info = itemColl.get(i);
                String number = info.getNumber();
                taxItemInitMap.put(number, "T" + info.getFieldSn());
            }
        } catch (BOSException var5) {
            var5.printStackTrace();
            throw new BOSException("获取个税项目报错: " + var5.getMessage());
        }
        return taxItemInitMap;
    }

    /**
     * 获取待计算数据
     */
    private Map<String, List<Map<String, Object>>> getCaluData(Context ctx, Map<String, String> paramDataMap,Map<String, String> taxItemInitMap) throws BOSException {
        try {
            String taxUnitId = paramDataMap.get("taxUnitId");//纳税单位id
            String batchNo = paramDataMap.get("batchNo");//初算数据id
            StringBuilder sql = new StringBuilder();
            sql.append("SELECT ").append("\n");
            for (String number : taxItemInitMap.keySet()) {
                String tableField = taxItemInitMap.get(number);
                sql.append("scid.").append(tableField).append(" ").append(number).append(",\n");
            }
            sql.append("item.fnumber AS itemNumber,").append("\n")
                    .append("personRe.FCARDNUMBER,").append("\n")
                    .append("personRe.FCARDTYPE,").append("\n")
                    .append("(CASE WHEN personRe.FREPORTNAME IS NOT NULL THEN personRe.FREPORTNAME ELSE person.fname_l2 END) AS personName,").append("\n")
                    .append("person.fnumber AS personNumber,").append("\n")
                    .append("personRe.FPHONENUMBER,").append("\n")  // 手机号
                    .append("personRe.FISOVERSEA,").append("\n")  // 是否境外人员
                    .append("personRe.FGENDER,").append("\n")  // 性别
                    .append("personRe.FBIRTHDAY,").append("\n")  // 出生日期
                    .append("personRe.FISDISABILITY,").append("\n")  // 是否残疾
                    .append("personRe.FDISCARDNUMBER,").append("\n")  // 残疾证号
                    .append("personRe.FHEROCARDNUMBER,").append("\n")  // 烈属证号
                    .append("personRe.FEMAIL,").append("\n")  // 电子邮箱
                    .append("personRe.FCHINESENAME,").append("\n")  // 中文名
                    .append("personRe.FISHERO,").append("\n")  // 是否烈属
                    .append("personRe.FISOLD,").append("\n")  // 是否孤老
                    .append("personRe.FADDRESS,").append("\n")  // 居住地省
                    .append("personRe.FADDRESSCITY,").append("\n")  // 居住城市
                    .append("personRe.FADDRESSCOUNTY,").append("\n")  // 居住区县
                    .append("personRe.FADDRESSSTREET,").append("\n")  // 居住街道
                    .append("personRe.FDESC,").append("\n")  // 备注
                    .append("personRe.FHOMETOWN,").append("\n")  // 户籍省份
                    .append("personRe.FHOMETOWNCITY,").append("\n")  // 户籍城市
                    .append("personRe.FHOMETOWNCOUNTRY,").append("\n")  // 户籍区县
                    .append("personRe.FHOMETOWNSTREET,").append("\n")  // 户籍街道
                    .append("personRe.FHOMETOWNDETAILED,").append("\n")  // 户籍详细地址
                    .append("personRe.FACCOUNT,").append("\n")  // 银行账号
                    .append("personRe.FOTHERCARDTYPE,").append("\n")  // 其他证件类型
                    .append("personRe.FOTHERCARDNUMBER,").append("\n")  // 其他证件号码
                    .append("personRe.FTAXREASON,").append("\n")  // 涉税事项
                    .append("personRe.FBANKCARDPROVINCE,").append("\n")  // 开户银行省份
                    .append("bank.fname_l2 AS bankName,").append("\n")  // 开户银行
                    .append("personRe.FCONTACTADDRESS,").append("\n")  // 联系地址_省
                    .append("personRe.FCONTACTCITY,").append("\n")  // 联系地城市
                    .append("personRe.FCONTACTCOUNTRY,").append("\n")  // 联系地区县
                    .append("personRe.FCONTACTSTREET,").append("\n")  // 联系地街道
                    .append("personRe.FCONTACTDETAILED,").append("\n")  // 联系地详细地址
                    .append("personRe.FENTRYDATE,").append("\n")  // 首次入境时间
                    .append("personRe.FLEAVEDATE,").append("\n")  // 预计离境时间
                    .append("personRe.FPOSITION,").append("\n")  // 职务
                    .append("personRe.FINVESTMENTTOTAL,").append("\n")  // 个人投资总额
                    .append("personRe.FINVESTMENTRATE,").append("\n")  // 个人投资比例
                    .append("birthplace.FNAME_L2 AS birthplaceName,").append("\n")  // 出生地
                    .append("nationality.FNAME_L2 AS nationalityName,").append("\n")  // 国籍
                    .append("diploma.fnumber AS diplomaNumber,").append("\n")  // 学历编码
                    .append("personReEntry.FPERSONSTATUS,").append("\n")  // 人员状态
                    .append("personReEntry.FEMPLOYEDDATE,").append("\n")  // 受雇日期
                    .append("personReEntry.FDEPARTUREDATE,").append("\n")  // 离职日期
                    .append("personReEntry.FEMPLOYEDTYPE,").append("\n")  // 任职受雇从业类型
                    .append("personReEntry.FSITUATION,").append("\n")  // 就业情况
                    .append("personReEntry.FDEDUCTFEES").append("\n") // 是否扣除减除费用
                    .append("FROM T_HR_STAXCALCONFIGDETAIL scid ").append("\n")
                    .append("LEFT JOIN T_HR_STaxIncomeItem item ON item.fid = scid.FINCOMEITEMID ").append("\n")

                    .append("LEFT JOIN (select * from ").append("\n")
                    .append(" T_HR_STaxPersonRecordentry where fTaxUnitId||fPersonId||FLASTREPORTMONTH||FEMPLOYEDDATE in( ").append("\n")
                    .append("  select fTaxUnitId||fPersonId||max(FLASTREPORTMONTH)||max(FEMPLOYEDDATE) from T_HR_STaxPersonRecordentry where FSUBMITSTATUS=2 group by FTAXUNITID,FPERSONID  ").append("\n")
                    .append(")) personReEntry ON personReEntry.fPersonId = scid.fPersonId AND scid.fTaxUnitId = personReEntry.fTaxUnitId ").append("\n")
                   //.append("LEFT JOIN T_HR_STaxPersonRecordentry personReEntry ON personReEntry.fPersonId = scid.fPersonId AND scid.fTaxUnitId = personReEntry.fTaxUnitId and personReEntry.FPERSONSTATUS=1 )").append("\n")

                    .append("LEFT JOIN T_HR_STaxPersonRecord personRe ON personReEntry.FBILLID = personRe.fid ").append("\n")
                    .append("LEFT JOIN T_BD_Person person ON person.fid = personRe.FPERSONID ").append("\n")
                    .append("LEFT JOIN T_BD_Nationality birthplace ON birthplace.fid = personRe.FBIRTHPLACEID ").append("\n")
                    .append("LEFT JOIN T_BD_HRDiploma diploma ON diploma.fid = personRe.FEDULEVELID ").append("\n")
                    .append("LEFT JOIN T_HR_PBank bank ON bank.fid = personRe.FHRBANKID ").append("\n")
                    .append("LEFT JOIN T_BD_Nationality nationality ON nationality.fid = personRe.FNATIONALITYID ").append("\n")
                    .append("WHERE scid.FTAXUNITID = '").append(taxUnitId).append("'").append("\n")
                    .append("AND scid.FSTATE = '20' ").append("\n")
                    .append("AND scid.FBATCHNO ='").append(batchNo).append("'").append("\n");
            LOG.info("getCaluData.sql:\n" + sql);
            IRowSet iRowSet = DbUtil.executeQuery(ctx, sql.toString());
            Map<String, List<Map<String, Object>>> dataMap = new HashMap<>();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            while (iRowSet.next()) {
                List<Map<String, Object>> list;
                //所得项目编码
                String itemNumber = iRowSet.getString("itemNumber");
                if (dataMap.containsKey(itemNumber)) {
                    list = dataMap.get(itemNumber);
                } else {
                    list = new ArrayList<>();
                    dataMap.put(itemNumber, list);
                }
                Map map = new HashMap();
                //姓名
                map.put("personName", iRowSet.getString("personName"));
                //工号
                map.put("personNumber", iRowSet.getString("personNumber"));
                //证件号码
                map.put("cardNumber", iRowSet.getString("FCARDNUMBER"));
                //证件类型
                String cardType = iRowSet.getString("FCARDTYPE");
                if (!StringUtils.isEmpty(cardType)) {
                    CardTypeEnum anEnum = CardTypeEnum.getEnum(cardType);
                    if (anEnum != null) {
                        map.put("cardType", anEnum.getAlias());
                    }
                }
                //人员状态
                String personstatus = iRowSet.getString("FPERSONSTATUS");
                if (personstatus != null) {
                    PersonStatusEnum anEnum = PersonStatusEnum.getEnum(personstatus);
                    if (anEnum != null) {
                        map.put("personstatusName", anEnum.getAlias());
                    }
                }
                //任职受雇从业类型
                String employedtype = iRowSet.getString("FEMPLOYEDTYPE");
                if (!StringUtils.isEmpty(employedtype)) {
                    EmployedTypeEnum anEnum = EmployedTypeEnum.getEnum(employedtype);
                    if (anEnum != null) {
                        map.put("employedtypeName", anEnum.getAlias());
                    }
                }
                //手机号码
                map.put("phoneNumber", iRowSet.getString("FPHONENUMBER"));
                //就业情况
                Integer situation = iRowSet.getInt("FSITUATION");
                if (situation != null) {
                    EmploymentSituationEnum anEnum = EmploymentSituationEnum.getEnum(situation);
                    if (anEnum != null) {
                        map.put("situationName", anEnum.getAlias());
                    }
                }
                //性别
                String gender = iRowSet.getString("FGENDER");
                if (!StringUtils.isEmpty(gender)) {
                    GenderEnum anEnum = GenderEnum.getEnum(gender);
                    if (anEnum != null) {
                        map.put("gender", anEnum.getAlias());
                    }
                }
                //否境外人员
                String isoversea = iRowSet.getString("FISOVERSEA");
                if ("1".equals(isoversea)) {
                    map.put("isoversea", "境外");
                } else if ("0".equals(isoversea)) {
                    map.put("isoversea", "境内");
                }
                //是否残疾
                String isdisability = iRowSet.getString("FISDISABILITY");
                if ("1".equals(isdisability)) {
                    map.put("isdisability", "是");
                } else {
                    map.put("isdisability", "否");
                }
                //残疾证号
                map.put("discardnumber", iRowSet.getString("FDISCARDNUMBER"));
                //是否烈属
                String ishero = iRowSet.getString("FISHERO");
                if ("1".equals(ishero)) {
                    map.put("ishero", "是");
                } else {
                    map.put("ishero", "否");
                }
                //烈属证号
                map.put("herocardnumber", iRowSet.getString("FHEROCARDNUMBER"));
                //是否孤老
                String isold = iRowSet.getString("FISOLD");
                if ("1".equals(isold)) {
                    map.put("isold", "是");
                } else {
                    map.put("isold", "否");
                }
                //是否扣除减除费用
                String deductfees = iRowSet.getString("FDEDUCTFEES");
                if ("0".equals(deductfees)) {
                    map.put("deductfees", "是");
                } else {
                    map.put("deductfees", "否");
                }
                //职务
                String position = iRowSet.getString("FPOSITION");
                if (!StringUtils.isEmpty(position)) {
                    com.kingdee.eas.hr.base.PositionTypeEnum anEnum = com.kingdee.eas.hr.base.PositionTypeEnum.getEnum(position);
                    if (anEnum != null) {
                        map.put("positionName", anEnum.getAlias());
                    }
                }
                //电子邮箱
                map.put("email", iRowSet.getString("FEMAIL"));
                //个人投资总额
                map.put("investmenttotal", iRowSet.getBigDecimal("FINVESTMENTTOTAL"));
                //个人投资比例
                map.put("investmentrate", iRowSet.getBigDecimal("FINVESTMENTRATE"));
                //中文名
                map.put("chinesename", iRowSet.getString("FCHINESENAME"));
                //出生日期
                Date birthday = iRowSet.getDate("FBIRTHDAY");
                if (birthday != null) {
                    map.put("birthday", sdf.format(birthday));
                }
                //受雇日期
                Date employeddate = iRowSet.getDate("FEMPLOYEDDATE");
                if (employeddate != null) {
                    map.put("employeddate", sdf.format(employeddate));
                }
                //离职日期
                Date departuredate = iRowSet.getDate("FDEPARTUREDATE");
                if (departuredate != null) {
                    map.put("departuredate", sdf.format(departuredate));
                }
                //出生地
                map.put("birthplaceName", iRowSet.getString("birthplaceName"));
                //学历
                int diplomaNumber = iRowSet.getInt("diplomaNumber");
                //todo 大学本科以下 大学本科 研究生
                if (diplomaNumber < 6) {
                    map.put("diploma", "大学本科以下");
                } else if (diplomaNumber == 6) {
                    map.put("diploma", "大学本科");
                } else if (diplomaNumber > 6) {
                    map.put("diploma", "研究生");
                }
                //开户银行省份
                map.put("bankcardprovince", iRowSet.getString("FBANKCARDPROVINCE"));
                //开户银行
                map.put("bankName", iRowSet.getString("bankName"));
                //银行账号
                map.put("account", iRowSet.getString("FACCOUNT"));
                //其他证件类型
                map.put("othercardtype", iRowSet.getString("FOTHERCARDTYPE"));
                //其他证件号码
                map.put("othercardnumber", iRowSet.getString("FOTHERCARDNUMBER"));
                //居住地省
                map.put("address", iRowSet.getString("FADDRESS"));
                //居住城市
                map.put("addresscity", iRowSet.getString("FADDRESSCITY"));
                //居住区县
                map.put("addresscounty", iRowSet.getString("FADDRESSCOUNTY"));
                //居住街道
                map.put("addressstreet", iRowSet.getString("FADDRESSSTREET"));
                //户籍省份
                map.put("hometown", iRowSet.getString("FHOMETOWN"));
                //户籍城市
                map.put("hometowncity", iRowSet.getString("FHOMETOWNCITY"));
                //户籍城市
                map.put("hometowncountry", iRowSet.getString("FHOMETOWNCOUNTRY"));
                //户籍街道
                map.put("hometownstreet", iRowSet.getString("FHOMETOWNSTREET"));
                //户籍详细地址
                map.put("hometowndetailed", iRowSet.getString("FHOMETOWNDETAILED"));
                //国籍
                map.put("nationalityName", iRowSet.getString("nationalityName"));
                //涉税事项
                map.put("taxreason", iRowSet.getString("FTAXREASON"));
                //首次入境时间
                Date entrydate = iRowSet.getDate("FENTRYDATE");
                if (entrydate != null) {
                    map.put("entrydate", sdf.format(entrydate));
                }
                //预计离境时间
                Date leavedate = iRowSet.getDate("FLEAVEDATE");
                if (leavedate != null) {
                    map.put("leavedate", sdf.format(leavedate));
                }
                //联系地址_省
                map.put("contactaddress", iRowSet.getString("FCONTACTADDRESS"));
                //联系地城市
                map.put("contactcity", iRowSet.getString("FCONTACTCITY"));
                //联系地区县
                map.put("contactcountry", iRowSet.getString("FCONTACTCOUNTRY"));
                //联系地街道
                map.put("contactstreet", iRowSet.getString("FCONTACTSTREET"));
                //联系地详细地址
                map.put("contactdetailed", iRowSet.getString("FCONTACTDETAILED"));
                //备注
                map.put("desc", iRowSet.getString("FDESC"));
                for (String number : taxItemInitMap.keySet()) {
                    map.put(number, iRowSet.getBigDecimal(number));
                }
                list.add(map);
            }
            return dataMap;
        } catch (Exception e) {
            e.printStackTrace();
            throw new BOSException("获取待计算数据报错： " + e.getMessage());
        }
    }


    /***
     * 员工
     * @return
     */
    private ComplexIncome getComplexIncome(PersonInfo personInfo, String incomeItemName, BigDecimal sre) {
        ComplexIncome complexIncome = new ComplexIncome();
        //姓名
        complexIncome.setName(personInfo.getName());
        //居民身份证
        if (personInfo.getIdCardNO() != null) {
            //证照号码
            complexIncome.setLicenseNumber(personInfo.getIdCardNO());
            //证照类型
            complexIncome.setLicenseType("居民身份证");
        }
        //中国护照不
        if (personInfo.getPassportNO() != null) {
            //证照类型
            complexIncome.setLicenseType("中国护照");
            //证照号码
            complexIncome.setLicenseNumber(personInfo.getPassportNO());
        }
        //收入额
        complexIncome.setIncome(sre);
        complexIncome.setIncomeItemName(incomeItemName);
        return complexIncome;
    }

    /**
     * 企业员工列表*
     *
     * @return
     */
    private List<DetailCompanyEmployee> getCompanyEmployeeList(Set personIds,TaxUnitInfo taxUnitInfo) throws BOSException, EASBizException {
        List<DetailCompanyEmployee> companyEmployeeList = new ArrayList<DetailCompanyEmployee>();
        SelectorItemCollection sic = new SelectorItemCollection();
        sic.add("*");
        FilterInfo filterInfo = new FilterInfo();
        filterInfo.getFilterItems().add(new FilterItemInfo("id", personIds, CompareType.INCLUDE));
        EntityViewInfo entityViewInfo = EntityViewInfo.getInstance(filterInfo, sic, null);        //获取人员数据
        PersonCollection personCollection = PersonFactory.getLocalInstance(ctx).getPersonCollection(entityViewInfo);
        if (personCollection.size() > 0) {
            for (int i = 0; i < personCollection.size(); i++) {
                PersonInfo personInfo = personCollection.get(i);
                companyEmployeeList.add(getDetailCompanyEmployee(personInfo,taxUnitInfo));
            }
        }

        return companyEmployeeList;
    }

    /**
     * 人员
     *
     * @return
     */
    public DetailCompanyEmployee getDetailCompanyEmployee(PersonInfo personInfo,TaxUnitInfo taxUnitInfo) throws BOSException, EASBizException {

        //人员对象
        DetailCompanyEmployee detailCompanyEmployee = new DetailCompanyEmployee();
        ////姓名
        //detailCompanyEmployee.setName("何云");
        ////证件类型
        //detailCompanyEmployee.setLicenseType("居民身份证");
        ////证照号码
        //detailCompanyEmployee.setLicenseNumber("429004198601085125");
        //姓名
        detailCompanyEmployee.setName(personInfo.getName());
        //complexIncome.setName("何云");
        //居民身份证
        if (personInfo.getIdCardNO() != null) {
            //证照号码
            detailCompanyEmployee.setLicenseNumber(personInfo.getIdCardNO());
            //证照类型
            detailCompanyEmployee.setLicenseType("居民身份证");
            //人员地区
            detailCompanyEmployee.setArea("境内");
        }
        //中国护照
        if (personInfo.getPassportNO() != null) {
            //证照类型
            detailCompanyEmployee.setLicenseType("中国护照");
            //证照号码
            detailCompanyEmployee.setLicenseNumber(personInfo.getPassportNO());
            //人员地区
            detailCompanyEmployee.setArea("境外");
        }
        //电话号码
        detailCompanyEmployee.setPhone(personInfo.getCell());

        //人员状态
        detailCompanyEmployee.setState(personInfo.getEmployeeType().getName());
        //人员报税信息->任职受雇从业信息
        ITaxPersonRecordEntry iTaxPersonRecordEntry = TaxPersonRecordEntryFactory.getLocalInstance(ctx);
        EntityViewInfo view = new EntityViewInfo();
        FilterInfo filter = new FilterInfo();
        filter.getFilterItems().add(new FilterItemInfo("person.id",personInfo.getId().toString()));
        filter.getFilterItems().add(new FilterItemInfo("personstatus",1));
        filter.getFilterItems().add(new FilterItemInfo("taxUnit.id",taxUnitInfo.getId().toString()));
        view.setFilter(filter);
        SelectorItemCollection selector = new SelectorItemCollection();
        selector.add(new SelectorItemInfo("id"));
        selector.add(new SelectorItemInfo("employedType"));
        selector.add(new SelectorItemInfo("employedDate"));
        view.setSelector(selector);
        TaxPersonRecordEntryCollection taxPersonRecordEntryCollection = iTaxPersonRecordEntry.getTaxPersonRecordEntryCollection(view);
        if(null==taxPersonRecordEntryCollection&&taxPersonRecordEntryCollection.size()<=0) {
            FilterInfo filter1 = new FilterInfo();
            filter1.getFilterItems().add(new FilterItemInfo("person.id",personInfo.getId().toString()));
            filter1.getFilterItems().add(new FilterItemInfo("taxUnit.id",taxUnitInfo.getId().toString()));
            view.setFilter(filter1);
            taxPersonRecordEntryCollection = iTaxPersonRecordEntry.getTaxPersonRecordEntryCollection(view);
        }
        TaxPersonRecordEntryInfo taxPersonRecordEntryInfo = taxPersonRecordEntryCollection.get(0);
        //任职受雇类型  可选择雇员、保险营销员、证券经纪人、其他、实习学生（全日制学历教育）
        //detailCompanyEmployee.setIsEmployee("其他");
        detailCompanyEmployee.setIsEmployee(taxPersonRecordEntryInfo.getEmployedType().getAlias());
        //受雇日期  YYYY-MM-DD,不能大于当前时间，任职受雇类型选择雇员、保险营销员、证券经纪人时必录
        SimpleDateFormat inputFormat = new SimpleDateFormat("yyyy-MM-dd");
        detailCompanyEmployee.setEmployedDate(inputFormat.format(taxPersonRecordEntryInfo.getEmployedDate()));
        //性别
        detailCompanyEmployee.setGender(personInfo.getGender().getAlias());
        //出生日期
        detailCompanyEmployee.setBirthday(inputFormat.format(personInfo.getBirthday()));
        //国籍 nationality
        NationalityInfo nationality = personInfo.getNationality();
        detailCompanyEmployee.setNationality(nationality.getName());

        return detailCompanyEmployee;
    }


    private String getCheckSqlByType(Map<String, Object> incomeIdMap, String taxUnitId, String yearMonth, TbTypeEnum typeEnum) {
        StringBuilder sqlBuf = new StringBuilder();
        sqlBuf.append(" SELECT distinct tx.FTAXUNITID,t1.Fname_l2 as TAXNAME,p1.FNUMBER,p1.Fname_l2 as PERSONNAME, ti.fIncomeCode ");
        sqlBuf.append(" FROM T_HR_STaxCalConfigDetail tx  ");
        sqlBuf.append(" left join T_HR_TAXUNIT as t1 on t1.fid = tx.FTaxUnitID  ");
        sqlBuf.append(" left join T_BD_PERSON as p1 on p1.fid = tx.FPersonId  ");
        sqlBuf.append(" left join t_hr_sTaxIncomeItem as ti on tx.fIncomeItemId = ti.fid ");
        String dateFilter = CmpSQLUtil.generateSqlDateFilter("tx.FPeriodBegin", "tx.FPeriodEnd", yearMonth);
        sqlBuf.append(" where ").append(dateFilter);
        sqlBuf.append(" and tx.FTAXUNITID='").append(taxUnitId).append("'");
        sqlBuf.append(" and tx.FSTATE=10");
        sqlBuf.append(" and tx.FIsLast=1");
        sqlBuf.append(" and tx.FIncomeItemId in ").append(incomeIdMap.get(typeEnum.getValue()));
        return sqlBuf.toString();
    }

    //private Map<String, Object> checkTaxDeclareData(Context ctx, List<IncomeTaxDeclarInfo> waitToDeclareList) throws BOSException {
    //    Map<String, Object> checkDataResultMap = new HashMap();
    //    return null;
    //}
    private Map<String, Object> checkTaxDeclareData(Context ctx, HttpServletRequest request, List<IncomeTaxDeclarInfo> waitToDeclareList) throws BOSException, SQLException, ShrWebBizException {
        Map<String, Object> checkDataResultMap = new HashMap();
        boolean hasErrData = false;
        if (waitToDeclareList != null && waitToDeclareList.size() > 0) {
            List<String> preCheckSql = new ArrayList();
            List<String> specCheckForPre = new ArrayList();
            List<String> notPersonCheckSql = new ArrayList();
            List<String> classifyCheckSql = new ArrayList();
            Map<String, Object> incomeIdMap = new HashMap();
            incomeIdMap.put("1", CmpTaxUtil.genIncomeItemId(ctx, "1"));
            incomeIdMap.put("2", CmpTaxUtil.genIncomeItemId(ctx, "2"));
            incomeIdMap.put("3", CmpTaxUtil.genIncomeItemId(ctx, "3"));
            Iterator i$ = waitToDeclareList.iterator();

            String yearMonth;
            while (i$.hasNext()) {
                IncomeTaxDeclarInfo declareInfo = (IncomeTaxDeclarInfo) i$.next();
                TbTypeEnum tbType = declareInfo.getTbType();
                String taxUnitId = declareInfo.getTaxUnit().getId().toString();
                yearMonth = declareInfo.getYearMonth();
                if (tbType != null) {
                    if ("1".equals(tbType.getValue())) {
                        preCheckSql.add(this.getCheckSqlByType(incomeIdMap, taxUnitId, yearMonth, TbTypeEnum.SB0701));
                        specCheckForPre.add(this.getPreCheckSql(declareInfo));
                    } else if ("3".equals(tbType.getValue())) {
                        notPersonCheckSql.add(this.getCheckSqlByType(incomeIdMap, taxUnitId, yearMonth, TbTypeEnum.SB0703));
                    } else {
                        classifyCheckSql.add(this.getCheckSqlByType(incomeIdMap, taxUnitId, yearMonth, TbTypeEnum.SB0702));
                    }
                }
            }

            Map<String, String> reasonOperaMap = new HashMap();
            reasonOperaMap.put("noCalDataReson", EASResource.getString("com.kingdee.shr.compensation.resource.CommonResource", "label140", ctx.getLocale()));
            reasonOperaMap.put("noCalDataOper", EASResource.getString("com.kingdee.shr.compensation.resource.CommonResource", "label141", ctx.getLocale()));
            reasonOperaMap.put("preDataReason", EASResource.getString("com.kingdee.shr.compensation.resource.CommonResource", "label142", ctx.getLocale()));
            reasonOperaMap.put("preDataOpera", EASResource.getString("com.kingdee.shr.compensation.resource.CommonResource", "label143", ctx.getLocale()));
            List<TaxDeclarExcelRowDTO> taxDeclareExcelRowDTOS = new ArrayList();
            taxDeclareExcelRowDTOS.addAll(this.getExceptData(ctx, preCheckSql, specCheckForPre, reasonOperaMap, TbTypeEnum.SB0701));
            taxDeclareExcelRowDTOS.addAll(this.getExceptData(ctx, classifyCheckSql, specCheckForPre, reasonOperaMap, TbTypeEnum.SB0702));
            taxDeclareExcelRowDTOS.addAll(this.getExceptData(ctx, notPersonCheckSql, specCheckForPre, reasonOperaMap, TbTypeEnum.SB0703));
            String filePath = "";
            if (taxDeclareExcelRowDTOS.size() > 0) {
                hasErrData = true;
                HSSFWorkbook workbook = new HSSFWorkbook();
                yearMonth = EASResource.getString("com.kingdee.shr.compensation.resource.CommonResource", "label144", ctx.getLocale());
                this.fillTitle(ctx, workbook, yearMonth.split(","));
                this.fillWorkdBookData(workbook, taxDeclareExcelRowDTOS);
                SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
                File dir = new File(UserUtil.getUserTempDirAbsolutePath(request.getSession()));
                if (!dir.exists()) {
                    dir.mkdirs();
                }

                String fileName = EASResource.getString("com.kingdee.shr.compensation.resource.CommonResource", "label145", ctx.getLocale()) + "_" + format.format(new Date()) + ".xls";
                String realFileName = MD5.md5Hash(fileName);
                File file = new File(dir, realFileName);
                FileOutputStream out = null;

                try {
                    out = new FileOutputStream(file);
                    workbook.write(out);
                    out.flush();
                } catch (FileNotFoundException var33) {
                    LOG.error(var33.getMessage(), var33);
                } catch (IOException var34) {
                    LOG.error(var34.getMessage(), var34);
                } finally {
                    if (out != null) {
                        try {
                            out.close();
                        } catch (IOException var32) {
                            LOG.error(var32.getMessage(), var32);
                        }
                    }

                }

                Map<String, String> params = new HashMap();
                params.put("method", "tmp");
                params.put("file", realFileName);
                params.put("filename", fileName);
                filePath = DynamicUtil.assembleUrl("/downloadfile.do", params);
            }

            checkDataResultMap.put("excel", filePath);
        }

        checkDataResultMap.put("hasErrData", hasErrData);
        return checkDataResultMap;
    }

    private void fillTitle(Context ctx, HSSFWorkbook workbook, String[] titleArr) {
        HSSFSheet sheet = workbook.createSheet();
        HSSFRow createRow = sheet.createRow(0);
        HSSFCell infoCell = createRow.createCell(0);
        infoCell.setCellValue(EASResource.getString("com.kingdee.shr.compensation.resource.CommonResource", "label146", ctx.getLocale()));
        sheet.setColumnWidth(0, 12800);
        createRow = sheet.createRow(1);
        HSSFFont font = workbook.createFont();
        font.setColor((short) 8);
        font.setFontHeightInPoints((short) 12);
        font.setBoldweight((short) 700);
        HSSFCellStyle style = workbook.createCellStyle();
        style.setFont(font);
        style.setAlignment((short) 2);
        style.setVerticalAlignment((short) 1);
        if (titleArr != null && titleArr.length > 0) {
            for (int i = 0; i < titleArr.length; ++i) {
                HSSFCell cell = createRow.createCell(i);
                cell.setCellStyle(style);
                cell.setCellValue(titleArr[i]);
                if (i > 3) {
                    sheet.setColumnWidth(i, 15360);
                } else {
                    sheet.setColumnWidth(i, 7680);
                }
            }
        }

    }

    private void fillWorkdBookData(HSSFWorkbook workbook, List<TaxDeclarExcelRowDTO> dataList) {
        HSSFSheet sheet = workbook.getSheetAt(0);
        if (dataList != null && dataList.size() > 0) {
            for (int i = 0; i < dataList.size(); ++i) {
                HSSFRow row = sheet.createRow(i + 2);
                TaxDeclarExcelRowDTO excelRowDTO = (TaxDeclarExcelRowDTO) dataList.get(i);
                HSSFCell cell = row.createCell(0);
                cell.setCellValue(excelRowDTO.getPersonNum());
                cell = row.createCell(1);
                cell.setCellValue(excelRowDTO.getPersonName());
                cell = row.createCell(2);
                cell.setCellValue(excelRowDTO.getTaxName());
                cell = row.createCell(3);
                cell.setCellValue(excelRowDTO.getDeclarType());
                cell = row.createCell(4);
                cell.setCellValue(excelRowDTO.getReason());
                cell = row.createCell(5);
                cell.setCellValue(excelRowDTO.getOperation());
            }
        }

    }

    private String getSqlDateFilterLqDate(String dateStr) {
        String[] beginDateArr = dateStr.split("-");
        Calendar calendar = Calendar.getInstance();
        calendar.set(Integer.parseInt(beginDateArr[0]), Integer.parseInt(beginDateArr[1]) - 1, 1, 0, 0, 0);
        Date beginDate = calendar.getTime();
        return CmpDateUtil.toKSqlDate(beginDate);
    }

    private List<TaxDeclarExcelRowDTO> getExceptData(Context ctx, List<String> preCheckSql, List<String> specCheckForPre, Map<String, String> noCalDataOper, TbTypeEnum typeEnum) throws BOSException, SQLException, ShrWebBizException {
        List<TaxDeclarExcelRowDTO> taxDeclarExcelRowDTOS = new ArrayList();
        Iterator i$;
        String s;
        IRowSet rowSet;
        TaxDeclarExcelRowDTO taxDeclareExcelRow;
        if (preCheckSql != null && preCheckSql.size() > 0) {
            i$ = preCheckSql.iterator();

            while (i$.hasNext()) {
                s = (String) i$.next();
                rowSet = DbUtil.executeQuery(ctx, s);

                while (rowSet.next()) {
                    taxDeclareExcelRow = new TaxDeclarExcelRowDTO();
                    taxDeclareExcelRow.setPersonNum(rowSet.getString("FNUMBER"));
                    taxDeclareExcelRow.setPersonName(rowSet.getString("PERSONNAME"));
                    String taxUnitName = rowSet.getString("TAXNAME");
                    taxDeclareExcelRow.setTaxName(taxUnitName);
                    taxDeclareExcelRow.setDeclarType(typeEnum.getAlias());
                    taxDeclareExcelRow.setReason((String) noCalDataOper.get("noCalDataReson"));
                    taxDeclareExcelRow.setOperation((String) noCalDataOper.get("noCalDataOper"));
                    String incomeCode = (String) noCalDataOper.get("fIncomeCode");
                    taxDeclarExcelRowDTOS.add(taxDeclareExcelRow);
                }
            }
        }

        if ("1".equals(typeEnum.getValue()) && specCheckForPre != null && specCheckForPre.size() > 0) {
            i$ = specCheckForPre.iterator();

            while (i$.hasNext()) {
                s = (String) i$.next();
                rowSet = DbUtil.executeQuery(ctx, s);

                while (rowSet.next()) {
                    taxDeclareExcelRow = new TaxDeclarExcelRowDTO();
                    taxDeclareExcelRow.setPersonNum(rowSet.getString("FNUMBER"));
                    taxDeclareExcelRow.setPersonName(rowSet.getString("PERSONNAME"));
                    taxDeclareExcelRow.setTaxName(rowSet.getString("TAXNAME"));
                    taxDeclareExcelRow.setDeclarType(typeEnum.getAlias());
                    taxDeclareExcelRow.setReason((String) noCalDataOper.get("preDataReason"));
                    taxDeclareExcelRow.setOperation((String) noCalDataOper.get("preDataOpera"));
                    taxDeclarExcelRowDTOS.add(taxDeclareExcelRow);
                }
            }
        }

        return taxDeclarExcelRowDTOS;
    }

    private String getPreCheckSql(IncomeTaxDeclarInfo incomeTaxDeclarInfo) {
        StringBuilder sqlBuf = new StringBuilder();
        String yearMonth = incomeTaxDeclarInfo.getYearMonth();
        String taxUnitId = incomeTaxDeclarInfo.getTaxUnit().getId().toString();
        String sql = "select FPersonID from T_HR_STaxCalConfigDetail where FTaxUnitId='" + taxUnitId + "' and FPeriodBegin = " + CmpDateUtil.toKSqlDate(incomeTaxDeclarInfo.getYearMonthDate());
        sqlBuf.append(" SELECT distinct ent.FTAXUNITID, t.Fname_l2 as TAXNAME, p.FNUMBER, p.Fname_l2 as PERSONNAME ");
        sqlBuf.append(" FROM T_HR_STaxPersonRecordEntry ent ");
        sqlBuf.append(" left join T_HR_TAXUNIT as t on t.fid = ent.FTaxUnitID ");
        sqlBuf.append(" left join T_BD_PERSON as p on p.fid = ent.FPersonId ");
        sqlBuf.append(" where ent.FSubmitStatus='2' and ent.FPersonStatus='1' ");
        sqlBuf.append(" and ent.FTaxUnitID='").append(taxUnitId).append("'");
        sqlBuf.append(" and ent.FENDDATE <=").append(this.getSqlDateFilterLqDate(yearMonth));
        sqlBuf.append(" and ent.FPersonID not in ( ").append(sql).append(" )");
        return sqlBuf.toString();
    }

    private Map<String, Object> checkIncomeTaxIssue(Context ctx, List<IncomeTaxDeclarInfo> waitToDeclareList) throws BOSException {
        StringBuilder taxUnitIds = new StringBuilder();

        IncomeTaxDeclarInfo declareInfo;
        for (Iterator i$ = waitToDeclareList.iterator(); i$.hasNext(); taxUnitIds.append(declareInfo.getTaxUnit().getId().toString())) {
            declareInfo = (IncomeTaxDeclarInfo) i$.next();
            if (taxUnitIds.length() > 0) {
                taxUnitIds.append(",");
            }
        }

        String oql = "select person.person.name where taxUnit.id in " + CmpStrUtil.buildInSql(taxUnitIds.toString()) + " and result = " + 1 + " and status = " + 2 + " and inviteStatus = " + 0;
        IncomeTaxIssueCollection collection = IncomeTaxIssueFactory.getLocalInstance(ctx).getIncomeTaxIssueCollection(oql);
        if (collection != null && !collection.isEmpty()) {
            StringBuilder errMsg = new StringBuilder();

            for (int i = 0; i < collection.size() && i != 5; ++i) {
                if (errMsg.length() > 0) {
                    errMsg.append(",");
                }

                errMsg.append("[").append(collection.get(i).getPerson().getPerson().getName()).append("]");
            }

            Map<String, Object> map = new HashMap();
            map.put("errMsg", "以下员工存在申诉属实争议，且未进行邀请确认，需要进行发送邀请确认后才可进行个税申报或者进行非正常人员报送（更新人员报税信息中的人员状态为非正常，并进行人员报送成功），员工姓名：" + errMsg.toString() + "，选择[是]则跳转到[申诉争议-申诉属实人员]列表，选择[否]则跳转到[人员报税信息]列表。");
            map.put("issueError", true);
            return map;
        } else {
            return null;
        }
    }

    private String checkTaxCalStatus(Context ctx, List<IncomeTaxDeclarInfo> waitToDeclareList) throws SHRWebException {
        String sql = "select t.fState, u.fName_l2 taxUnitName, d.fIncomeItemId  from t_hr_sTaxCalConfigDetail d left join t_hr_sTaxCalInitDetail t  on d.fCmpCalTableId = t.fCmpCalTableId and d.fIncomeItemId = t.fIncomeItemId  left join t_hr_taxUnit u on d.fTaxUnitId = u.fid  where d.fTaxUnitId = ? and d.fPeriodBegin = ?";

        try {
            Iterator i$ = waitToDeclareList.iterator();

            boolean isTaxCalFinished;
            String taxUnitName;
            do {
                if (!i$.hasNext()) {
                    return null;
                }

                IncomeTaxDeclarInfo declareInfo = (IncomeTaxDeclarInfo) i$.next();
                String taxUnitId = declareInfo.getTaxUnit().getId().toString();
                Date periodDate = declareInfo.getYearMonthDate();
                Object[] param = new Object[]{taxUnitId, CmpDateUtil.toSqlDate(periodDate)};
                IRowSet rs = DbUtil.executeQuery(ctx, sql, param);
                boolean havingSalaryIncome = false;
                isTaxCalFinished = true;
                taxUnitName = "";

                while (rs.next()) {
                    int state = rs.getInt("fState");
                    taxUnitName = rs.getString("taxUnitName");
                    String incomeItemId = rs.getString("fIncomeItemId");
                    if (state != 40) {
                        isTaxCalFinished = false;
                    }

                    if ("8r0AAABCg2PDiOoP".equals(incomeItemId)) {
                        havingSalaryIncome = true;
                    }
                }

                TbTypeEnum typeEnum = declareInfo.getTbType();
                if (!havingSalaryIncome && typeEnum == TbTypeEnum.SB0701) {
                    return "纳税单位[" + taxUnitName + "]当期预扣预缴申报表未包含所得项目为正常工资薪金所得的员工，不允许申报，请确认";
                }
            } while (isTaxCalFinished);

            return "纳税单位【" + taxUnitName + "】存在接口算税未完成的数据，请确认";
        } catch (Exception var15) {
            LOG.error("checkTaxCalStatus error: ", var15);
            throw new SHRWebException(var15.getMessage());
        }
    }

    /**
     * 异常提醒
     *
     * @param advanceDeclareInfo
     * @return
     */
    private String combineError(List<String> advanceDeclareInfo) {
        StringBuilder error = new StringBuilder();
        error.append("以下纳税单位尚未到申报时间，请不要提前申报：");
        Iterator i$ = advanceDeclareInfo.iterator();

        while (i$.hasNext()) {
            String taxUnitInfo = (String) i$.next();
            if (advanceDeclareInfo.indexOf(taxUnitInfo) == 5) {
                error.append("...");
                break;
            }

            if (advanceDeclareInfo.indexOf(taxUnitInfo) > 0) {
                error.append("，");
            }

            String[] arr = taxUnitInfo.split("_");
            error.append(arr[0]).append("【").append(arr[1]).append("】");
        }

        return error.toString();
    }


    /**
     * 获取个税申报审批通过数据
     *
     * @param ctx
     * @param selectedId
     * @return
     * @throws BOSException
     */
    private Map<String, Object> getDeclareData(Context ctx, String selectedId) throws BOSException, JsonProcessingException {
        Map<String, Object> resultMap = new HashMap();
        List<TaxDeclareDTO> declaredList = new ArrayList();
        List<IncomeTaxDeclarInfo> waitToDeclareList = new ArrayList();
        String sqlInString = CmpUtils.spiltToSqlString(selectedId);
        if (StringUtils.isEmpty(sqlInString)) {
            sqlInString = "''";
        }

        String currentYearMonth = CmpDateUtil.getDateStr(new Date(), "yyyy-MM");
        String oqlBuffer = "select id,yearMonth,totalPerson,totalMoney,taxRebate,declareStatus,versionCode,yearMonthDate,tbType,taxUnit.id,taxUnit.name,taxUnit.taxNumber,taxUnit.regNumber,taxUnit.realAccount,taxUnit.areaCode,taxUnit.declPassword,taxUnit.realPassword, batchNo where id in ( " + sqlInString + " )";
        LOG.error("getDeclareData----------oqlBuffer------" + oqlBuffer);
        IncomeTaxDeclarCollection declareCollection = IncomeTaxDeclarFactory.getLocalInstance(ctx).getIncomeTaxDeclarCollection(oqlBuffer);
        LOG.error("getDeclareData----------declareCollection------" + declareCollection.size());
        String ms1 = EASResource.getString("com.kingdee.shr.compensation.resource.CommonResource", "label137", ctx.getLocale());
        String ms2 = EASResource.getString("com.kingdee.shr.compensation.resource.CommonResource", "label138", ctx.getLocale());
        String ms3 = EASResource.getString("com.kingdee.shr.compensation.resource.CommonResource", "label139", ctx.getLocale());
        List<String> taxUnitInfo = new ArrayList();
        if (declareCollection != null && declareCollection.size() > 0) {
            for (int i = 0; i < declareCollection.size(); ++i) {
                IncomeTaxDeclarInfo declareInfo = declareCollection.get(i);
                String declareStatus = declareInfo.getDeclareStatus().getValue();
                LOG.error("getDeclareData----------declareStatus------" + declareStatus);
                String taxUnitName = declareInfo.getTaxUnit().getName();
                String tbTypeAlia = declareInfo.getTbType().getAlias();
                if (currentYearMonth.compareTo(declareInfo.getYearMonth()) <= 0) {
                    taxUnitInfo.add(declareInfo.getTaxUnit().getName() + "_" + declareInfo.getYearMonth());
                }
                if (!"2".equals(declareStatus)) {
                    waitToDeclareList.add(declareInfo);
                    LOG.error("getDeclareData----------waitToDeclareList------" + waitToDeclareList);
                } else {
                    TaxDeclareDTO dto = new TaxDeclareDTO(taxUnitName, tbTypeAlia);
                    declaredList.add(dto);
                }
            }

            if (declaredList.size() == declareCollection.size()) {
                resultMap.put("info", ms1);
            } else if (declaredList.size() == 0) {
                resultMap.put("info", ms2);
            } else {
                resultMap.put("info", ms3);
            }
        }
        LOG.error("getDeclareData----------resultMap------" + resultMap);

        resultMap.put("DECLARED", declaredList);
        resultMap.put("advanceDeclareInfo", taxUnitInfo);
        resultMap.put("WATI_TO_DECLARE", waitToDeclareList);
        return resultMap;
    }
}