diff --git a/src/com/engine/salary/cache/SalaryCacheKey.java b/src/com/engine/salary/cache/SalaryCacheKey.java
index 01f0747a9..549dccd31 100644
--- a/src/com/engine/salary/cache/SalaryCacheKey.java
+++ b/src/com/engine/salary/cache/SalaryCacheKey.java
@@ -9,15 +9,55 @@ package com.engine.salary.cache;
  */
 public class SalaryCacheKey {
 
+    /**
+     * 人员范围同步
+     */
+    public final static String TAX_AGENT_MANAGE_RANGE_SYNC = "TAX_AGENT_MANAGE_RANGE_SYNC";
 
     /**
      * 核算进度
      */
     public final static String ACCT_PROGRESS = "ACCT_PROGRESS_";
 
+    /**
+     * 薪资核算的账套配置
+     */
+    public final static String ACCT_SOB_CONFIG = "ACCT_SOB_CONFIG";
+
     /**
      * 考勤进度
      */
-    public final static String ATTEND_PROGRESS = "ATTEND_PROGRESS_";
+    public final static String ATTEND_PROGRESS = "ATTEND_PROGRESS";
+
+    /**
+     * 工资单发放进度
+     */
+    public final static String SALARY_GRANT_PROGRESS = "SALARY_GRANT_PROGRESS";
+
+    /**
+     * 工资单撤回进度
+     */
+    public final static String SALARY_WITHDRAW_PROGRESS = "SALARY_WITHDRAW_PROGRESS";
+
+    /**
+     * ecology系统的token
+     */
+    public final static String ECOLOGY_TOKEN = "ECOLOGY_TOKEN";
+
+    /**
+     * 个税申报表
+     */
+    public final static String TAX_DECLARATION = "TAX_DECLARATION";
+
+    /**
+     * 人员报送
+     */
+    public final static String EMPLOYEE_DECLARE = "EMPLOYEE_DECLARE";
+
+    /**
+     * 自定义业务数据
+     */
+    public final static String CUSTOM_DATA = "CUSTOM_DATA";
+
 
 }
diff --git a/src/com/engine/salary/entity/salaryacct/bo/CalculateFormulaVarBO.java b/src/com/engine/salary/entity/salaryacct/bo/CalculateFormulaVarBO.java
index b2a9eb0e0..fc5dcc5cd 100644
--- a/src/com/engine/salary/entity/salaryacct/bo/CalculateFormulaVarBO.java
+++ b/src/com/engine/salary/entity/salaryacct/bo/CalculateFormulaVarBO.java
@@ -16,6 +16,7 @@ import com.engine.salary.entity.salaryarchive.dto.SalaryArchiveDataDTO;
 import com.engine.salary.entity.salaryarchive.dto.SalaryArchiveItemDataDTO;
 import com.engine.salary.entity.salaryarchive.dto.SalaryArchiveTaxAgentDataDTO;
 import com.engine.salary.entity.salaryitem.po.SalaryItemPO;
+import com.engine.salary.entity.salarysob.dto.SalarySobCycleDTO;
 import com.engine.salary.entity.salarysob.po.SalarySobAdjustRulePO;
 import com.engine.salary.enums.salaryformula.SalaryFormulaReferenceEnum;
 import com.engine.salary.enums.salaryformula.SalarySQLReferenceEnum;
@@ -136,6 +137,39 @@ public class CalculateFormulaVarBO {
         return resultMap;
     }
 
+    /**
+     * 处理核算日期相关信息
+     */
+    private List<FormulaVarValue> handleSalarySobCycleDTO(SalaryAcctCalculateBO salaryAcctCalculateBO) {
+
+        SalarySobCycleDTO salarySobCycleDTO = salaryAcctCalculateBO.getSalarySobCycleDTO();
+
+        salarySobCycleDTO.setSalaryDate(SalaryDateUtil.toDate(salarySobCycleDTO.getSalaryMonth(), 1));
+        salarySobCycleDTO.setTaxDate(SalaryDateUtil.toDate(salarySobCycleDTO.getTaxCycle(), 1));
+        salarySobCycleDTO.setSocialSecurityDate(SalaryDateUtil.toDate(salarySobCycleDTO.getSocialSecurityCycle(), 1));
+        LocalDateRange salaryCycle = salarySobCycleDTO.getSalaryCycle();
+        salarySobCycleDTO.setSalaryCycleFromDate(salaryCycle.getFromDate());
+        salarySobCycleDTO.setSalaryCycleEndDate(salaryCycle.getEndDate());
+        LocalDateRange attendCycle = salarySobCycleDTO.getAttendCycle();
+        salarySobCycleDTO.setAttendCycleFromDate(attendCycle.getFromDate());
+        salarySobCycleDTO.setAttendCycleEndDate(attendCycle.getEndDate());
+
+        Map<String, String> map = JsonUtil.parseMap(salarySobCycleDTO, String.class);
+
+        List<FormulaVarValue> formulaVarValues = Lists.newArrayList();
+        Field[] declaredFields = SalarySobCycleDTO.class.getDeclaredFields();
+        for (Field declaredField : declaredFields) {
+            if (declaredField.isAnnotationPresent(SalaryFormulaVar.class)) {
+                String fieldName = declaredField.getName();
+                String fieldId = SalarySQLReferenceEnum.SALARY_CYCLE.getValue()
+                        + SalaryFormulaFieldConstant.FIELD_ID_SEPARATOR
+                        + fieldName;
+                formulaVarValues.add(new FormulaVarValue().setFieldId(fieldId).setFieldValue(map.getOrDefault(fieldName, StringUtils.EMPTY)));
+            }
+        }
+        return formulaVarValues;
+    }
+
 
     /**
      * 处理薪资核算结果
@@ -164,7 +198,7 @@ public class CalculateFormulaVarBO {
     }
 
     /**
-     * 处理薪资档案（会涉及调薪计薪规则）
+     * 处理薪资档案（会涉及调薪计薪规则）+处理核算日期
      *
      * @param salaryAcctCalculateBO 薪资核算参数
      * @param resultMap             返回结果集
@@ -179,6 +213,7 @@ public class CalculateFormulaVarBO {
                 List<FormulaVarValue> formulaVarValues = resultMap.computeIfAbsent(key, k -> Lists.newArrayList());
                 // 将薪资档案的值转换成公式中的变量，填充到返回结果集中
                 formulaVarValues.addAll(handleSalaryArchiveItemVal(salaryAcctCalculateBO, salaryArchiveTaxAgentDataDTO.getSalaryItemValues(), salarySobAdjustRulePOMap));
+                formulaVarValues.addAll(handleSalarySobCycleDTO(salaryAcctCalculateBO));
             }
         }
     }
diff --git a/src/com/engine/salary/entity/salaryacct/bo/SalaryAcctEmployeeBO.java b/src/com/engine/salary/entity/salaryacct/bo/SalaryAcctEmployeeBO.java
index 67a99329b..6ce040fed 100644
--- a/src/com/engine/salary/entity/salaryacct/bo/SalaryAcctEmployeeBO.java
+++ b/src/com/engine/salary/entity/salaryacct/bo/SalaryAcctEmployeeBO.java
@@ -119,4 +119,28 @@ public class SalaryAcctEmployeeBO {
         }
         return resultList;
     }
+
+
+    public static List<List<SalaryAcctEmployeePO>> partitionByEmployeeId(List<SalaryAcctEmployeePO> salaryAcctEmployees) {
+        if (CollectionUtils.isEmpty(salaryAcctEmployees)) {
+            return Collections.emptyList();
+        }
+        List<Long> employeeIdList = salaryAcctEmployees.stream()
+                .map(SalaryAcctEmployeePO::getEmployeeId)
+                .distinct()
+                .collect(Collectors.toList());
+        // 每个线程处理多少个人员（一个线程最多处理10个人员）
+        int size = 100;
+        List<List<Long>> partition = Lists.partition(employeeIdList, size);
+        List<List<SalaryAcctEmployeePO>> resultList = new ArrayList<>();
+        Map<Long, List<SalaryAcctEmployeePO>> salaryAcctEmployeeMap = SalaryEntityUtil.group2Map(salaryAcctEmployees, SalaryAcctEmployeePO::getEmployeeId);
+        for (List<Long> employeeIds : partition) {
+            List<SalaryAcctEmployeePO> temp = new ArrayList<>();
+            for (Long employeeId : employeeIds) {
+                temp.addAll(salaryAcctEmployeeMap.getOrDefault(employeeId, Collections.emptyList()));
+            }
+            resultList.add(temp);
+        }
+        return resultList;
+    }
 }
diff --git a/src/com/engine/salary/entity/salaryacct/bo/SalaryCalcContext.java b/src/com/engine/salary/entity/salaryacct/bo/SalaryCalcContext.java
new file mode 100644
index 000000000..c1a88ba6a
--- /dev/null
+++ b/src/com/engine/salary/entity/salaryacct/bo/SalaryCalcContext.java
@@ -0,0 +1,46 @@
+package com.engine.salary.entity.salaryacct.bo;
+
+import com.engine.salary.entity.datacollection.DataCollectionEmployee;
+import com.engine.salary.entity.salaryacct.po.SalaryAcctRecordPO;
+import com.engine.salary.entity.salarysob.dto.SalarySobCycleDTO;
+import com.engine.salary.entity.salarysob.po.SalarySobAdjustRulePO;
+import lombok.Data;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @description: 薪资核算上下文
+ * @author: xiajun
+ * @modified By: xiajun
+ * @date: Created in 8/22/22 3:26 PM
+ * @version:v1.0
+ */
+@Data
+public class SalaryCalcContext {
+
+    /**
+     * 当前核算人员
+     */
+    private DataCollectionEmployee simpleEmployee;
+    /**
+     * 员工状态
+     */
+    private Map<String, String> hrmStatusMap;
+    /**
+     * 薪资核算记录
+     */
+    private SalaryAcctRecordPO salaryAcctRecord;
+    /**
+     * 考勤周期、薪资周期、税款所属期、社保福利台账月份
+     */
+    private SalarySobCycleDTO salarySobCycle;
+    /**
+     * 调薪计薪规则
+     */
+    private List<SalarySobAdjustRulePO> salaryAdjustmentRules;
+    /**
+     * 本次薪资核算所涉及的公式
+     */
+    private SalaryCalcFormulaContext salaryCalcFormulaContext;
+}
diff --git a/src/com/engine/salary/entity/salaryacct/bo/SalaryCalcEmployeeContext.java b/src/com/engine/salary/entity/salaryacct/bo/SalaryCalcEmployeeContext.java
new file mode 100644
index 000000000..fa07e673e
--- /dev/null
+++ b/src/com/engine/salary/entity/salaryacct/bo/SalaryCalcEmployeeContext.java
@@ -0,0 +1,41 @@
+package com.engine.salary.entity.salaryacct.bo;
+
+import com.engine.salary.entity.salaryacct.po.SalaryAcctEmployeePO;
+import com.engine.salary.entity.salaryacct.po.SalaryAcctRecordPO;
+import com.engine.salary.entity.salaryacct.po.SalaryAcctResultPO;
+import lombok.Data;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @description:
+ * @author: xiajun
+ * @modified By: xiajun
+ * @date: Created in 8/23/22 3:45 PM
+ * @version:v1.0
+ */
+@Data
+public class SalaryCalcEmployeeContext {
+
+    /**
+     * key：formulaId、value：公式变量的值
+     */
+    private Map<Long, Map<String, String>> formulaVarValueMap;
+    /**
+     * key：salaryAcctEmployeeId、value：薪资核算结果
+     */
+    private Map<Long, SalaryAcctResultPO> noDecryptAcctResultValueMap;
+    /**
+     * key：salaryAcctRecordId、value：薪资核算记录
+     */
+    private Map<Long, SalaryAcctRecordPO> sameTaxCycleRecordMap;
+    /**
+     * key：employee-taxAgentId、value：薪资核算人员
+     */
+    private Map<String, List<SalaryAcctEmployeePO>> sameTaxCycleEmployeeMap;
+    /**
+     * key：salaryAcctEmployeeId、value：薪资核算结果
+     */
+    private Map<Long, SalaryAcctResultPO> sameTaxCycleResultValueMap;
+}
diff --git a/src/com/engine/salary/entity/salaryacct/bo/SalaryCalcFormula.java b/src/com/engine/salary/entity/salaryacct/bo/SalaryCalcFormula.java
new file mode 100644
index 000000000..937bffdc7
--- /dev/null
+++ b/src/com/engine/salary/entity/salaryacct/bo/SalaryCalcFormula.java
@@ -0,0 +1,53 @@
+package com.engine.salary.entity.salaryacct.bo;
+
+import com.engine.salary.enums.SalaryRoundingModeEnum;
+import com.engine.salary.enums.salaryitem.SalaryDataTypeEnum;
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+/**
+ * @description: 薪资核算计算优先级
+ * @author: xiajun
+ * @modified By: xiajun
+ * @date: Created in 8/23/22 11:52 AM
+ * @version:v1.0
+ */
+@Data
+@Accessors(chain = true)
+public class SalaryCalcFormula {
+
+    /**
+     * 薪资项目id
+     */
+    private Long salaryItemId;
+    /**
+     * 薪资项目的code
+     */
+    private String salaryItemCode;
+    /**
+     * 薪资类型
+     */
+    private String incomeCategory;
+    /**
+     * 薪资档案引用。0：薪资档案未引用、1：薪资档案引用
+     * 为处理历史数据而留，不再使用
+     */
+    @Deprecated
+    private Integer useInEmployeeSalary;
+    /**
+     * 字段类型
+     */
+    private SalaryDataTypeEnum dataType;
+    /**
+     * 舍入规则
+     */
+    private SalaryRoundingModeEnum roundingMode;
+    /**
+     * 小数位数
+     */
+    private Integer pattern;
+    /**
+     * 公式id
+     */
+    private Long formulaId;
+}
diff --git a/src/com/engine/salary/entity/salaryacct/bo/SalaryCalcFormulaContext.java b/src/com/engine/salary/entity/salaryacct/bo/SalaryCalcFormulaContext.java
new file mode 100644
index 000000000..bd8a60387
--- /dev/null
+++ b/src/com/engine/salary/entity/salaryacct/bo/SalaryCalcFormulaContext.java
@@ -0,0 +1,105 @@
+package com.engine.salary.entity.salaryacct.bo;
+
+import com.engine.salary.entity.salaryformula.ExpressFormula;
+import com.engine.salary.entity.salaryitem.po.SalaryItemPO;
+import com.googlecode.aviator.Expression;
+import lombok.Data;
+
+import java.util.*;
+
+/**
+ * @description: 薪资核算公式
+ * @author: xiajun
+ * @modified By: xiajun
+ * @date: Created in 8/22/22 3:33 PM
+ * @version:v1.0
+ */
+@Data
+public class SalaryCalcFormulaContext {
+
+    /**
+     * 薪资核算所包含的薪资项目
+     */
+    private Map<Long, SalaryItemPO> salaryItemMap;
+
+    /**
+     * 本次薪资核算所涉及的公式编译后的对象
+     */
+    private Map<Long, Expression> expressionMap;
+
+    /**
+     * 薪资核算所包含的公式
+     */
+    private Map<Long, ExpressFormula> expressFormulaMap;
+
+    /**
+     * 薪资核算所包含的薪资项目id（按计算顺序排序好了）
+     */
+    private List<List<SalaryCalcFormula>> salaryCalcFormulas;
+
+    /**
+     * 所有公式中是否包含薪资档案
+     */
+    private Set<String> salaryArchiveFieldIds;
+
+    /**
+     * 所有公式中是否包含其他扣除
+     */
+    private Set<String> otherDeductionFieldIds;
+
+    /**
+     * 所有公式中是否包含专项附加扣除
+     */
+    private Set<String> addUpDeductionFieldIds;
+
+    /**
+     * 所有公式中是否包含往期累计情况
+     */
+    private Set<String> addUpSituationFieldIds;
+
+    /**
+     * 所有公式中是否包含考勤
+     */
+    private Set<String> attendFieldIds;
+
+    /**
+     * 所有公式中是否包含社保福利
+     */
+    private Set<String> welfareFieldIds;
+
+    /**
+     * 所有公式中是否包含人员信息
+     */
+    private Set<String> employeeInfoFieldIds;
+
+    /**
+     * 所有公式中是否包含外部人员
+     */
+    private Set<String> extEmployeeFieldIds;
+
+    /**
+     * 所有公式中包含的自定义业务数据表
+     */
+    private Map<Long, Set<String>> customDataFieldIdMap;
+
+    /**
+     * 所有公式中包含的已发
+     */
+    private Set<String> issuedFieldIds;
+
+    public SalaryCalcFormulaContext() {
+        this.salaryItemMap = new HashMap<>();
+        this.expressFormulaMap = new HashMap<>();
+        this.salaryCalcFormulas = new ArrayList<>();
+        this.salaryArchiveFieldIds = new HashSet<>();
+        this.otherDeductionFieldIds = new HashSet<>();
+        this.addUpDeductionFieldIds = new HashSet<>();
+        this.addUpSituationFieldIds = new HashSet<>();
+        this.attendFieldIds = new HashSet<>();
+        this.welfareFieldIds = new HashSet<>();
+        this.employeeInfoFieldIds = new HashSet<>();
+        this.extEmployeeFieldIds = new HashSet<>();
+        this.customDataFieldIdMap = new HashMap<>();
+        this.issuedFieldIds = new HashSet<>();
+    }
+}
diff --git a/src/com/engine/salary/entity/salaryacct/bo/SalaryCalcResult.java b/src/com/engine/salary/entity/salaryacct/bo/SalaryCalcResult.java
new file mode 100644
index 000000000..3b658c769
--- /dev/null
+++ b/src/com/engine/salary/entity/salaryacct/bo/SalaryCalcResult.java
@@ -0,0 +1,34 @@
+package com.engine.salary.entity.salaryacct.bo;
+
+import com.engine.salary.entity.salaryacct.po.SalaryAcctResultPO;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * @description:
+ * @author: xiajun
+ * @modified By: xiajun
+ * @date: 2022/8/22 20:45
+ * @version:v1.0
+ */
+@Data
+@AllArgsConstructor
+public class SalaryCalcResult {
+
+    /**
+     * 子线程是否运算成功
+     */
+    private boolean status;
+
+    /**
+     * 子线程元算失败的错误信息
+     */
+    private String errMsg;
+
+    /**
+     * 计算结果
+     */
+    private List<SalaryAcctResultPO> salaryAcctResultValues;
+}
diff --git a/src/com/engine/salary/entity/salaryacct/dto/SalaryAcctRateDTO.java b/src/com/engine/salary/entity/salaryacct/dto/SalaryAcctRateDTO.java
new file mode 100644
index 000000000..8044bed9e
--- /dev/null
+++ b/src/com/engine/salary/entity/salaryacct/dto/SalaryAcctRateDTO.java
@@ -0,0 +1,41 @@
+package com.engine.salary.entity.salaryacct.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+import java.math.BigDecimal;
+
+@Data
+@Accessors(chain = true)
+@AllArgsConstructor
+public class SalaryAcctRateDTO {
+
+    //"缓存索引")
+    private String index;
+    //"提示信息")
+    private String msg;
+    //"状态")
+    private boolean status;
+    //"是否已经完成")
+    private boolean finish;
+    //"总数")
+    private Integer totalQty;
+    //"已经计算的数量")
+    private Integer calcQty;
+    //"进度")
+    private BigDecimal rate;
+    //"校验异常")
+    private boolean checkStatus;
+
+    public SalaryAcctRateDTO(String index) {
+        this.index = index;
+        this.msg = "";
+        this.status = true;
+        this.finish = false;
+        this.totalQty = 1;
+        this.calcQty = 0;
+        this.rate = BigDecimal.ZERO;
+        this.checkStatus = true;
+    }
+}
diff --git a/src/com/engine/salary/entity/salaryarchive/bo/SalaryArchiveExcelBO.java b/src/com/engine/salary/entity/salaryarchive/bo/SalaryArchiveExcelBO.java
index 41bba094d..389f66a64 100644
--- a/src/com/engine/salary/entity/salaryarchive/bo/SalaryArchiveExcelBO.java
+++ b/src/com/engine/salary/entity/salaryarchive/bo/SalaryArchiveExcelBO.java
@@ -372,6 +372,7 @@ public class SalaryArchiveExcelBO extends Service {
         //员工id  流程定薪使用
         String empId = Optional.ofNullable(map.get("员工id")).orElse("").toString();
         if (StringUtils.isNotBlank(empId)) {
+            employeeSameIds.clear();
             employeeSameIds.add(Long.valueOf(empId));
             employeeId = Long.valueOf(empId);
         }
diff --git a/src/com/engine/salary/entity/salarysob/dto/SalarySobCycleDTO.java b/src/com/engine/salary/entity/salarysob/dto/SalarySobCycleDTO.java
index 65a482e20..70a688b10 100644
--- a/src/com/engine/salary/entity/salarysob/dto/SalarySobCycleDTO.java
+++ b/src/com/engine/salary/entity/salarysob/dto/SalarySobCycleDTO.java
@@ -1,5 +1,6 @@
 package com.engine.salary.entity.salarysob.dto;
 
+import com.engine.salary.annotation.SalaryFormulaVar;
 import com.engine.salary.common.LocalDateRange;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
@@ -9,6 +10,7 @@ import lombok.Data;
 import lombok.NoArgsConstructor;
 
 import java.time.YearMonth;
+import java.util.Date;
 
 /**
  * 薪资账套的周期
@@ -24,24 +26,43 @@ import java.time.YearMonth;
 @AllArgsConstructor
 public class SalarySobCycleDTO {
 
-   //薪资账套id
+    //薪资账套id
     private Long salarySobId;
 
-   //薪资所属月
+    //薪资所属月
     @JsonSerialize(using = ToStringSerializer.class)
     private YearMonth salaryMonth;
 
-   //税款所属期
+    //税款所属期
     @JsonSerialize(using = ToStringSerializer.class)
     private YearMonth taxCycle;
 
-   //社保福利所属期
+    //社保福利所属期
     @JsonSerialize(using = ToStringSerializer.class)
     private YearMonth socialSecurityCycle;
 
-   //薪资周期")
+    //薪资周期")
     private LocalDateRange salaryCycle;
 
-   //考勤周期")
+    //考勤周期")
     private LocalDateRange attendCycle;
+
+
+    /**
+     * 公式变量
+     */
+    @SalaryFormulaVar(defaultLabel = "薪资所属月", labelId = 86321, dataType = "string")
+    private Date salaryDate;
+    @SalaryFormulaVar(defaultLabel = "税款所属期", labelId = 86321, dataType = "string")
+    private Date taxDate;
+    @SalaryFormulaVar(defaultLabel = "社保福利所属期", labelId = 86321, dataType = "string")
+    private Date socialSecurityDate;
+    @SalaryFormulaVar(defaultLabel = "薪资周期起始日期", labelId = 86321, dataType = "string")
+    private Date salaryCycleFromDate;
+    @SalaryFormulaVar(defaultLabel = "薪资周期结束日期", labelId = 86321, dataType = "string")
+    private Date salaryCycleEndDate;
+    @SalaryFormulaVar(defaultLabel = "考勤周期起始日期", labelId = 86321, dataType = "string")
+    private Date attendCycleFromDate;
+    @SalaryFormulaVar(defaultLabel = "考勤周期结束日期", labelId = 86321, dataType = "string")
+    private Date attendCycleEndDate;
 }
diff --git a/src/com/engine/salary/enums/salaryformula/SalarySQLReferenceEnum.java b/src/com/engine/salary/enums/salaryformula/SalarySQLReferenceEnum.java
index 16ba69a64..f08a583d2 100644
--- a/src/com/engine/salary/enums/salaryformula/SalarySQLReferenceEnum.java
+++ b/src/com/engine/salary/enums/salaryformula/SalarySQLReferenceEnum.java
@@ -16,7 +16,8 @@ import java.util.Objects;
 public enum SalarySQLReferenceEnum implements BaseEnum<String> {
 
     EMPLOYEE_INFO("employeeInfo", "员工基本信息", 85366),
-    SALARY_ACCT_EMPLOYEE("salaryAcctEmployee", "核算基本信息", 85368);
+    SALARY_ACCT_EMPLOYEE("salaryAcctEmployee", "核算基本信息", 85368),
+    SALARY_CYCLE("SalaryCycle", "核算日期", 85368);
     private String value;
 
     private String defaultLabel;
diff --git a/src/com/engine/salary/mapper/InsuranceExportMapper.xml b/src/com/engine/salary/mapper/InsuranceExportMapper.xml
index 02e48fb98..517eb1672 100644
--- a/src/com/engine/salary/mapper/InsuranceExportMapper.xml
+++ b/src/com/engine/salary/mapper/InsuranceExportMapper.xml
@@ -129,6 +129,7 @@
         AND bill_month = #{param.billMonth}
         AND payment_status = #{paymentStatus}
         AND creator = #{param.creator}
+        AND payment_organization = #{param.paymentOrganization}
         ) a
         LEFT JOIN hrmresource e ON e.ID = a.employee_id
         LEFT JOIN hrmdepartment d ON d.id = e.departmentid
@@ -154,6 +155,7 @@
         AND bill_month = #{param.billMonth}
         AND payment_status = #{paymentStatus}
         AND creator = #{param.creator}
+        AND payment_organization = #{param.paymentOrganization}
         ) a
         LEFT JOIN hrmresource e ON e.ID = a.employee_id
         LEFT JOIN hrmdepartment d ON d.id = e.departmentid
@@ -179,6 +181,7 @@
         AND bill_month = #{param.billMonth}
         AND payment_status = #{paymentStatus}
         AND creator = #{param.creator}
+        AND payment_organization = #{param.paymentOrganization}
         ) a
         LEFT JOIN hrmresource e ON e.ID = a.employee_id
         LEFT JOIN hrmdepartment d ON d.id = e.departmentid
diff --git a/src/com/engine/salary/mapper/datacollection/EmployMapper.java b/src/com/engine/salary/mapper/datacollection/EmployMapper.java
index 427ff6cd7..496f00ed0 100644
--- a/src/com/engine/salary/mapper/datacollection/EmployMapper.java
+++ b/src/com/engine/salary/mapper/datacollection/EmployMapper.java
@@ -53,5 +53,8 @@ public interface EmployMapper {
 
     List<SubCompanyInfo> getSubCompanyInfoList(@Param("subDepartmentIds") List<Long> subDepartmentIds);
 
+    List<DataCollectionEmployee> listAll();
+
+
     List<HrmInfoDTO> listHrmInfoByIdAndName(@Param("param") HrmQueryParam param);
 }
\ No newline at end of file
diff --git a/src/com/engine/salary/mapper/datacollection/EmployMapper.xml b/src/com/engine/salary/mapper/datacollection/EmployMapper.xml
index 874f28246..806a1bf2d 100644
--- a/src/com/engine/salary/mapper/datacollection/EmployMapper.xml
+++ b/src/com/engine/salary/mapper/datacollection/EmployMapper.xml
@@ -37,17 +37,23 @@
     <select id="getEmployeeByIdsAll" resultType="com.engine.salary.entity.datacollection.DataCollectionEmployee">
         select e.id as employeeId,
         e.lastname as username,
-        e.status as status,
-        e.workcode as workcode,
-        e.certificatenum as idNo,
         d.departmentname as departmentName,
         d.id as departmentId,
+        sc.SUBCOMPANYNAME as subcompanyName,
         c.jobtitlename as jobtitleName,
         c.id as jobtitleId,
         e.companystartdate as companystartdate,
         e.mobile as mobile,
-        e.enddate as dismissdate,
-        sc.SUBCOMPANYNAME as subcompanyName
+        e.status as status,
+        e.workcode as workcode,
+        e.sex as sex,
+        e.email as email,
+        e.telephone as telephone,
+        e.jobcall as jobcall,
+        e.birthday as birthday,
+        e.certificatenum as idNo,
+        c.id as jobtitleId,
+        e.enddate as dismissdate
         from hrmresource e
         left join hrmdepartment d on e.departmentid = d.id
         left join hrmjobtitles c on e.jobtitle = c.id
@@ -232,6 +238,22 @@
           and (e.accounttype is null or e.accounttype = 0)
     </select>
 
+    <select id="listAll" resultType="com.engine.salary.entity.datacollection.DataCollectionEmployee">
+        select e.id               as employeeId,
+               e.lastname         as username,
+               e.status           as status,
+               e.workcode         as workcode,
+               e.certificatenum   as idNo,
+               e.companystartdate as companystartdate,
+               e.mobile           as mobile,
+               e.subcompanyid1    as subcompanyid,
+               e.departmentid     as departmentId,
+               e.jobtitle         as jobtitleId
+        from hrmresource e
+        where e.status not in (7)
+          and (e.accounttype is null or e.accounttype = 0)
+    </select>
+
 
     <select id="listAllForReport" resultType="com.engine.salary.entity.datacollection.DataCollectionEmployee">
         select e.id               as employeeId,
diff --git a/src/com/engine/salary/service/SalaryAcctCalcService.java b/src/com/engine/salary/service/SalaryAcctCalcService.java
new file mode 100644
index 000000000..842622b3c
--- /dev/null
+++ b/src/com/engine/salary/service/SalaryAcctCalcService.java
@@ -0,0 +1,31 @@
+//package com.engine.salary.service;
+//
+//import com.engine.salary.entity.datacollection.DataCollectionEmployee;
+//
+//import java.util.Collection;
+//
+///**
+// * @description: 薪资核算
+// * @author: xiajun
+// * @modified By: xiajun
+// * @date: Created in 8/22/22 3:15 PM
+// * @version:v1.0
+// */
+//public interface SalaryAcctCalcService {
+//
+//    /**
+//     * 按薪资核算记录id进行核算
+//     *
+//     * @param salaryAcctRecordId
+//     * @param simpleEmployee
+//     */
+//    void calcByRecordId(Long salaryAcctRecordId, DataCollectionEmployee simpleEmployee) throws Exception;
+//
+//    /**
+//     * 按薪资核算人员id进行核算
+//     *
+//     * @param salaryAcctEmployeeIds
+//     * @param simpleEmployee
+//     */
+//    void calcByEmployeeIds(Long salaryAcctRecordId, Collection<Long> salaryAcctEmployeeIds, DataCollectionEmployee simpleEmployee) throws Exception;
+//}
diff --git a/src/com/engine/salary/service/SalaryAcctEmployeeService.java b/src/com/engine/salary/service/SalaryAcctEmployeeService.java
index 325cb7b1f..44f9f38f7 100644
--- a/src/com/engine/salary/service/SalaryAcctEmployeeService.java
+++ b/src/com/engine/salary/service/SalaryAcctEmployeeService.java
@@ -1,6 +1,5 @@
 package com.engine.salary.service;
 
-import com.engine.salary.entity.datacollection.DataCollectionEmployee;
 import com.engine.salary.entity.salaryacct.dto.SalaryAcctEmployeeCountDTO;
 import com.engine.salary.entity.salaryacct.param.*;
 import com.engine.salary.entity.salaryacct.po.SalaryAcctEmployeePO;
diff --git a/src/com/engine/salary/service/SalaryCacheService.java b/src/com/engine/salary/service/SalaryCacheService.java
new file mode 100644
index 000000000..2c01c1466
--- /dev/null
+++ b/src/com/engine/salary/service/SalaryCacheService.java
@@ -0,0 +1,69 @@
+package com.engine.salary.service;
+
+public interface SalaryCacheService {
+
+    /**
+     * 添加缓存
+     *
+     * @param key
+     * @param value
+     * @param <T>
+     * @return
+     */
+    <T> void set(String key, T value);
+
+    /**
+     * 添加缓存，有过期时间
+     *
+     * @param key
+     * @param value
+     * @param time
+     * @return
+     */
+    <T> void set(String key, T value, int time);
+
+    /**
+     * 将对象转为json字符串缓存
+     * @param key
+     * @param value
+     * @param <T>
+     */
+    <T> void setJson(String key, T value);
+
+    /**
+     * 将对象转为json字符串缓存，有过期时间
+     * @param key
+     * @param value
+     * @param time
+     * @param <T>
+     */
+    <T> void setJson(String key, T value, int time);
+
+
+    /**
+     * 获取缓存
+     * @param key
+     * @param <T>
+     * @return
+     */
+    <T> T get(String key);
+
+
+    /**
+     * 获取缓存对象
+     * @param key
+     * @param clazz
+     * @param <T>
+     * @return
+     */
+    <T> T getJson(String key, Class<T> clazz);
+
+    /**
+     * 清除缓存
+     *
+     * @param key
+     */
+    void remove(String key);
+
+
+}
diff --git a/src/com/engine/salary/service/SalaryEmployeeService.java b/src/com/engine/salary/service/SalaryEmployeeService.java
index 1acc05e9b..a31b12692 100644
--- a/src/com/engine/salary/service/SalaryEmployeeService.java
+++ b/src/com/engine/salary/service/SalaryEmployeeService.java
@@ -72,5 +72,5 @@ public interface SalaryEmployeeService {
      * @param workcode 工号
      * @param uid 人员id
      */
-    List<DataCollectionEmployee> matchImportEmployee(List<DataCollectionEmployee> employeeList, String userName, String deparmentName, String mobile, String workcode,Long uid);
+    List<DataCollectionEmployee> matchImportEmployee(List<DataCollectionEmployee> employeeList, String userName, String deparmentName, String mobile, String workcode, Long uid);
 }
diff --git a/src/com/engine/salary/service/SalaryFormulaService.java b/src/com/engine/salary/service/SalaryFormulaService.java
index 591e83caa..5bc9223f0 100644
--- a/src/com/engine/salary/service/SalaryFormulaService.java
+++ b/src/com/engine/salary/service/SalaryFormulaService.java
@@ -36,4 +36,10 @@ public interface SalaryFormulaService {
     FormulaPO save(SalaryFormulaSaveParam salaryFormulaSaveParam);
 
     FormulaPO update(SalaryFormulaSaveParam salaryFormulaSaveParam);
+
+
+    /**
+     * 初始化函数
+     */
+    void initFunction();
 }
diff --git a/src/com/engine/salary/service/TaxAgentManageRangeService.java b/src/com/engine/salary/service/TaxAgentManageRangeService.java
index f3bd3ad21..eaa6c8fe1 100644
--- a/src/com/engine/salary/service/TaxAgentManageRangeService.java
+++ b/src/com/engine/salary/service/TaxAgentManageRangeService.java
@@ -1,12 +1,10 @@
 package com.engine.salary.service;
 
-import com.engine.salary.entity.taxagent.dto.TaxAgentManageRangeEmployeeDTO;
 import com.engine.salary.entity.taxagent.dto.TaxAgentManageRangeListDTO;
 import com.engine.salary.entity.taxagent.param.TaxAgentRangeQueryParam;
 import com.engine.salary.entity.taxagent.param.TaxAgentRangeSaveParam;
 import com.engine.salary.entity.taxagent.param.TaxAgentSubAdminRangeQueryParam;
 import com.engine.salary.entity.taxagent.po.TaxAgentManageRangePO;
-import com.engine.salary.enums.salarysob.SalaryEmployeeStatusEnum;
 import com.engine.salary.util.page.PageInfo;
 
 import java.util.Collection;
@@ -22,40 +20,6 @@ import java.util.List;
  **/
 public interface TaxAgentManageRangeService  {
 
-    /**
-     * 根据个税扣缴义务人ID和当前账户查询人员
-     *
-     * @param taxAgentIds
-     * @return
-     */
-    List<TaxAgentManageRangeEmployeeDTO> listSalaryEmployeeByTaxAgentIds(List<Long> taxAgentIds);
-
-    /**
-     * 根据人员状态、个税扣缴义务人ID和当前账户查询人员
-     *
-     * @param employeeStatus
-     * @param taxAgentIds
-     * @return
-     */
-    List<TaxAgentManageRangeEmployeeDTO> listSalaryEmployeeByTaxAgentIds(SalaryEmployeeStatusEnum employeeStatus, List<Long> taxAgentIds);
-
-    /**
-     * 根据分管理员ID和当前账户查询人员
-     *
-     * @param taxAgentSubAdminIds
-     * @return
-     */
-    List<TaxAgentManageRangeEmployeeDTO> listSalaryEmployeeBySubAdminIds(List<Long> taxAgentSubAdminIds);
-
-    /**
-     * 根据人员状态、分管理员ID和当前账户查询人员
-     *
-     * @param employeeStatus
-     * @param taxAgentSubAdminIds
-     * @return
-     */
-    List<TaxAgentManageRangeEmployeeDTO> listSalaryEmployeeBySubAdminIds(SalaryEmployeeStatusEnum employeeStatus, List<Long> taxAgentSubAdminIds);
-
     /**
      * 根据查询条件查询分管理员的人员范围
      *
@@ -89,12 +53,6 @@ public interface TaxAgentManageRangeService  {
      */
     void save(TaxAgentRangeSaveParam saveParam);
 
-    /**
-     * 保存分管理员的管理范围
-     *
-     * @param saveParam
-     */
-//    void save4SubAdmin(TaxAgentSubAdminRangeSaveParam saveParam);
 
     /**
      * 根据主键id删除管理范围
@@ -110,10 +68,5 @@ public interface TaxAgentManageRangeService  {
      */
     void deleteByTaxAgentIds(Collection<Long> taxAgentIds);
 
-    /**
-     * 根据分管理员的id删除管理范围
-     *
-     * @param subAdminIds 分管理员列表
-     */
-    void deleteBySubAdmins(Collection<Long> subAdminIds);
+    void syncManageRange(List<Long> taxAgentIds,String index);
 }
diff --git a/src/com/engine/salary/service/impl/RemoteExcelServiceImpl.java b/src/com/engine/salary/service/impl/RemoteExcelServiceImpl.java
index 2a45271fe..c069b30b9 100644
--- a/src/com/engine/salary/service/impl/RemoteExcelServiceImpl.java
+++ b/src/com/engine/salary/service/impl/RemoteExcelServiceImpl.java
@@ -14,6 +14,7 @@ import com.engine.salary.entity.salaryacct.po.SalaryAcctEmployeePO;
 import com.engine.salary.entity.salaryformula.dto.SalaryFormulaTaxRateDTO;
 import com.engine.salary.entity.salaryformula.po.FormulaVar;
 import com.engine.salary.entity.salaryitem.po.SalaryItemPO;
+import com.engine.salary.entity.salarysob.dto.SalarySobCycleDTO;
 import com.engine.salary.entity.salarysob.po.SalarySobItemPO;
 import com.engine.salary.entity.taxrate.TaxRateBase;
 import com.engine.salary.enums.salaryformula.ReferenceTypeEnum;
@@ -111,6 +112,9 @@ public class RemoteExcelServiceImpl extends Service implements RemoteExcelServic
                         case SALARY_ACCT_EMPLOYEE:
                             vars = convert2FormulaVar(SalaryAcctEmployeePO.class, referenceEnum.getValue() + "");
                             break;
+                        case SALARY_CYCLE:
+                            vars = convert2FormulaVar(SalarySobCycleDTO.class, referenceEnum.getValue() + "");
+                            break;
                         default:
                             break;
                     }
@@ -124,9 +128,11 @@ public class RemoteExcelServiceImpl extends Service implements RemoteExcelServic
         if (referenceEnum != null) {
             switch (referenceEnum) {
                 case SALARY_ITEM:
-                case SALARY_ARCHIVES:
                     vars = salaryItem2FormulaVar(referenceEnum, extendParam);
                     break;
+                case SALARY_ARCHIVES:
+                    vars = salaryArchives2FormulaVar(referenceEnum, extendParam);
+                    break;
                 case ADD_UP_SITUATION:
                     vars = convert2FormulaVar(AddUpSituation.class, referenceEnum.getValue() + "");
                     break;
@@ -279,6 +285,7 @@ public class RemoteExcelServiceImpl extends Service implements RemoteExcelServic
             salaryItems = getSalaryItemService(user).listByIds(salaryItemIds);
         }
         return salaryItems.stream()
+                .filter(e -> e.getUseInEmployeeSalary() == 0)
                 .map(e -> {
                     FormulaVar formulaVar = new FormulaVar();
                     formulaVar.setFieldId(referenceEnum.getValue() + SalaryFormulaFieldConstant.FIELD_ID_SEPARATOR + e.getCode());
@@ -290,6 +297,32 @@ public class RemoteExcelServiceImpl extends Service implements RemoteExcelServic
 
     }
 
+
+    private List<FormulaVar> salaryArchives2FormulaVar(SalaryFormulaReferenceEnum referenceEnum, Map<String, Object> extendParam) {
+        Set<Long> salaryItemIds = Collections.emptySet();
+        Object salarySobId = extendParam == null ? null : extendParam.get("salarySobId");
+        if (Objects.nonNull(salarySobId)) {
+            List<SalarySobItemPO> salarySobItems = getSalarySobItemService(user).listBySalarySobId(Long.valueOf(String.valueOf(salarySobId)));
+            salaryItemIds = SalaryEntityUtil.properties(salarySobItems, SalarySobItemPO::getSalaryItemId);
+        }
+        List<SalaryItemPO> salaryItems;
+        if (CollectionUtils.isEmpty(salaryItemIds)) {
+            salaryItems = getSalaryItemService(user).listAll();
+        } else {
+            salaryItems = getSalaryItemService(user).listByIds(salaryItemIds);
+        }
+        return salaryItems.stream()
+                .filter(e -> e.getUseInEmployeeSalary() == 1)
+                .map(e -> {
+                    FormulaVar formulaVar = new FormulaVar();
+                    formulaVar.setFieldId(referenceEnum.getValue() + SalaryFormulaFieldConstant.FIELD_ID_SEPARATOR + e.getCode());
+                    formulaVar.setName(e.getName());
+                    formulaVar.setSource("" + referenceEnum.getValue());
+                    formulaVar.setFieldType(e.getDataType());
+                    return formulaVar;
+                }).collect(Collectors.toList());
+    }
+
     private <T> List<FormulaVar> convert2FormulaVar(Class<T> clazz, String formId) {
         Field[] declaredFields = clazz.getDeclaredFields();
         List<FormulaVar> formulaVars = Lists.newArrayListWithExpectedSize(declaredFields.length);
diff --git a/src/com/engine/salary/service/impl/SIAccountServiceImpl.java b/src/com/engine/salary/service/impl/SIAccountServiceImpl.java
index 9019e07e5..b59e86774 100644
--- a/src/com/engine/salary/service/impl/SIAccountServiceImpl.java
+++ b/src/com/engine/salary/service/impl/SIAccountServiceImpl.java
@@ -2257,8 +2257,43 @@ public class SIAccountServiceImpl extends Service implements SIAccountService {
         getPaymentGroup(otherComJson, "公司", "其他福利", dataMap, addGroups);
 
         Map<String, Object> resultMap = new HashMap<>();
-        resultMap.put("data", dataMap);
-        resultMap.put("items", addGroups);
+//        resultMap.put("data", dataMap);
+//        resultMap.put("items", addGroups);
+
+        List<Map<String, String>> perList = new ArrayList<>();
+        List<Map<String, String>> comList = new ArrayList<>();
+        for (SearchConditionGroup group : addGroups) {
+
+            if (group.getItems() != null && group.getItems().size() > 0) {
+                for (SearchConditionItem item : group.getItems()) {
+                    Map<String, String> map = new HashMap<>();
+
+                    String[] domkey = item.getDomkey();
+                    String insuranceId = domkey[0].substring(3);
+                    if (group.getTitle().contains("个人")) {
+                        map.put("title", group.getTitle());
+                        map.put("paymentScope", "个人");
+                        map.put("insuranceName", item.getLabel());
+                        map.put("insuranceId", insuranceId);
+                        map.put("insuranceValue", dataMap.get(domkey[0]));
+                        perList.add(map);
+                    } else if (group.getTitle().contains("公司")) {
+                        map.put("title", group.getTitle());
+                        map.put("paymentScope", "公司");
+                        map.put("insuranceName", item.getLabel());
+                        map.put("insuranceId", insuranceId);
+                        map.put("insuranceValue", dataMap.get(domkey[0]));
+                        comList.add(map);
+                    }
+                }
+            }
+
+        }
+
+        List<Map<String, String>> resultList = new ArrayList<>();
+        resultList.addAll(perList);
+        resultList.addAll(comList);
+        resultMap.put("data", resultList);
 
         return resultMap;
     }
@@ -2308,6 +2343,9 @@ public class SIAccountServiceImpl extends Service implements SIAccountService {
 
         InsuranceAccountDetailPOEncrypt.encryptItem(insuranceAccountDetailPO);
         getInsuranceAccountDetailMapper().updateById(insuranceAccountDetailPO);
+
+        //刷新_bill_batch表中的统计信息
+        refreshBillBatch(insuranceAccountDetailPO.getPaymentOrganization(), insuranceAccountDetailPO.getBillMonth());
     }
 
     public void accountFundByData(InsuranceAccountDetailPO insuranceAccountDetailPO, EditAccountDetailParam baseParam) {
diff --git a/src/com/engine/salary/service/impl/SIRecessionServiceImpl.java b/src/com/engine/salary/service/impl/SIRecessionServiceImpl.java
index 2c06d7016..fae20634b 100644
--- a/src/com/engine/salary/service/impl/SIRecessionServiceImpl.java
+++ b/src/com/engine/salary/service/impl/SIRecessionServiceImpl.java
@@ -9,6 +9,7 @@ import com.engine.salary.entity.hrm.dto.HrmInfoDTO;
 import com.engine.salary.entity.hrm.param.HrmQueryParam;
 import com.engine.salary.entity.siaccount.param.InsuranceAccountDetailParam;
 import com.engine.salary.entity.siaccount.param.RecessionParam;
+import com.engine.salary.entity.siaccount.po.InsuranceAccountBatchPO;
 import com.engine.salary.entity.siaccount.po.InsuranceAccountDetailPO;
 import com.engine.salary.entity.taxagent.dto.TaxAgentEmployeeDTO;
 import com.engine.salary.enums.siaccount.BillStatusEnum;
@@ -16,6 +17,7 @@ import com.engine.salary.enums.siaccount.PaymentStatusEnum;
 import com.engine.salary.enums.siaccount.ProjectTypeEnum;
 import com.engine.salary.enums.sicategory.DeleteTypeEnum;
 import com.engine.salary.mapper.datacollection.EmployMapper;
+import com.engine.salary.mapper.siaccount.InsuranceAccountBatchMapper;
 import com.engine.salary.mapper.siaccount.InsuranceAccountDetailMapper;
 import com.engine.salary.service.SIAccountService;
 import com.engine.salary.service.SIRecessionService;
@@ -58,7 +60,9 @@ public class SIRecessionServiceImpl extends Service implements SIRecessionServic
     private SIAccountService getSIAccountService(User user) {
         return ServiceUtil.getService(SIAccountServiceImpl.class, user);
     }
-
+    private InsuranceAccountBatchMapper getInsuranceAccountBatchMapper() {
+        return MapperProxyFactory.getProxy(InsuranceAccountBatchMapper.class);
+    }
     @Override
     public void save(RecessionParam param, Long employeeId) {
 
@@ -75,12 +79,19 @@ public class SIRecessionServiceImpl extends Service implements SIRecessionServic
         SalaryAssert.notEmpty(employeeIds, SalaryI18nUtil.getI18nLabel(133967, "无退差人员"));
 
         //查询退差员工对应的退差月份的正常缴纳的福利台账数据
-        List<InsuranceAccountDetailPO> detailPOS= getInsuranceAccountDetailMapper().list(InsuranceAccountDetailParam.builder()
-                .paymentStatus(PaymentStatusEnum.COMMON.getValue())
-                .recessionMonthList(param.getRecessionMonthList())
-                .employeeIds(employeeIds)
-//                .paymentOrganization(param.getPaymentOrganization())
-                .build());
+        List<InsuranceAccountDetailPO> detailPOS = new ArrayList<>();
+        List<List<Long>> partitionEmpIds = Lists.partition((List<Long>) employeeIds, 100);
+        partitionEmpIds.forEach(p -> {
+            detailPOS.addAll(
+                    getInsuranceAccountDetailMapper().list(InsuranceAccountDetailParam.builder()
+                    .paymentStatus(PaymentStatusEnum.COMMON.getValue())
+                    .recessionMonthList(param.getRecessionMonthList())
+                    .employeeIds(p)
+                    .paymentOrganization(param.getPaymentOrganization())
+                    .build())
+            );
+        });
+
         InsuranceAccountDetailPOEncrypt.decryptInsuranceAccountDetailPOList(detailPOS);
         //处理数据
         List<InsuranceAccountDetailPO> finalDetailPOS = detailPOS;
@@ -117,10 +128,16 @@ public class SIRecessionServiceImpl extends Service implements SIRecessionServic
         if (CollectionUtils.isEmpty(ids)) {
             throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(84026, "参数错误"));
         }
+
+        InsuranceAccountDetailPO refreshTargetPO = getInsuranceAccountDetailMapper().getById(((List<Long>) ids).get(0));
+
+
         //根据id删除
         List<List<Long>> partition = Lists.partition((List<Long>) ids, 100);
         partition.forEach(getInsuranceAccountDetailMapper()::batchDelAccountDetailsByIds);
 
+        //刷新bill_batch表中统计信息
+        getSIAccountService(user).refreshBillBatch(refreshTargetPO.getPaymentOrganization(), refreshTargetPO.getBillMonth());
     }
 
 
@@ -150,11 +167,13 @@ public class SIRecessionServiceImpl extends Service implements SIRecessionServic
 
 
     private void recessionBaseBuild(RecessionParam param, InsuranceAccountDetailPO temp, InsuranceAccountDetailPO insuranceAccountDetailPO) {
+        InsuranceAccountBatchPO insuranceAccountBatchPO = getInsuranceAccountBatchMapper().getByBillMonth(param.getBillMonth(), Long.valueOf(param.getPaymentOrganization()));
         temp.setPaymentStatus(PaymentStatusEnum.RECESSION.getValue());
 //        temp.setId(IdGenerator.generate());
         temp.setCreateTime(new Date());
         temp.setUpdateTime(new Date());
-        temp.setCreator(insuranceAccountDetailPO.getCreator());
+        temp.setCreator(insuranceAccountBatchPO.getCreator());
+        temp.setSocialPayOrg(insuranceAccountDetailPO.getPaymentOrganization());
         temp.setDeleteType(DeleteTypeEnum.NOT_DELETED.getValue());
         temp.setTenantKey(insuranceAccountDetailPO.getTenantKey());
         temp.setEmployeeId(insuranceAccountDetailPO.getEmployeeId());
diff --git a/src/com/engine/salary/service/impl/SalaryAcctCalcServiceImpl.java b/src/com/engine/salary/service/impl/SalaryAcctCalcServiceImpl.java
new file mode 100644
index 000000000..c48450772
--- /dev/null
+++ b/src/com/engine/salary/service/impl/SalaryAcctCalcServiceImpl.java
@@ -0,0 +1,648 @@
+//package com.engine.salary.service.impl;
+//
+//import com.engine.salary.cache.SalaryCacheKey;
+//import com.engine.salary.constant.SalaryDefaultTenantConstant;
+//import com.engine.salary.entity.datacollection.DataCollectionEmployee;
+//import com.engine.salary.entity.salaryacct.bo.*;
+//import com.engine.salary.entity.salaryacct.dto.SalaryAcctRateDTO;
+//import com.engine.salary.entity.salaryacct.po.SalaryAcctEmployeePO;
+//import com.engine.salary.entity.salaryacct.po.SalaryAcctRecordPO;
+//import com.engine.salary.entity.salaryacct.po.SalaryAcctResultPO;
+//import com.engine.salary.entity.salaryformula.ExpressFormula;
+//import com.engine.salary.entity.salaryitem.po.SalaryItemPO;
+//import com.engine.salary.service.*;
+//import com.engine.salary.util.SalaryEntityUtil;
+//import com.google.common.collect.Lists;
+//import com.google.common.collect.Maps;
+//import com.googlecode.aviator.Expression;
+//import com.weaver.common.distribution.genid.IdGenerator;
+//import com.weaver.common.elog.dto.LoggerContext;
+//import com.weaver.common.elog.util.Util;
+//import com.weaver.common.hrm.domain.employee.HrmStatus;
+//import com.weaver.datasecurity.interceptor.DSTenantKeyThreadVar;
+//import com.weaver.excel.formula.api.entity.FormulaVar;
+//import com.weaver.excel.formula.entity.parameter.standard.ExcelResult;
+//import com.weaver.framework.util.JsonUtil;
+//import com.weaver.hrm.salary.common.LocalDateRange;
+//import com.weaver.hrm.salary.constant.SalaryFormulaFieldConstant;
+//import com.weaver.hrm.salary.entity.customdata.param.CustomDataEmployeeQueryParam;
+//import com.weaver.hrm.salary.entity.customdata.po.CustomDataEmployeePO;
+//import com.weaver.hrm.salary.entity.customdata.po.CustomDataRecordPO;
+//import com.weaver.hrm.salary.entity.datacollection.dto.AttendQuoteDataDTO;
+//import com.weaver.hrm.salary.entity.datacollection.po.AddUpDeductionPO;
+//import com.weaver.hrm.salary.entity.datacollection.po.AddUpSituationPO;
+//import com.weaver.hrm.salary.entity.datacollection.po.OtherDeductionPO;
+//import com.weaver.hrm.salary.entity.extemployee.po.ExtEmployeePO;
+//import com.weaver.hrm.salary.entity.salaryacct.bo.*;
+//import com.weaver.hrm.salary.entity.salaryacct.po.*;
+//import com.weaver.hrm.salary.entity.salaryarchive.dto.SalaryArchiveDataDTO;
+//import com.weaver.hrm.salary.entity.salarysob.dto.SalarySobCycleDTO;
+//import com.weaver.hrm.salary.entity.salarysob.po.SalarySobAdjustRulePO;
+//import com.weaver.hrm.salary.entity.salarysob.po.SalarySobBackItemPO;
+//import com.weaver.hrm.salary.entity.salarysob.po.SalarySobItemPO;
+//import com.weaver.hrm.salary.entity.salarysob.po.SalarySobPO;
+//import com.weaver.hrm.salary.enums.OperateTypeEnum;
+//import com.weaver.hrm.salary.enums.salaryaccounting.EmployeeTypeEnum;
+//import com.weaver.hrm.salary.enums.salaryaccounting.SalaryAcctRecordStatusEnum;
+//import com.weaver.hrm.salary.enums.salaryitem.SalaryDataTypeEnum;
+//import com.weaver.hrm.salary.enums.salaryitem.SalaryFormulaReferenceEnum;
+//import com.weaver.hrm.salary.enums.salaryitem.SalaryRoundingModeEnum;
+//import com.weaver.hrm.salary.enums.salarysob.IncomeCategoryEnum;
+//import com.weaver.hrm.salary.enums.sicategory.DeleteTypeEnum;
+//import com.weaver.hrm.salary.exception.SalaryRunTimeException;
+//import com.weaver.hrm.salary.service.*;
+//import com.weaver.hrm.salary.util.SalaryI18nUtil;
+//import com.weaver.util.threadPool.ThreadPoolUtil;
+//import com.weaver.util.threadPool.constant.ModulePoolEnum;
+//import com.weaver.util.threadPool.entity.LocalRunnable;
+//import lombok.extern.slf4j.Slf4j;
+//import org.apache.commons.collections4.CollectionUtils;
+//import org.apache.commons.collections4.MapUtils;
+//import org.apache.commons.lang3.StringUtils;
+//import org.apache.commons.lang3.math.NumberUtils;
+//import org.springframework.transaction.annotation.Transactional;
+//
+//import java.math.BigDecimal;
+//import java.math.RoundingMode;
+//import java.time.LocalDateTime;
+//import java.time.Month;
+//import java.util.*;
+//import java.util.concurrent.BlockingDeque;
+//import java.util.concurrent.CountDownLatch;
+//import java.util.concurrent.LinkedBlockingDeque;
+//import java.util.stream.Collectors;
+//
+///**
+// * 薪资核算
+// *
+// * <p>Copyright: Copyright (c) 2022</p>
+// * <p>Company: 泛微软件</p>
+// *
+// * @author qiantao
+// * @version 1.0
+// **/
+//@Slf4j
+//public class SalaryAcctCalcServiceImpl implements SalaryAcctCalcService {
+//
+//
+//    private SalaryAcctRecordService salaryAcctRecordService;
+//
+//    private SalarySobItemService salarySobItemService;
+//
+////    private SalarySobBackItemService salarySobBackItemService;
+//
+//    private SalarySobAdjustRuleService salarySobAdjustRuleService;
+//
+//    private SalaryFormulaService salaryFormulaService;
+//
+//    private SalaryItemService salaryItemService;
+//
+//    private SalaryAcctEmployeeService salaryAcctEmployeeService;
+//
+//    private SalaryArchiveService salaryArchiveService;
+//
+//    private AddUpSituationService addUpSituationService;
+//
+//    private AddUpDeductionService addUpDeductionService;
+//
+//    private OtherDeductionService otherDeductionService;
+//
+//    private AttendQuoteDataService attendQuoteDataService;
+//
+//    private SIAccountService siAccountService;
+//
+//    private SalaryCacheService salaryCacheService;
+//
+////    private CustomDataRecordService customDataRecordService;
+//
+////    private CustomDataEmployeeService customDataEmployeeService;
+//
+////    private HrmCommonEmployeeService hrmCommonEmployeeService;
+//
+////    private ExtEmployeeService extEmployeeService;
+//
+////    private SalaryAcctResultValueService salaryAcctResultValueService;
+//
+//
+//    private SalarySobService salarySobService;
+//
+////    private SalaryAcctSobConfigService salaryAcctSobConfigService;
+//
+//
+//    @Override
+//    public void calcByRecordId(Long salaryAcctRecordId, DataCollectionEmployee simpleEmployee) throws Exception {
+//        calcByEmployeeIds(salaryAcctRecordId, Collections.emptyList(), simpleEmployee);
+//    }
+//
+//    @Override
+//    @Transactional(rollbackFor = Exception.class)
+//    public void calcByEmployeeIds(Long salaryAcctRecordId, Collection<Long> salaryAcctEmployeeIds, DataCollectionEmployee simpleEmployee) throws Exception {
+//        SalaryAcctRateDTO salaryAcctRate = new SalaryAcctRateDTO("" + salaryAcctRecordId);
+//        try {
+//            String tenantKey = SalaryDefaultTenantConstant.DEFAULT_TENANT_KEY;
+//            // 查询本次核算的薪资核算人员
+//            List<SalaryAcctEmployeePO> salaryAcctEmployees;
+//            if (CollectionUtils.isEmpty(salaryAcctEmployeeIds)) {
+//                salaryAcctEmployees = salaryAcctEmployeeService.listBySalaryAcctRecordId(salaryAcctRecordId);
+//            } else {
+//                salaryAcctEmployees = salaryAcctEmployeeService.listByIds(salaryAcctEmployeeIds);
+//            }
+//            // 初始化核算进度(总数+1是因为所有人员核算完成后，数据保存入库还需要一定的时间)
+//            salaryAcctRate.setTotalQty(salaryAcctEmployees.size() + 1);
+//            salaryCacheService.set(SalaryCacheKey.ACCT_PROGRESS + salaryAcctRate.getIndex(), salaryAcctRate);
+//            // 查询薪资核算记录
+//            SalaryAcctRecordPO salaryAcctRecord = salaryAcctRecordService.getById(salaryAcctRecordId);
+//            // 检查是否能够核算
+//            checkBeforeCalc(salaryAcctRecord, salaryAcctEmployees);
+//            // 加载函数
+////            salaryFormulaService.initFunction();
+//            // 构建核算上下文
+//            SalaryCalcContext salaryCalcContext = loadContext(salaryAcctRecord, simpleEmployee);
+//            // 分批核算
+//            List<List<SalaryAcctEmployeePO>> salaryAcctEmployeePartition = SalaryAcctEmployeeBO.partitionByEmployeeId(salaryAcctEmployees);
+//            // 监控子线程的任务执行
+//            CountDownLatch childMonitor = new CountDownLatch(salaryAcctEmployeePartition.size());
+//            // 记录子线程的执行结果
+//            BlockingDeque<SalaryCalcResult> blockingDeque = new LinkedBlockingDeque<>(salaryAcctEmployeePartition.size());
+//            for (List<SalaryAcctEmployeePO> partSalaryAcctEmployees : salaryAcctEmployeePartition) {
+//                LocalRunnable localRunnable = new LocalRunnable() {
+//                    @Override
+//                    public void execute() {
+//                        calc(salaryCalcContext, partSalaryAcctEmployees, childMonitor, blockingDeque, simpleEmployee);
+//                    }
+//                };
+//                ThreadPoolUtil.fixedPoolExecute(ModulePoolEnum.OTHER, "salaryAcctCalculate", localRunnable);
+//            }
+//            // 等待核算结束
+//            childMonitor.await();
+//            // 处理核算结果
+//            handleCalcResult(blockingDeque, salaryAcctRecordId, salaryAcctEmployeeIds, tenantKey);
+//            // 记录日志
+//            writeLog(salaryAcctRecordId, tenantKey);
+//            // 核算结束，更新进度
+//            salaryAcctRate.setFinish(true).setCalcQty(salaryAcctEmployees.size()).setRate(BigDecimal.ONE);
+//        } finally {
+//            // 更新进度
+//            salaryCacheService.set(SalaryCacheKey.ACCT_PROGRESS + salaryAcctRate.getIndex(), salaryAcctRate);
+//        }
+//    }
+//
+//    private void calc(SalaryCalcContext salaryCalcContext,
+//                      List<SalaryAcctEmployeePO> salaryAcctEmployees,
+//                      CountDownLatch childMonitor,
+//                      BlockingDeque<SalaryCalcResult> blockingDeque,
+//                      DataCollectionEmployee simpleEmployee) {
+//        try {
+//            // 数据库字段加密用
+//            LocalDateTime now = LocalDateTime.now();
+//            // 加载公式计算时所需要的变量
+//            SalaryCalcEmployeeContext salaryCalcEmployeeContext = loadEmployeeContext(salaryCalcContext, salaryAcctEmployees, simpleEmployee.getTenantKey());
+//            // 对薪资核算人员进行分组，如果是合并计算(工资薪金、劳务一起计算)的话，会存在工资薪金和劳务费用的项目存在相互引用，所以相关联的人员要在同一组进行核算
+//            Map<Long, List<SalaryAcctEmployeePO>> salaryAcctEmployeeMap = SalaryEntityUtil.group2Map(salaryAcctEmployees, SalaryAcctEmployeePO::getId);
+////            if (salaryCalcContext.getSalarySobCycle().getIncomeCategories().size() > 1) {
+////                salaryAcctEmployeeMap = SalaryEntityUtil.group2Map(salaryAcctEmployees, SalaryAcctEmployeePO::getEmployeeId);
+////            }
+//            // 计算公式
+//            int calcQty = 0;
+//            List<SalaryAcctResultPO> newSalaryAcctResultValues = Lists.newArrayListWithExpectedSize(salaryAcctEmployees.size());
+//            for (Map.Entry<Long, List<SalaryAcctEmployeePO>> entry : salaryAcctEmployeeMap.entrySet()) {
+//                // 获取锁定的薪资项目
+//                Set<Long> lockSalaryItemIds = new HashSet<>(Collections.emptySet());
+//                for (SalaryAcctEmployeePO salaryAcctEmployee : entry.getValue()) {
+//                    SalaryAcctResultPO noDecryptSalaryAcctResultValue = salaryCalcEmployeeContext.getNoDecryptAcctResultValueMap().get(salaryAcctEmployee.getId());
+////                    if (noDecryptSalaryAcctResultValue != null) {
+////                        lockSalaryItemIds.addAll(noDecryptSalaryAcctResultValue.getLockSalaryItemIds());
+////                    }
+//                }
+//                Map<String, Map<String, String>> incomeCategoryResultValueMap = Maps.newHashMap();
+//                Map<String, SalaryAcctEmployeePO> incomeCategoryAcctEmployeeMap = SalaryEntityUtil.convert2Map(entry.getValue(), SalaryAcctEmployeePO::getIncomeCategory);
+//                // 根据解析好的公式计算优先级计算公式
+//                for (List<SalaryCalcFormula> formulaPriority : salaryCalcContext.getSalaryCalcFormulaContext().getSalaryCalcFormulas()) {
+//                    for (SalaryCalcFormula salaryCalcFormula : formulaPriority) {
+//                        SalaryAcctEmployeePO salaryAcctEmployee;
+//                        if (Objects.equals(salaryCalcFormula.getIncomeCategory(), "0")) {
+//                            salaryAcctEmployee = SalaryEntityUtil.findFirst(entry.getValue());
+//                        } else {
+//                            salaryAcctEmployee = incomeCategoryAcctEmployeeMap.get(salaryCalcFormula.getIncomeCategory());
+//                        }
+//                        if (salaryAcctEmployee == null) {
+//                            continue;
+//                        }
+//                        // 找出需要计算的公式
+//                        SalaryItemPO salaryItem = salaryCalcContext.getSalaryCalcFormulaContext().getSalaryItemMap().get(salaryCalcFormula.getSalaryItemId());
+//                        ExpressFormula expressFormula = salaryCalcContext.getSalaryCalcFormulaContext().getExpressFormulaMap().get(salaryCalcFormula.getFormulaId());
+//                        Expression expression = salaryCalcContext.getSalaryCalcFormulaContext().getExpressionMap().get(salaryCalcFormula.getFormulaId());
+//                        // 获取变量的值
+//                        Map<String, String> formulaVarValueMap = salaryCalcEmployeeContext.getFormulaVarValueMap().computeIfAbsent(salaryAcctEmployee.getId(), k -> new HashMap<>());
+//                        // 运行公式获取结果
+//                        String resultValue = calcResultValue(salaryCalcFormula, expressFormula, expression, formulaVarValueMap, lockSalaryItemIds, salaryCalcContext.getSimpleEmployee());
+//                        // 处理合并计税
+//                        resultValue = handleConsolidatedTax(salaryCalcContext, salaryCalcEmployeeContext, salaryAcctEmployee, resultValue, salaryItem);
+//                        // 处理小数位数
+//                        resultValue = roundResultValue(resultValue, salaryCalcFormula);
+//                        // 将公式计算结果回填到变量map中
+//                        formulaVarValueMap.put(SalaryFormulaReferenceEnum.SALARY_ITEM.getValue()
+//                                + SalaryFormulaFieldConstant.FIELD_ID_SEPARATOR + salaryItem.getCode(), resultValue);
+//                        // 合并计算时工资薪金和劳务费用的项目存在相互引用，所以需要将公式计算结果回填到另一个相关联的薪资核算人员的变量map中
+//                        for (SalaryAcctEmployeePO relationSalaryAcctEmployee : entry.getValue()) {
+//                            if (!Objects.equals(relationSalaryAcctEmployee.getId(), salaryAcctEmployee.getId())) {
+//                                Map<String, String> relationFormulaVarValueMap = salaryCalcEmployeeContext.getFormulaVarValueMap().computeIfAbsent(relationSalaryAcctEmployee.getId(), k -> new HashMap<>());
+//                                relationFormulaVarValueMap.put(SalaryFormulaReferenceEnum.SALARY_ITEM.getValue()
+//                                        + SalaryFormulaFieldConstant.FIELD_ID_SEPARATOR + salaryItem.getCode(), resultValue);
+//                            }
+//                        }
+//                        // 计算结果
+//                        Map<String, String> resultValueMap = incomeCategoryResultValueMap.computeIfAbsent(salaryCalcFormula.getIncomeCategory(), k -> Maps.newHashMap());
+//                        resultValueMap.put("" + salaryCalcFormula.getSalaryItemId(), resultValue);
+//                    }
+//                }
+//                for (SalaryAcctEmployeePO salaryAcctEmployee : entry.getValue()) {
+//                    Map<String, String> resultValueMap = Maps.newHashMap();
+//                    // 根据薪资核算人员的收入所得项目(工资薪金或者劳务)，获取对应的薪资核算结果
+//                    resultValueMap.putAll(incomeCategoryResultValueMap.getOrDefault(salaryAcctEmployee.getIncomeCategory(), Collections.emptyMap()));
+//                    // 回算薪资项目既不属于工资薪金也不属于劳务，但是也要保存到人员的薪资核算结果中
+//                    resultValueMap.putAll(incomeCategoryResultValueMap.getOrDefault("0", Collections.emptyMap()));
+//                    SalaryAcctResultValuePO noDecryptSalaryAcctResultValue = salaryCalcEmployeeContext.getNoDecryptAcctResultValueMap().get(salaryAcctEmployee.getId());
+//                    SalaryAcctResultValuePO newSalaryAcctResultValue = new SalaryAcctResultValuePO()
+//                            .setId(IdGenerator.generate())
+//                            .setSalaryAcctRecordId(salaryAcctEmployee.getSalaryAcctRecordId())
+//                            .setSalaryAcctEmployeeId(salaryAcctEmployee.getId())
+//                            .setResultValue(resultValueMap)
+//                            .setOriginResultValueJson(noDecryptSalaryAcctResultValue == null
+//                                    ? StringUtils.EMPTY : noDecryptSalaryAcctResultValue.getOriginResultValueJson())
+//                            .setLockSalaryItemIds(lockSalaryItemIds)
+//                            .setDeleteType(DeleteTypeEnum.NOT_DELETED.getValue())
+//                            .setTenantKey(simpleEmployee.getTenantKey())
+//                            .setCreator(simpleEmployee.getEmployeeId())
+//                            .setCreateTime(now)
+//                            .setUpdateTime(now);
+//                    newSalaryAcctResultValues.add(newSalaryAcctResultValue);
+//                    // 更新计算进度
+//                    updateRate(salaryCalcContext.getSalaryAcctRecord().getId(), ++calcQty, salaryAcctEmployees.size());
+//                }
+//            }
+//            blockingDeque.add(new SalaryCalcResult(true, "", newSalaryAcctResultValues));
+//        } catch (Exception e) {
+//            log.info("薪资核算失败：{}", e.getMessage(), e);
+//            blockingDeque.add(new SalaryCalcResult(false, e.getMessage(), Collections.emptyList()));
+//        } finally {
+//            // 子线程执行完毕
+//            childMonitor.countDown();
+//            // 数据库字段加密用
+//            DSTenantKeyThreadVar.tenantKey.remove();
+//        }
+//    }
+//
+//    private void checkBeforeCalc(SalaryAcctRecordPO salaryAcctRecordPO, List<SalaryAcctEmployeePO> salaryAcctEmployees) {
+//        if (Objects.isNull(salaryAcctRecordPO)) {
+//            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(145221, "薪资核算记录不存在或已被删除"));
+//        }
+//        // 归档状态或已申报状态下不能核算
+//        if (!Objects.equals(salaryAcctRecordPO.getStatus(), SalaryAcctRecordStatusEnum.NOT_ARCHIVED.getValue())) {
+//            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(145222, "薪资核算记录已经归档，不能再核算"));
+//        }
+//        // 没有薪资核算人员不能核算
+//        if (CollectionUtils.isEmpty(salaryAcctEmployees)) {
+//            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(0, "当前核算人员为空，请先确认要核算的人员"));
+//        }
+//    }
+//
+//    private SalaryCalcContext loadContext(SalaryAcctRecordPO salaryAcctRecord, DataCollectionEmployee simpleEmployee) {
+//        String tenantKey = simpleEmployee.getTenantKey();
+//        // 查询考勤周期、薪资周期、税款所属期、社保福利台账月份
+//        SalarySobCycleDTO salarySobCycle = salaryAcctRecordService.getSalarySobCycleById(salaryAcctRecord.getId(), tenantKey);
+//        // 查询薪资核算记录的账套配置
+//        SalaryAcctSobConfigPO salaryAcctSobConfig = salaryAcctSobConfigService.getBySalaryAcctRecordId(salaryAcctRecord.getId(), tenantKey);
+//        // 薪资项目
+//        List<SalarySobItemPO> salarySobItems = JsonUtil.parseList(salaryAcctSobConfig.getItemConfig(), SalarySobItemPO.class);
+//        // 回算薪资项目
+//        List<SalarySobBackItemPO> salarySobBackItems = !Objects.equals(salaryAcctRecord.getBackCalcStatus(), 1) ? Collections.emptyList()
+//                : JsonUtil.parseList(salaryAcctSobConfig.getBackItemConfig(), SalarySobBackItemPO.class);
+//        // 查询薪资项目所用的公式id
+//        Set<Long> formulaIds = new HashSet<>();
+//        formulaIds.addAll(SalaryEntityUtil.properties(salarySobItems, SalarySobItemPO::getFormulaId));
+//        formulaIds.addAll(SalaryEntityUtil.properties(salarySobBackItems, SalarySobBackItemPO::getFormulaId));
+//        List<ExpressFormula> expressFormulas = salaryFormulaService.listOriginExpressFormula(formulaIds, tenantKey);
+//        // 查询薪资项目
+//        Set<Long> salaryItemIds = new HashSet<>();
+//        salaryItemIds.addAll(SalaryEntityUtil.properties(salarySobItems, SalarySobItemPO::getSalaryItemId));
+//        salaryItemIds.addAll(SalaryEntityUtil.properties(salarySobBackItems, SalarySobBackItemPO::getSalaryItemId));
+//        List<SalaryItemPO> salaryItems = salaryItemService.listByIds(salaryItemIds, tenantKey);
+//        // 计算薪资项目的计算优先级
+//        SalaryCalcPriority salaryCalcPriority = new SalaryCalcPriority(salaryItems, salarySobItems, salarySobBackItems, expressFormulas);
+//        SalaryCalcFormulaContext salaryCalcFormulaContext = salaryCalcPriority.calc();
+//        // 查询薪资核算所用的调薪计薪规则
+//        List<SalarySobAdjustRulePO> salarySobAdjustRules = salarySobAdjustRuleService.listBySalarySobId(salaryAcctRecord.getSalarySobId(), tenantKey);
+//        // 查询员工状态
+//        List<HrmStatus> hrmStatusList = hrmCommonHrmStatusService.list(tenantKey);
+//        Map<String, String> hrmStatusMap = SalaryEntityUtil.convert2Map(hrmStatusList, hrmStatus -> "" + hrmStatus.getCodeId(), HrmStatus::getName);
+//
+//        // 构建上下文
+//        SalaryCalcContext salaryCalcContext = new SalaryCalcContext();
+//        salaryCalcContext.setSimpleEmployee(simpleEmployee);
+//        salaryCalcContext.setHrmStatusMap(hrmStatusMap);
+//        salaryCalcContext.setSalaryAcctRecord(salaryAcctRecord);
+//        salaryCalcContext.setSalarySobCycle(salarySobCycle);
+//        salaryCalcContext.setSalaryAdjustmentRules(salarySobAdjustRules);
+//        salaryCalcContext.setSalaryCalcFormulaContext(salaryCalcFormulaContext);
+//        return salaryCalcContext;
+//    }
+//
+//    private SalaryCalcEmployeeContext loadEmployeeContext(SalaryCalcContext salaryCalcContext, List<SalaryAcctEmployeePO> salaryAcctEmployees, String tenantKey) {
+//        // 查询合并计税的薪资核算记录
+//        LocalDateRange localDateRange = LocalDateRange.builder()
+//                .fromDate(salaryCalcContext.getSalarySobCycle().getTaxCycle().atDay(1))
+//                .endDate(salaryCalcContext.getSalarySobCycle().getTaxCycle().atEndOfMonth())
+//                .build();
+//        List<SalaryAcctRecordPO> salaryAcctRecords = salaryAcctRecordService.listByTaxCycle(localDateRange, tenantKey);
+//        Map<Long, SalaryAcctRecordPO> salaryAcctRecordMap = SalaryEntityUtil.convert2Map(salaryAcctRecords, SalaryAcctRecordPO::getId);
+//        // 查询合并计税的薪资核算人员
+//        List<SalaryAcctEmployeePO> sameTaxCycleSalaryAcctEmployees = salaryAcctEmployeeService.listSameTaxCycle(salaryAcctEmployees, salaryCalcContext.getSalarySobCycle().getTaxCycle().toString(), tenantKey);
+//        Map<String, List<SalaryAcctEmployeePO>> sameTaxCycleEmployeeMap = SalaryEntityUtil.group2Map(sameTaxCycleSalaryAcctEmployees, o -> o.getEmployeeId() + "-" + o.getTaxAgentId());
+//        Set<Long> sameTaxCycleSalaryAcctEmployeeIds = SalaryEntityUtil.properties(sameTaxCycleSalaryAcctEmployees, SalaryAcctEmployeePO::getId);
+//        List<SalaryAcctResultValuePO> sameTaxCycleResultValues = salaryAcctResultValueService
+//                .listBySalaryAcctEmployeeIds(sameTaxCycleSalaryAcctEmployeeIds, tenantKey);
+//        Map<Long, SalaryAcctResultValuePO> sameTaxCycleResultValueMap = SalaryEntityUtil.convert2Map(sameTaxCycleResultValues, SalaryAcctResultValuePO::getSalaryAcctEmployeeId);
+//
+//        SalaryCalcEmployeeContext salaryCalcEmployeeContext = new SalaryCalcEmployeeContext();
+//        salaryCalcEmployeeContext.setSameTaxCycleRecordMap(salaryAcctRecordMap);
+//        salaryCalcEmployeeContext.setSameTaxCycleEmployeeMap(sameTaxCycleEmployeeMap);
+//        salaryCalcEmployeeContext.setSameTaxCycleResultValueMap(sameTaxCycleResultValueMap);
+//        // 加载公式变量
+//        loadFormulaVar(salaryCalcContext, salaryCalcEmployeeContext, salaryAcctEmployees);
+//        return salaryCalcEmployeeContext;
+//    }
+//
+//    private void loadFormulaVar(SalaryCalcContext salaryCalcContext, SalaryCalcEmployeeContext salaryCalcEmployeeContext, List<SalaryAcctEmployeePO> salaryAcctEmployees) {
+//        String tenantKey = salaryCalcContext.getSimpleEmployee().getTenantKey();
+//        // 薪资核算人员中的组织架构人员
+//        List<Long> employeeIds = SalaryEntityUtil.properties(salaryAcctEmployees, SalaryAcctEmployeePO::getEmployeeId, Collectors.toList());
+//        // 查询薪资档案
+//        List<SalaryArchiveDataDTO> salaryArchiveDataList = Collections.emptyList();
+//        if (CollectionUtils.isNotEmpty(salaryCalcContext.getSalaryCalcFormulaContext().getSalaryArchiveFieldIds())
+//                && CollectionUtils.isNotEmpty(employeeIds)) {
+//            salaryArchiveDataList = salaryArchiveService.getSalaryArchiveData(salaryCalcContext.getSalarySobCycle().getSalaryCycle(), employeeIds, tenantKey);
+//        }
+//        // 查询往期累计情况
+//        List<AddUpSituationPO> addUpSituations = Collections.emptyList();
+//        if (CollectionUtils.isNotEmpty(salaryCalcContext.getSalaryCalcFormulaContext().getAddUpSituationFieldIds())
+//                && salaryCalcContext.getSalarySobCycle().getTaxCycle().getMonth() != Month.JANUARY
+//                && CollectionUtils.isNotEmpty(employeeIds)) {
+//            addUpSituations = addUpSituationService.getAddUpSituationList(salaryCalcContext.getSalarySobCycle().getTaxCycle().plusMonths(-1), employeeIds, tenantKey);
+//        }
+//        // 查询累计专项附加扣除
+//        List<AddUpDeductionPO> addUpDeductions = Collections.emptyList();
+//        if (CollectionUtils.isNotEmpty(salaryCalcContext.getSalaryCalcFormulaContext().getAddUpDeductionFieldIds())
+//                && CollectionUtils.isNotEmpty(employeeIds)) {
+//            addUpDeductions = addUpDeductionService.getAddUpDeductionList(salaryCalcContext.getSalarySobCycle().getTaxCycle(), employeeIds, tenantKey);
+//        }
+//        // 查询其他扣除
+//        List<OtherDeductionPO> otherDeductions = Collections.emptyList();
+//        if (CollectionUtils.isNotEmpty(salaryCalcContext.getSalaryCalcFormulaContext().getOtherDeductionFieldIds())
+//                && CollectionUtils.isNotEmpty(employeeIds)) {
+//            otherDeductions = otherDeductionService.getOtherDeductionList(salaryCalcContext.getSalarySobCycle().getTaxCycle(), employeeIds, tenantKey);
+//        }
+//        // 查询考勤
+//        List<AttendQuoteDataDTO> attendQuoteDataList = Collections.emptyList();
+//        if (CollectionUtils.isNotEmpty(salaryCalcContext.getSalaryCalcFormulaContext().getAttendFieldIds())
+//                && CollectionUtils.isNotEmpty(employeeIds)) {
+//            SalarySobPO salarySob = salarySobService.getById(salaryCalcContext.getSalaryAcctRecord().getSalarySobId(), tenantKey);
+//            attendQuoteDataList = attendQuoteDataService.getAttendQuoteData(salaryCalcContext.getSalarySobCycle().getSalaryMonth(), salarySob.getOriginSalarySobId(), employeeIds, tenantKey);
+//        }
+//        // 查询社保福利
+//        List<Map<String, Object>> welfareMapList = Collections.emptyList();
+//        if (CollectionUtils.isNotEmpty(salaryCalcContext.getSalaryCalcFormulaContext().getWelfareFieldIds())
+//                && CollectionUtils.isNotEmpty(employeeIds)) {
+//            welfareMapList = siAccountService.welfareData(salaryCalcContext.getSalarySobCycle().getSocialSecurityCycle().toString(), employeeIds, tenantKey);
+//        }
+//        // 查询自定义业务数据
+//        List<CustomDataEmployeePO> customDataEmployees = Collections.emptyList();
+//        if (MapUtils.isNotEmpty(salaryCalcContext.getSalaryCalcFormulaContext().getCustomDataFieldIdMap())
+//                && CollectionUtils.isNotEmpty(employeeIds)) {
+//            Set<Long> customFieldIds = salaryCalcContext.getSalaryCalcFormulaContext().getCustomDataFieldIdMap().values().stream()
+//                    .flatMap(Collection::stream)
+//                    .map(fieldId -> Util.getLongValue(fieldId, 0L))
+//                    .collect(Collectors.toSet());
+//            List<CustomDataRecordPO> customDataRecords = customDataRecordService.listByCustomFormIdsAndSalaryMonth(
+//                    salaryCalcContext.getSalaryCalcFormulaContext().getCustomDataFieldIdMap().keySet(),
+//                    salaryCalcContext.getSalarySobCycle().getSalaryMonth(),
+//                    salaryCalcContext.getSimpleEmployee().getEmployeeId(), tenantKey);
+//            CustomDataEmployeeQueryParam param = new CustomDataEmployeeQueryParam()
+//                    .setCustomDataRecordIds(SalaryEntityUtil.properties(customDataRecords, CustomDataRecordPO::getId))
+//                    .setEmployeeIds(employeeIds)
+//                    .setCustomFieldIds(customFieldIds);
+//            customDataEmployees = customDataEmployeeService.listByParam(param, tenantKey);
+//        }
+//        // 查询人员信息
+//        List<DataCollectionEmployee> simpleEmployees = Collections.emptyList();
+//        if (CollectionUtils.isNotEmpty(salaryCalcContext.getSalaryCalcFormulaContext().getEmployeeInfoFieldIds())
+//                && CollectionUtils.isNotEmpty(employeeIds)) {
+//            simpleEmployees = hrmCommonEmployeeService.getEmployeeByIds(employeeIds, tenantKey);
+//        }
+//        // 查询外部人员
+//        List<Long> extEmployeeIds = salaryAcctEmployees.stream()
+//                .filter(salaryAcctEmployee -> Objects.equals(salaryAcctEmployee.getEmployeeType(), EmployeeTypeEnum.EXT_EMPLOYEE.getValue()))
+//                .map(SalaryAcctEmployeePO::getEmployeeId)
+//                .distinct()
+//                .collect(Collectors.toList());
+//        List<ExtEmployeePO> extEmployees = Collections.emptyList();
+//        if (CollectionUtils.isNotEmpty(salaryCalcContext.getSalaryCalcFormulaContext().getExtEmployeeFieldIds())
+//                && CollectionUtils.isNotEmpty(extEmployeeIds)) {
+//            extEmployees = extEmployeeService.listByIdsWithDeleted(extEmployeeIds, tenantKey);
+//        }
+//        // 查询薪资核算结果(不解密)
+//        Set<Long> salaryAcctEmployeeIds = SalaryEntityUtil.properties(salaryAcctEmployees, SalaryAcctEmployeePO::getId);
+//        List<SalaryAcctResultValuePO> noDecryptSalaryAcctResultValues = salaryAcctResultValueService.listNoDecryptBySalaryAcctEmployeeIds(salaryAcctEmployeeIds, tenantKey);
+//        Map<Long, SalaryAcctResultValuePO> noDecryptSalaryAcctResultValueMap = SalaryEntityUtil.convert2Map(noDecryptSalaryAcctResultValues, SalaryAcctResultValuePO::getSalaryAcctEmployeeId);
+//        salaryCalcEmployeeContext.setNoDecryptAcctResultValueMap(noDecryptSalaryAcctResultValueMap);
+//        // 查询薪资核算结果(解密)
+//        List<SalaryAcctResultValuePO> salaryAcctResultValues = salaryAcctResultValueService.listBySalaryAcctEmployeeIds(salaryAcctEmployeeIds, tenantKey);
+//
+//        SalaryCalcFormulaVar salaryCalcFormulaVar = new SalaryCalcFormulaVar(salaryArchiveDataList, addUpSituations,
+//                addUpDeductions, otherDeductions, attendQuoteDataList, welfareMapList, customDataEmployees, simpleEmployees, extEmployees, salaryAcctResultValues);
+//        Map<Long, List<SalaryCalcFormulaVarValue>> resultMap = salaryCalcFormulaVar.handleSalaryCalcFormulaVar(salaryCalcContext, salaryAcctEmployees);
+//        Map<Long, Map<String, String>> formulaVarValueMap = Maps.newHashMapWithExpectedSize(resultMap.size());
+//        resultMap.forEach((k, v) -> {
+//            Map<String, String> map = SalaryEntityUtil.convert2Map(v, SalaryCalcFormulaVarValue::getFieldId, SalaryCalcFormulaVarValue::getFieldValue);
+//            formulaVarValueMap.put(k, map);
+//        });
+//        salaryCalcEmployeeContext.setFormulaVarValueMap(formulaVarValueMap);
+//    }
+//
+//    private String calcResultValue(SalaryCalcFormula salaryCalcFormula,
+//                                   ExpressFormula expressFormula,
+//                                   Expression expression,
+//                                   Map<String, String> formulaVarValueMap,
+//                                   Set<Long> lockSalaryItemIds,
+//                                   DataCollectionEmployee simpleEmployee) {
+//        String originValue = formulaVarValueMap.getOrDefault(SalaryFormulaReferenceEnum.SALARY_ITEM.getValue()
+//                + SalaryFormulaFieldConstant.FIELD_ID_SEPARATOR + salaryCalcFormula.getSalaryItemCode(), "");
+//        if (Objects.isNull(expressFormula) || lockSalaryItemIds.contains(salaryCalcFormula.getSalaryItemId())) {
+//            if (Objects.equals(salaryCalcFormula.getUseInEmployeeSalary(), NumberUtils.INTEGER_ONE) && !lockSalaryItemIds.contains(salaryCalcFormula.getSalaryItemId())) {
+//                return formulaVarValueMap.getOrDefault(SalaryFormulaReferenceEnum.SALARY_ARCHIVES.getValue()
+//                        + SalaryFormulaFieldConstant.FIELD_ID_SEPARATOR + salaryCalcFormula.getSalaryItemId(), "");
+//            }
+//            return originValue;
+//        }
+//        // 如果只包含了优化的函数，走本模块的计算，否则走公式模块提供的公共方法计算
+//        if (expression != null) {
+//            try {
+//                // 填充变量的值
+//                Map<String, Object> envMap = ExpressFormulaBO.fillExpressionEnvMap(expressFormula, formulaVarValueMap);
+//                // 运行公式
+//                return Util.null2String(expression.execute(envMap));
+//            } catch (Exception e) {
+//                log.info("公式计算错误：{}", expressFormula.getFormula(), e);
+//                return StringUtils.EMPTY;
+//            }
+//        }
+//        // 填充变量的值
+//        List<FormulaVar> formulaVars = ExpressFormulaBO.fillFormulaVarContent(expressFormula, formulaVarValueMap);
+//        // 运行公式
+//        ExcelResult excelResult = excelRunService.run(expressFormula, formulaVars, simpleEmployee);
+//        if (excelResult.isStatus()) {
+//            return excelResult.getStringData();
+//        } else {
+//            log.info("公式计算错误：{}, 错误原因：{}", expressFormula.getFormula(), excelResult.getErrorMsg());
+//            return StringUtils.EMPTY;
+//        }
+//    }
+//
+//    private String handleConsolidatedTax(SalaryCalcContext salaryCalcContext,
+//                                         SalaryCalcEmployeeContext salaryCalcEmployeeContext,
+//                                         SalaryAcctEmployeePO salaryAcctEmployee,
+//                                         String resultValue,
+//                                         SalaryItemPO salaryItem) {
+//        // 只有正常工资薪金所得才需要合并计税处理
+//        if (!Objects.equals(salaryAcctEmployee.getIncomeCategory(), "" + IncomeCategoryEnum.WAGES_AND_SALARIES.getValue())) {
+//            return resultValue;
+//        }
+//        List<SalaryAcctEmployeePO> sameTaxCycleSalaryAcctEmployees = salaryCalcEmployeeContext.getSameTaxCycleEmployeeMap()
+//                .get(salaryAcctEmployee.getEmployeeId() + "-" + salaryAcctEmployee.getTaxAgentId());
+//        if (CollectionUtils.isEmpty(sameTaxCycleSalaryAcctEmployees)) {
+//            return resultValue;
+//        }
+//        // 第一次计算时不需要合并计税处理
+//        boolean needConsolidatedTax = needConsolidatedTax(salaryCalcEmployeeContext, salaryAcctEmployee, sameTaxCycleSalaryAcctEmployees);
+//        if (!needConsolidatedTax) {
+//            return resultValue;
+//        }
+//        List<SalaryAcctResultValuePO> salaryAcctResultValues = Lists.newArrayList();
+//        for (SalaryAcctEmployeePO sameTaxCycleSalaryAcctEmployee : sameTaxCycleSalaryAcctEmployees) {
+//            SalaryAcctResultValuePO salaryAcctResultValue = salaryCalcEmployeeContext.getSameTaxCycleResultValueMap().get(sameTaxCycleSalaryAcctEmployee.getId());
+//            if (salaryAcctResultValue != null) {
+//                salaryAcctResultValues.add(salaryAcctResultValue);
+//            }
+//        }
+//        List<SalaryItemPO> salaryItems = Lists.newArrayList(salaryCalcContext.getSalaryCalcFormulaContext().getSalaryItemMap().values());
+//        return SalaryAcctConsolidatedTax.handleConsolidatedTaxValue(resultValue, salaryItem, salaryItems, salaryAcctResultValues);
+//    }
+//
+//    /**
+//     * 判断是否需要进行合并计税
+//     *
+//     * @param salaryCalcEmployeeContext
+//     * @param salaryAcctEmployee
+//     * @param sameTaxCycleSalaryAcctEmployees
+//     * @return
+//     */
+//    private boolean needConsolidatedTax(SalaryCalcEmployeeContext salaryCalcEmployeeContext,
+//                                        SalaryAcctEmployeePO salaryAcctEmployee,
+//                                        List<SalaryAcctEmployeePO> sameTaxCycleSalaryAcctEmployees) {
+//        SalaryAcctRecordPO salaryAcctRecord = salaryCalcEmployeeContext.getSameTaxCycleRecordMap().get(salaryAcctEmployee.getSalaryAcctRecordId());
+//        if (salaryAcctRecord == null) {
+//            return false;
+//        }
+//        for (SalaryAcctEmployeePO sameTaxCycleSalaryAcctEmployee : sameTaxCycleSalaryAcctEmployees) {
+//            SalaryAcctRecordPO otherSalaryAcctRecord = salaryCalcEmployeeContext.getSameTaxCycleRecordMap()
+//                    .get(sameTaxCycleSalaryAcctEmployee.getSalaryAcctRecordId());
+//            if (otherSalaryAcctRecord == null) {
+//                continue;
+//            }
+//            if (otherSalaryAcctRecord.getCreateTime().compareTo(salaryAcctRecord.getCreateTime()) < 0) {
+//                return true;
+//            }
+//        }
+//        return false;
+//    }
+//
+//    private String roundResultValue(String resultValue, SalaryCalcFormula salaryCalcFormula) {
+//        // 值为空，不需要四舍五入
+//        if (StringUtils.isEmpty(resultValue)) {
+//            return StringUtils.EMPTY;
+//        }
+//        // 薪资项目字段类型为string，无需四舍五入
+//        SalaryDataTypeEnum dataTypeEnum = salaryCalcFormula.getDataType();
+//        if (dataTypeEnum == SalaryDataTypeEnum.STRING) {
+//            return resultValue;
+//        }
+//        BigDecimal bigDecimalValue = SalaryEntityUtil.empty2Zero(resultValue);
+//        RoundingMode roundingMode = RoundingMode.HALF_UP;
+//        if (salaryCalcFormula.getRoundingMode() == SalaryRoundingModeEnum.ROUND_UP) {
+//            roundingMode = RoundingMode.UP;
+//        }
+//        if (salaryCalcFormula.getRoundingMode() == SalaryRoundingModeEnum.ROUND_DOWN) {
+//            roundingMode = RoundingMode.DOWN;
+//        }
+//        return bigDecimalValue.setScale(salaryCalcFormula.getPattern(), roundingMode).toPlainString();
+//    }
+//
+//    /**
+//     * 更新核算进度
+//     *
+//     * @param salaryAcctRecordId
+//     * @param calcQty
+//     */
+//    private synchronized void updateRate(Long salaryAcctRecordId, int calcQty, int salaryAcctEmployeeSize) {
+//        int addQty = 0;
+//        if (calcQty % 10 == 0) {
+//            addQty = 10;
+//        } else if (Objects.equals(calcQty, salaryAcctEmployeeSize)) {
+//            addQty = calcQty % 10;
+//        }
+//        if (addQty > 0) {
+//            SalaryAcctRateDTO salaryAcctRate = salaryCacheService
+//                    .get(SalaryCacheKey.ACCT_PROGRESS, "" + salaryAcctRecordId, SalaryAcctRateDTO.class);
+//            salaryAcctRate.setCalcQty(salaryAcctRate.getCalcQty() + addQty);
+//            salaryCacheService.set(SalaryCacheKey.ACCT_PROGRESS, "" + salaryAcctRecordId, salaryAcctRate);
+//        }
+//    }
+//
+//    private void handleCalcResult(BlockingDeque<SalaryCalcResult> blockingDeque,
+//                                  Long salaryAcctRecordId, Collection<Long> salaryAcctEmployeeIds,
+//                                  String tenantKey) {
+//        boolean allSuccess = blockingDeque.stream().allMatch(SalaryCalcResult::isStatus);
+//        if (!allSuccess) {
+//            // 薪资核算实现的线程的错误信息
+//            String errorMsg = blockingDeque.stream()
+//                    .filter(result -> !result.isStatus())
+//                    .map(SalaryCalcResult::getErrMsg)
+//                    .collect(Collectors.joining("|"));
+//            // 返回错误信息
+//            throw new SalaryRunTimeException("薪资核算失败：" + errorMsg);
+//        }
+//        // 删除历史数据
+//        if (CollectionUtils.isNotEmpty(salaryAcctEmployeeIds)) {
+//            salaryAcctResultValueService.deleteBySalaryAcctEmployeeIds(salaryAcctEmployeeIds, tenantKey);
+//        } else {
+//            salaryAcctResultValueService.deleteBySalaryAcctRecordIds(Collections.singleton(salaryAcctRecordId), tenantKey);
+//        }
+//        // 保存新数据
+//        List<SalaryAcctResultValuePO> salaryAcctResultValues = Lists.newArrayList();
+//        for (SalaryCalcResult salaryCalcResult : blockingDeque) {
+//            salaryAcctResultValues.addAll(salaryCalcResult.getSalaryAcctResultValues());
+//        }
+//        salaryAcctResultValueService.batchSave(salaryAcctResultValues, tenantKey);
+//    }
+//
+//    private void writeLog(Long salaryAcctRecordId, String tenantKey) {
+//        String targetName = salaryAcctRecordService.getLogTargetNameById(salaryAcctRecordId, tenantKey);
+//        LoggerContext<SalaryCheckResultPO> loggerContext = new LoggerContext<>();
+//        loggerContext.setTargetId(String.valueOf(salaryAcctRecordId));
+//        loggerContext.setTargetName(targetName);
+//        loggerContext.setOperateType(OperateTypeEnum.UPDATE.getValue());
+//        loggerContext.setOperateTypeName(SalaryI18nUtil.getI18nLabel(95783, "薪资核算"));
+//        loggerContext.setOperatedesc(SalaryI18nUtil.getI18nLabel(95783, "薪资核算"));
+//        salaryAcctRecordLoggerTemplate.write(loggerContext);
+//    }
+//}
diff --git a/src/com/engine/salary/service/impl/SalaryCacheServiceImpl.java b/src/com/engine/salary/service/impl/SalaryCacheServiceImpl.java
new file mode 100644
index 000000000..1242a0b95
--- /dev/null
+++ b/src/com/engine/salary/service/impl/SalaryCacheServiceImpl.java
@@ -0,0 +1,51 @@
+package com.engine.salary.service.impl;
+
+import com.cloudstore.dev.api.util.Util_DataCache;
+import com.engine.core.impl.Service;
+import com.engine.salary.service.SalaryCacheService;
+import com.engine.salary.util.JsonUtil;
+import org.apache.commons.lang3.StringUtils;
+import weaver.general.Util;
+
+public class SalaryCacheServiceImpl extends Service implements SalaryCacheService {
+
+
+    @Override
+    public <T> void set(String key, T value) {
+        Util_DataCache.setObjVal(key, value);
+    }
+
+    @Override
+    public <T> void set(String key, T value, int time) {
+        Util_DataCache.setObjVal(key, value, time);
+    }
+
+    @Override
+    public <T> void setJson(String key, T value) {
+        Util_DataCache.setObjVal(key, JsonUtil.toJsonString(value));
+    }
+
+    @Override
+    public <T> void setJson(String key, T value, int time) {
+        Util_DataCache.setObjVal(key, JsonUtil.toJsonString(value), time);
+    }
+
+    @Override
+    public <T> T get(String key) {
+        return (T) Util_DataCache.getObjVal(key);
+    }
+
+    @Override
+    public <T> T getJson(String key, Class<T> clazz) {
+        String value = Util.null2String(Util_DataCache.getObjVal(key));
+        if (StringUtils.isEmpty(value)) {
+            return null;
+        }
+        return JsonUtil.parseObject(value, clazz);
+    }
+
+    @Override
+    public void remove(String key) {
+        Util_DataCache.clearVal(key);
+    }
+}
diff --git a/src/com/engine/salary/service/impl/SalaryFormulaServiceImpl.java b/src/com/engine/salary/service/impl/SalaryFormulaServiceImpl.java
index cba68be38..65cb918c8 100644
--- a/src/com/engine/salary/service/impl/SalaryFormulaServiceImpl.java
+++ b/src/com/engine/salary/service/impl/SalaryFormulaServiceImpl.java
@@ -292,4 +292,9 @@ public class SalaryFormulaServiceImpl extends Service implements SalaryFormulaSe
         return formulaPO;
     }
 
+    @Override
+    public void initFunction() {
+
+    }
+
 }
diff --git a/src/com/engine/salary/service/impl/TaxAgentManageRangeServiceImpl.java b/src/com/engine/salary/service/impl/TaxAgentManageRangeServiceImpl.java
index 1acdd790d..f7d8ed802 100644
--- a/src/com/engine/salary/service/impl/TaxAgentManageRangeServiceImpl.java
+++ b/src/com/engine/salary/service/impl/TaxAgentManageRangeServiceImpl.java
@@ -1,5 +1,6 @@
 package com.engine.salary.service.impl;
 
+import com.cloudstore.dev.api.util.Util_DataCache;
 import com.engine.common.util.ServiceUtil;
 import com.engine.core.impl.Service;
 import com.engine.salary.biz.EmployBiz;
@@ -9,26 +10,27 @@ import com.engine.salary.entity.hrm.HrmStatus;
 import com.engine.salary.entity.hrm.PositionInfo;
 import com.engine.salary.entity.hrm.SubCompanyInfo;
 import com.engine.salary.entity.taxagent.bo.TaxAgentBO;
-import com.engine.salary.entity.taxagent.dto.TaxAgentManageRangeEmployeeDTO;
 import com.engine.salary.entity.taxagent.dto.TaxAgentManageRangeListDTO;
 import com.engine.salary.entity.taxagent.param.*;
 import com.engine.salary.entity.taxagent.po.TaxAgentManageRangePO;
 import com.engine.salary.entity.taxagent.po.TaxAgentPO;
 import com.engine.salary.enums.UserStatusEnum;
-import com.engine.salary.enums.salarysob.SalaryEmployeeStatusEnum;
 import com.engine.salary.enums.salarysob.TargetTypeEnum;
 import com.engine.salary.enums.taxagent.TaxAgentRangeTypeEnum;
 import com.engine.salary.exception.SalaryRunTimeException;
 import com.engine.salary.mapper.datacollection.EmployMapper;
 import com.engine.salary.mapper.taxagent.TaxAgentManageRangeMapper;
-import com.engine.salary.service.*;
-import com.engine.salary.util.JsonUtil;
+import com.engine.salary.service.TaxAgentEmpService;
+import com.engine.salary.service.TaxAgentManageRangeService;
+import com.engine.salary.service.TaxAgentService;
 import com.engine.salary.util.SalaryEntityUtil;
 import com.engine.salary.util.SalaryI18nUtil;
 import com.engine.salary.util.db.MapperProxyFactory;
 import com.engine.salary.util.page.PageInfo;
 import com.engine.salary.util.page.SalaryPageUtil;
 import com.google.common.collect.Lists;
+import com.weaver.util.threadPool.ThreadPoolUtil;
+import com.weaver.util.threadPool.entity.LocalRunnable;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
@@ -80,17 +82,6 @@ public class TaxAgentManageRangeServiceImpl extends Service implements TaxAgentM
         return getTaxAgentManageRangeMapper().listSome(TaxAgentManageRangePO.builder().rangeType(TaxAgentRangeTypeEnum.TAXAGENT.getValue()).taxAgentIds(taxAgentIds).build());
     }
 
-    @Override
-    public List<TaxAgentManageRangeEmployeeDTO> listSalaryEmployeeByTaxAgentIds(List<Long> taxAgentIds) {
-        return listSalaryEmployeeByTaxAgentIds(null, taxAgentIds);
-    }
-
-    @Override
-    public List<TaxAgentManageRangeEmployeeDTO> listSalaryEmployeeByTaxAgentIds(SalaryEmployeeStatusEnum employeeStatus, List<Long> taxAgentIds) {
-        List<TaxAgentManageRangePO> allTaxAgentManageRanges = this.listByTaxAgentIds(taxAgentIds);
-        return convertTaxAgentEmployee(employeeStatus, taxAgentIds, allTaxAgentManageRanges);
-    }
-
     @Override
     public List<TaxAgentManageRangePO> listBySubAdminIds(Collection<Long> taxAgentSubAdminIds) {
         if (CollectionUtils.isEmpty(taxAgentSubAdminIds)) {
@@ -99,51 +90,15 @@ public class TaxAgentManageRangeServiceImpl extends Service implements TaxAgentM
         return getTaxAgentManageRangeMapper().listSome(TaxAgentManageRangePO.builder().rangeType(TaxAgentRangeTypeEnum.SUBADMIN.getValue()).taxAgentSubAdminIds(taxAgentSubAdminIds).build());
     }
 
-    @Override
-    public List<TaxAgentManageRangeEmployeeDTO> listSalaryEmployeeBySubAdminIds(List<Long> taxAgentIds) {
-        return listSalaryEmployeeBySubAdminIds(null, taxAgentIds);
-    }
-
-    @Override
-    public List<TaxAgentManageRangeEmployeeDTO> listSalaryEmployeeBySubAdminIds(SalaryEmployeeStatusEnum employeeStatus, List<Long> taxAgentSubAdminIds) {
-        List<TaxAgentManageRangePO> allTaxAgentManageRanges = this.listBySubAdminIds(taxAgentSubAdminIds);
-        List<Long> taxAgentIds = allTaxAgentManageRanges.stream().map(TaxAgentManageRangePO::getTaxAgentId).distinct().collect(Collectors.toList());
-
-        return convertTaxAgentEmployee(employeeStatus, taxAgentIds, allTaxAgentManageRanges);
-    }
-
-    private List<TaxAgentManageRangeEmployeeDTO> convertTaxAgentEmployee(SalaryEmployeeStatusEnum employeeStatus, List<Long> taxAgentIds, List<TaxAgentManageRangePO> allTaxAgentManageRanges) {
-        return taxAgentIds.stream().distinct().map(e -> {
-            // 获取范围下的人员
-            List<DataCollectionEmployee> salaryEmployees = getManageRangeSalaryEmployees(employeeStatus, e, allTaxAgentManageRanges);
-            if (CollectionUtils.isEmpty(salaryEmployees)) {
-                return null;
-            }
-            List<TaxAgentManageRangeEmployeeDTO.TaxAgentEmployee> taxAgentEmployees = salaryEmployees.stream().map(m -> {
-                TaxAgentManageRangeEmployeeDTO.TaxAgentEmployee taxAgentEmployee = new TaxAgentManageRangeEmployeeDTO.TaxAgentEmployee();
-                taxAgentEmployee.setEmployeeId(m.getEmployeeId());
-                taxAgentEmployee.setUsername(m.getUsername());
-                return taxAgentEmployee;
-            }).collect(Collectors.toList());
-
-            return TaxAgentManageRangeEmployeeDTO.builder()
-                    .taxAgentId(e)
-                    .taxAgentName("")
-                    .employeeList(taxAgentEmployees)
-                    .build();
-        }).filter(Objects::nonNull).collect(Collectors.toList());
-    }
-
     /**
      * 获取范围下的人员
      *
-     * @param employeeStatus
      * @param taxAgentId
      * @param allTaxAgentManageRanges
+     * @param salaryEmployees
      * @return
      */
-    private List<DataCollectionEmployee> getManageRangeSalaryEmployees(SalaryEmployeeStatusEnum employeeStatus, Long taxAgentId,
-                                                                       List<TaxAgentManageRangePO> allTaxAgentManageRanges) {
+    private List<DataCollectionEmployee> getManageRangeSalaryEmployees(Long taxAgentId, List<TaxAgentManageRangePO> allTaxAgentManageRanges, List<DataCollectionEmployee> salaryEmployees) {
         List<TaxAgentManageRangePO> includeAllTaxAgentManageRanges = allTaxAgentManageRanges.stream().filter(f -> f.getIncludeType().equals(NumberUtils.INTEGER_ONE)).collect(Collectors.toList());
         if (CollectionUtils.isEmpty(includeAllTaxAgentManageRanges)) {
             return Collections.emptyList();
@@ -155,19 +110,8 @@ public class TaxAgentManageRangeServiceImpl extends Service implements TaxAgentM
         if (CollectionUtils.isEmpty(includeTaxAgentManageRanges)) {
             return includeSalaryEmployees;
         }
-        // 如果需要状态过滤
-        List<String> personnelStatuss = Lists.newArrayList();
-        if (employeeStatus != null) {
-            // 查询人员状态
-//            if (employeeStatus.equals(SalaryEmployeeStatusEnum.NORMAL)) {
-//                personnelStatuss = UserStatusEnum.getNormalStatus();
-//            } else if (employeeStatus.equals(SalaryEmployeeStatusEnum.UNAVAILABLE)) {
-//                personnelStatuss = UserStatusEnum.getUnavailableStatus();
-//            }
-            personnelStatuss.add(employeeStatus.getValue().toString());
-        }
         // 根据上一步的查询参数查询人员
-        includeSalaryEmployees = listSalaryEmployeeByManageRange(includeTaxAgentManageRanges, personnelStatuss);
+        includeSalaryEmployees = listSalaryEmployeeByManageRange(includeTaxAgentManageRanges, salaryEmployees);
         if (CollectionUtils.isEmpty(includeSalaryEmployees)) {
             return includeSalaryEmployees;
         }
@@ -175,7 +119,7 @@ public class TaxAgentManageRangeServiceImpl extends Service implements TaxAgentM
         List<TaxAgentManageRangePO> excludeTaxAgentManageRanges = excludeAllTaxAgentManageRanges.stream().filter(f -> f.getTaxAgentId().equals(taxAgentId)).collect(Collectors.toList());
         if (CollectionUtils.isNotEmpty(excludeTaxAgentManageRanges)) {
             // 根据上一步的查询参数查询人员
-            List<DataCollectionEmployee> excludeSalaryEmployees = listSalaryEmployeeByManageRange(excludeTaxAgentManageRanges, personnelStatuss);
+            List<DataCollectionEmployee> excludeSalaryEmployees = listSalaryEmployeeByManageRange(excludeTaxAgentManageRanges, salaryEmployees);
             // 需要排除的人员范围
             Set<Long> excludeEmployeeIds = SalaryEntityUtil.properties(excludeSalaryEmployees, DataCollectionEmployee::getEmployeeId);
             // 过滤人员
@@ -192,22 +136,15 @@ public class TaxAgentManageRangeServiceImpl extends Service implements TaxAgentM
      * @param taxAgentManageRanges
      * @return
      */
-    private List<DataCollectionEmployee> listSalaryEmployeeByManageRange(List<TaxAgentManageRangePO> taxAgentManageRanges, List<String> personnelStatuss) {
-        if (CollectionUtils.isEmpty(taxAgentManageRanges)) {
+    private List<DataCollectionEmployee> listSalaryEmployeeByManageRange(List<TaxAgentManageRangePO> taxAgentManageRanges, List<DataCollectionEmployee> salaryEmployees) {
+        if (CollectionUtils.isEmpty(taxAgentManageRanges) || CollectionUtils.isEmpty(salaryEmployees)) {
             return Collections.emptyList();
         }
-        List<DataCollectionEmployee> salaryEmployees = getEmployMapper().listAllFields();
         List<DataCollectionEmployee> salaryEmployeeList = Lists.newArrayList();
         for (TaxAgentManageRangePO manageRange : taxAgentManageRanges) {
             salaryEmployeeList.addAll(salaryEmployees.stream()
                     .filter(salaryEmployee -> {
-                        // 判断人员状态
-                        List<String> hrmStatusList = JsonUtil.parseList(manageRange.getEmployeeStatus(), String.class);
-                        // 有状态过滤则取交集
-                        if (CollectionUtils.isNotEmpty(personnelStatuss)) {
-                            hrmStatusList = hrmStatusList.stream().filter(personnelStatuss::contains).collect(Collectors.toList());
-                        }
-                        if (CollectionUtils.isNotEmpty(hrmStatusList) && !hrmStatusList.contains(salaryEmployee.getStatus())) {
+                        if (StringUtils.isEmpty(manageRange.getEmployeeStatus()) || !manageRange.getEmployeeStatus().contains("\"" + salaryEmployee.getStatus() + "\"")) {
                             return false;
                         }
                         if (Objects.equals(manageRange.getTargetType(), TargetTypeEnum.ALL.getValue())) {
@@ -376,7 +313,9 @@ public class TaxAgentManageRangeServiceImpl extends Service implements TaxAgentM
         allRanges = allRanges.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(
                 Comparator.comparing(f -> f.getTaxAgentId() + "." + f.getRangeType() + "." + f.getTargetType() + "." + f.getTargetId() + "." + f.getEmployeeStatus() + "." + f.getIncludeType()))
         ), ArrayList::new));
-        List<DataCollectionEmployee> allSalaryEmployees = this.getManageRangeSalaryEmployees(null, saveParam.getTaxAgentId(), allRanges);
+
+        List<DataCollectionEmployee> salaryEmployees = getEmployMapper().listAll();
+        List<DataCollectionEmployee> allSalaryEmployees = this.getManageRangeSalaryEmployees(saveParam.getTaxAgentId(), allRanges, salaryEmployees);
 
         /* 检查当前个税扣缴义务人的所有人员范围与所有分管理员的管理范围===========================end */
         if (CollectionUtils.isNotEmpty(result.getNeedInsertTaxAgentManageRanges())) {
@@ -414,7 +353,6 @@ public class TaxAgentManageRangeServiceImpl extends Service implements TaxAgentM
     }
 
 
-
     /**
      * 根据分管理员id获取管理范围列表
      *
@@ -449,9 +387,11 @@ public class TaxAgentManageRangeServiceImpl extends Service implements TaxAgentM
         List<TaxAgentManageRangePO> allRanges = allManageRanges.stream().filter(f -> f.getRangeType().equals(TaxAgentRangeTypeEnum.TAXAGENT.getValue())).collect(Collectors.toList());
         List<TaxAgentManageRangePO> allSubAdminRanges = allManageRanges.stream().filter(f -> f.getRangeType().equals(TaxAgentRangeTypeEnum.SUBADMIN.getValue())).collect(Collectors.toList());
         Long taxAgentId = taxAgentIds.get(0);
-        List<DataCollectionEmployee> allSalaryEmployees = this.getManageRangeSalaryEmployees(null, taxAgentId, allRanges);
 
-        List<DataCollectionEmployee> allSubAdminSalaryEmployees = this.getManageRangeSalaryEmployees(null, taxAgentId, allSubAdminRanges);
+        List<DataCollectionEmployee> salaryEmployees = getEmployMapper().listAll();
+        List<DataCollectionEmployee> allSalaryEmployees = this.getManageRangeSalaryEmployees(taxAgentId, allRanges, salaryEmployees);
+
+        List<DataCollectionEmployee> allSubAdminSalaryEmployees = this.getManageRangeSalaryEmployees(taxAgentId, allSubAdminRanges, salaryEmployees);
         allSalaryEmployees.forEach(f -> {
             allSubAdminSalaryEmployees.removeIf(a -> a.getEmployeeId().equals(f.getEmployeeId()));
         });
@@ -474,62 +414,41 @@ public class TaxAgentManageRangeServiceImpl extends Service implements TaxAgentM
         getTaxAgentEmpService(user).deleteByTaxAgentIds(taxAgentIds);
     }
 
-    @Override
-    public void deleteBySubAdmins(Collection<Long> subAdminIds) {
-        if (CollectionUtils.isEmpty(subAdminIds)) {
-            return;
-        }
-        getTaxAgentManageRangeMapper().deleteBySubAdminIds(subAdminIds);
-        // 删除管理范围下的所有人员
-//        taxAgentSubAdminEmployeeService.deleteBySubAdminIds(subAdminIds);
-    }
-
-    //fixme
-//    @AsyncListener(topic = "hrm_resource_queue")
-//    public void receiveHrmResourceQueue(AsyncBean<HrmCommonQueue> asyncBean) {
-//        log.info("接受到人员变动的结果:{}", JSONObject.toJSONString(asyncBean));
-//        // todo 过滤必要性事件类型进行处理,后续加上时间间隔，避免人事批量操作时，监听事件过多
-//        if (asyncBean == null || asyncBean.getMessage() == null) {
-//            log.error("接受到人员变动的结果失败");
-//        }
-//        String tenantKey = asyncBean.getMessage().getTenantKey();
-//        // 开始同步
-//        taskExecutor.execute(() -> {
-//            try {
-//                handleSyncTaxAgentEmpData();
-//            } finally {
-//            }
-//        });
-//    }
 
     /**
      * 同步处理所有人员范围
      *
-     * @param
+     * @param taxAgentIds 为空代表所有个税扣缴义务人
      */
-    private void handleSyncTaxAgentEmpData() {
-        List<TaxAgentManageRangePO> allManageRanges = getTaxAgentManageRangeMapper().listAll();
+    private void handleSyncTaxAgentEmpData(List<Long> taxAgentIds) {
+
+        List<TaxAgentManageRangePO> allManageRanges = getTaxAgentManageRangeMapper().listSome(TaxAgentManageRangePO.builder().taxAgentIds(taxAgentIds).build());
+
         if (CollectionUtils.isEmpty(allManageRanges)) {
             return;
         }
-        List<Long> taxAgentIds = allManageRanges.stream().map(m -> m.getTaxAgentId()).distinct().collect(Collectors.toList());
+        taxAgentIds = allManageRanges.stream().map(TaxAgentManageRangePO::getTaxAgentId).distinct().collect(Collectors.toList());
+        // 获取所有人员
+        List<DataCollectionEmployee> salaryEmployees = getEmployMapper().listAll();
 
         List<TaxAgentEmpSaveParam> taxAgentEmpSaveParamList = Lists.newArrayList();
         List<TaxAgentSubAdminEmpSaveParam> subAdminEmpSaveParamList = Lists.newArrayList();
+
+        Map<String, List<TaxAgentManageRangePO>> allRangeMap = SalaryEntityUtil.group2Map(allManageRanges, k -> k.getTaxAgentId() + "-" + k.getRangeType());
         taxAgentIds.forEach(taxAgentId -> {
             // 当前个税扣缴义务人的所有范围
-            List<TaxAgentManageRangePO> allRanges = allManageRanges.stream().filter(f -> f.getTaxAgentId().equals(taxAgentId) && f.getRangeType().equals(TaxAgentRangeTypeEnum.TAXAGENT.getValue())).collect(Collectors.toList());
-            List<DataCollectionEmployee> allSalaryEmployees = this.getManageRangeSalaryEmployees(null, taxAgentId, allRanges);
+            List<TaxAgentManageRangePO> allRanges = Optional.ofNullable(allRangeMap.get(taxAgentId + "-" + TaxAgentRangeTypeEnum.TAXAGENT.getValue())).orElse(Collections.emptyList());
+            List<DataCollectionEmployee> allSalaryEmployees = this.getManageRangeSalaryEmployees(taxAgentId, allRanges, salaryEmployees);
             taxAgentEmpSaveParamList.add(getTaxAgentEmpSyncParam(taxAgentId, allSalaryEmployees));
-            List<TaxAgentManageRangePO> allSubAdminRanges = allManageRanges.stream().filter(f -> f.getTaxAgentId().equals(taxAgentId) && f.getRangeType().equals(TaxAgentRangeTypeEnum.SUBADMIN.getValue())).collect(Collectors.toList());
 
-            subAdminEmpSaveParamList.addAll(getTaxAgentSubAdminEmpSyncParam(taxAgentId, allSubAdminRanges));
+            List<TaxAgentManageRangePO> allSubAdminRanges = Optional.ofNullable(allRangeMap.get(taxAgentId + "-" + TaxAgentRangeTypeEnum.SUBADMIN.getValue())).orElse(Collections.emptyList());
+            subAdminEmpSaveParamList.addAll(getTaxAgentSubAdminEmpSyncParam(taxAgentId, allSubAdminRanges, salaryEmployees));
         });
         Long employeeId = 0L;
         // 同步管理员的人员
         getTaxAgentEmpService(user).syncTaxAgentEmployee(taxAgentEmpSaveParamList, employeeId);
         // 同步分管理员的人员
-//        taxAgentSubAdminEmployeeService.syncTaxAgentSubAdminEmployee(subAdminEmpSaveParamList, employeeId);
+//        taxAgentSubAdminEmployeeService.syncTaxAgentSubAdminEmployee(subAdminEmpSaveParamList, employeeId, tenantKey);
     }
 
     /**
@@ -551,14 +470,15 @@ public class TaxAgentManageRangeServiceImpl extends Service implements TaxAgentM
      *
      * @param taxAgentId
      * @param allSubAdminRanges
+     * @param salaryEmployees
      * @return
      */
-    private List<TaxAgentSubAdminEmpSaveParam> getTaxAgentSubAdminEmpSyncParam(Long taxAgentId, List<TaxAgentManageRangePO> allSubAdminRanges) {
+    private List<TaxAgentSubAdminEmpSaveParam> getTaxAgentSubAdminEmpSyncParam(Long taxAgentId, List<TaxAgentManageRangePO> allSubAdminRanges, List<DataCollectionEmployee> salaryEmployees) {
         List<Long> allSubAdminIds = allSubAdminRanges.stream().map(TaxAgentManageRangePO::getTaxAgentSubAdminId).distinct().collect(Collectors.toList());
         List<TaxAgentSubAdminEmpSaveParam> subAdminEmpSaveParamList = Lists.newArrayList();
         allSubAdminIds.forEach(e -> {
             List<TaxAgentManageRangePO> singSubAdminRanges = allSubAdminRanges.stream().filter(r -> e.equals(r.getTaxAgentSubAdminId())).collect(Collectors.toList());
-            List<DataCollectionEmployee> subAdminSalaryEmployees = this.getManageRangeSalaryEmployees(null, taxAgentId, singSubAdminRanges);
+            List<DataCollectionEmployee> subAdminSalaryEmployees = this.getManageRangeSalaryEmployees(taxAgentId, singSubAdminRanges, salaryEmployees);
 
             subAdminEmpSaveParamList.add(TaxAgentSubAdminEmpSaveParam.builder()
                     .taxAgentId(taxAgentId)
@@ -591,4 +511,28 @@ public class TaxAgentManageRangeServiceImpl extends Service implements TaxAgentM
             log.error("同步个税扣缴人员范围异常", e);
         }
     }
+
+
+    /**
+     * 同步人员范围
+     *
+     * @param taxAgentIds
+     */
+    @Override
+    public void syncManageRange(List<Long> taxAgentIds,String index) {
+        // 开始同步
+        LocalRunnable localRunnable = new LocalRunnable() {
+            @Override
+            public void execute() {
+                try {
+                    Util_DataCache.setObjVal(index, "1");
+                    handleSyncTaxAgentEmpData(taxAgentIds);
+                } finally {
+                    Util_DataCache.clearVal(index);
+                }
+            }
+        };
+        ThreadPoolUtil.execute(localRunnable);
+    }
+
 }
diff --git a/src/com/engine/salary/timer/SyncTaxAgentEmpJob.java b/src/com/engine/salary/timer/SyncTaxAgentEmpJob.java
index 42469d146..f8cf72df1 100644
--- a/src/com/engine/salary/timer/SyncTaxAgentEmpJob.java
+++ b/src/com/engine/salary/timer/SyncTaxAgentEmpJob.java
@@ -1,56 +1,26 @@
 package com.engine.salary.timer;
 
 import com.engine.common.util.ServiceUtil;
-import com.engine.salary.entity.datacollection.DataCollectionEmployee;
-import com.engine.salary.entity.taxagent.param.TaxAgentEmpSaveParam;
-import com.engine.salary.entity.taxagent.po.TaxAgentManageRangePO;
-import com.engine.salary.entity.taxagent.po.TaxAgentPO;
-import com.engine.salary.enums.salarysob.SalaryEmployeeStatusEnum;
-import com.engine.salary.enums.salarysob.TargetTypeEnum;
-import com.engine.salary.enums.taxagent.TaxAgentRangeTypeEnum;
-import com.engine.salary.mapper.datacollection.EmployMapper;
-import com.engine.salary.mapper.taxagent.TaxAgentManageRangeMapper;
-import com.engine.salary.mapper.taxagent.TaxAgentMapper;
-import com.engine.salary.service.TaxAgentEmpService;
-import com.engine.salary.service.impl.TaxAgentEmpServiceImpl;
-import com.engine.salary.util.JsonUtil;
-import com.engine.salary.util.SalaryEntityUtil;
-import com.engine.salary.util.db.MapperProxyFactory;
-import com.google.common.collect.Lists;
+import com.engine.salary.wrapper.TaxAgentWrapper;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.collections4.CollectionUtils;
-import org.apache.commons.lang3.math.NumberUtils;
+import org.springframework.util.StopWatch;
 import weaver.hrm.User;
 import weaver.interfaces.schedule.BaseCronJob;
 
-import java.util.*;
-import java.util.stream.Collectors;
-
 @Slf4j
 public class SyncTaxAgentEmpJob extends BaseCronJob {
 
-    private TaxAgentMapper getTaxAgentMapper() {
-        return MapperProxyFactory.getProxy(TaxAgentMapper.class);
-    }
-
-    private TaxAgentManageRangeMapper getTaxAgentManageRangeMapper() {
-        return MapperProxyFactory.getProxy(TaxAgentManageRangeMapper.class);
-    }
-
-    private EmployMapper getEmployMapper() {
-        return MapperProxyFactory.getProxy(EmployMapper.class);
-    }
-
-    private TaxAgentEmpService getTaxAgentEmpService(User user) {
-        return ServiceUtil.getService(TaxAgentEmpServiceImpl.class, user);
+    private TaxAgentWrapper getTaxAgentWrapper(User user) {
+        return ServiceUtil.getService(TaxAgentWrapper.class, user);
     }
 
     @Override
     public void execute() {
-        long time = System.currentTimeMillis();
-        log.info("计划任务【SyncTaxAgentEmpJob】开始执行");
+        StopWatch stopWatch = new StopWatch();
+        stopWatch.start("计划任务【SyncTaxAgentEmpJob】");
         start();
-        log.info("计划任务【SyncTaxAgentEmpJob】执行结束，用时：" + (System.currentTimeMillis() - time));
+        stopWatch.stop();
+        log.info(stopWatch.prettyPrint());
     }
 
 
@@ -59,174 +29,9 @@ public class SyncTaxAgentEmpJob extends BaseCronJob {
      */
     private void start() {
         try {
-            //获取所以个税扣缴义务人
-            List<TaxAgentPO> taxAgentPOS = getTaxAgentMapper().listAll();
-
-            //执行同步
-            taxAgentPOS.forEach(taxAgent -> {
-                Long taxAgentId = taxAgent.getId();
-
-                // 查询已有的管理范围
-                List<TaxAgentManageRangePO> taxAgentManageAllRanges = getTaxAgentManageRangeMapper().listSome(TaxAgentManageRangePO.builder()
-                        .taxAgentId(taxAgentId).rangeType(TaxAgentRangeTypeEnum.TAXAGENT.getValue()).build());
-
-                /* 检查当前个税扣缴义务人的所有人员范围与所有分管理员的管理范围===========================start */
-                List<TaxAgentManageRangePO> allRanges = Lists.newArrayList(taxAgentManageAllRanges);
-                // 去重
-                allRanges = allRanges.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(
-                        Comparator.comparing(f -> f.getTaxAgentId() + "." + f.getRangeType() + "." + f.getTargetType() + "." + f.getTargetId() + "." + f.getEmployeeStatus() + "." + f.getIncludeType()))
-                ), ArrayList::new));
-                List<DataCollectionEmployee> allSalaryEmployees = this.getManageRangeSalaryEmployees(null, taxAgentId, allRanges);
-
-
-                /* 同步本地人员范围的关联人员=========================== */
-                syncLocalEmp(taxAgentId, allSalaryEmployees, 0L);
-            });
-
-
+            getTaxAgentWrapper(null).syncAllRange();
         } catch (Exception e) {
             log.error("计划任务【SyncTaxAgentEmpJob】执行异常：" + e);
         }
-
     }
-
-
-    /**
-     * 同步本地范围关联人员
-     *
-     * @param taxAgentId
-     * @param allSalaryEmployees 个税扣缴义务人下的所有人员
-     * @param employeeId
-     */
-    private void syncLocalEmp(Long taxAgentId, List<DataCollectionEmployee> allSalaryEmployees, Long employeeId) {
-        try {
-            List<TaxAgentEmpSaveParam> taxAgentEmpSaveParamList = Collections.singletonList(getTaxAgentEmpSyncParam(taxAgentId, allSalaryEmployees));
-            // 同步个税扣缴义务人的人员
-            getTaxAgentEmpService(null).syncTaxAgentEmployee(taxAgentEmpSaveParamList, employeeId);
-
-        } catch (Exception e) {
-            log.error("同步个税扣缴人员范围异常", e);
-        }
-    }
-
-    /**
-     * 获取个税扣缴义务人的同步参数
-     *
-     * @param taxAgentId
-     * @param allSalaryEmployees
-     * @return
-     */
-    private TaxAgentEmpSaveParam getTaxAgentEmpSyncParam(Long taxAgentId, List<DataCollectionEmployee> allSalaryEmployees) {
-        return TaxAgentEmpSaveParam.builder()
-                .taxAgentId(taxAgentId)
-                .salaryEmployeeList(allSalaryEmployees)
-                .build();
-    }
-
-
-    /**
-     * 获取范围下的人员
-     *
-     * @param employeeStatus
-     * @param taxAgentId
-     * @param allTaxAgentManageRanges
-     * @return
-     */
-    private List<DataCollectionEmployee> getManageRangeSalaryEmployees(SalaryEmployeeStatusEnum employeeStatus, Long taxAgentId,
-                                                                       List<TaxAgentManageRangePO> allTaxAgentManageRanges) {
-        List<TaxAgentManageRangePO> includeAllTaxAgentManageRanges = allTaxAgentManageRanges.stream().filter(f -> f.getIncludeType().equals(NumberUtils.INTEGER_ONE)).collect(Collectors.toList());
-        if (CollectionUtils.isEmpty(includeAllTaxAgentManageRanges)) {
-            return Collections.emptyList();
-        }
-        List<TaxAgentManageRangePO> excludeAllTaxAgentManageRanges = allTaxAgentManageRanges.stream().filter(f -> f.getIncludeType().equals(NumberUtils.INTEGER_ZERO)).collect(Collectors.toList());
-
-        List<DataCollectionEmployee> includeSalaryEmployees = Lists.newArrayList();
-        List<TaxAgentManageRangePO> includeTaxAgentManageRanges = includeAllTaxAgentManageRanges.stream().filter(f -> f.getTaxAgentId().equals(taxAgentId)).collect(Collectors.toList());
-        if (CollectionUtils.isEmpty(includeTaxAgentManageRanges)) {
-            return includeSalaryEmployees;
-        }
-        // 如果需要状态过滤
-        List<String> personnelStatuss = Lists.newArrayList();
-        if (employeeStatus != null) {
-            // 查询人员状态
-//            if (employeeStatus.equals(SalaryEmployeeStatusEnum.NORMAL)) {
-//                personnelStatuss = UserStatusEnum.getNormalStatus();
-//            } else if (employeeStatus.equals(SalaryEmployeeStatusEnum.UNAVAILABLE)) {
-//                personnelStatuss = UserStatusEnum.getUnavailableStatus();
-//            }
-            personnelStatuss.add(employeeStatus.getValue().toString());
-        }
-        // 根据上一步的查询参数查询人员
-        includeSalaryEmployees = listSalaryEmployeeByManageRange(includeTaxAgentManageRanges, personnelStatuss);
-        if (CollectionUtils.isEmpty(includeSalaryEmployees)) {
-            return includeSalaryEmployees;
-        }
-        // 查询管理范围（从范围中排除）
-        List<TaxAgentManageRangePO> excludeTaxAgentManageRanges = excludeAllTaxAgentManageRanges.stream().filter(f -> f.getTaxAgentId().equals(taxAgentId)).collect(Collectors.toList());
-        if (CollectionUtils.isNotEmpty(excludeTaxAgentManageRanges)) {
-            // 根据上一步的查询参数查询人员
-            List<DataCollectionEmployee> excludeSalaryEmployees = listSalaryEmployeeByManageRange(excludeTaxAgentManageRanges, personnelStatuss);
-            // 需要排除的人员范围
-            Set<Long> excludeEmployeeIds = SalaryEntityUtil.properties(excludeSalaryEmployees, DataCollectionEmployee::getEmployeeId);
-            // 过滤人员
-            includeSalaryEmployees = includeSalaryEmployees.stream()
-                    .filter(salaryEmployee -> !excludeEmployeeIds.contains(salaryEmployee.getEmployeeId()))
-                    .collect(Collectors.toList());
-        }
-        return includeSalaryEmployees;
-    }
-
-
-    /**
-     * 根据范围加载人员
-     *
-     * @param taxAgentManageRanges
-     * @return
-     */
-    private List<DataCollectionEmployee> listSalaryEmployeeByManageRange(List<TaxAgentManageRangePO> taxAgentManageRanges, List<String> personnelStatuss) {
-        if (CollectionUtils.isEmpty(taxAgentManageRanges)) {
-            return Collections.emptyList();
-        }
-        List<DataCollectionEmployee> salaryEmployees = getEmployMapper().listAllFields();
-        List<DataCollectionEmployee> salaryEmployeeList = Lists.newArrayList();
-        for (TaxAgentManageRangePO manageRange : taxAgentManageRanges) {
-            salaryEmployeeList.addAll(salaryEmployees.stream()
-                    .filter(salaryEmployee -> {
-                        // 判断人员状态
-                        List<String> hrmStatusList = JsonUtil.parseList(manageRange.getEmployeeStatus(), String.class);
-                        // 有状态过滤则取交集
-                        if (CollectionUtils.isNotEmpty(personnelStatuss)) {
-                            hrmStatusList = hrmStatusList.stream().filter(personnelStatuss::contains).collect(Collectors.toList());
-                        }
-                        if (CollectionUtils.isNotEmpty(hrmStatusList) && !hrmStatusList.contains(salaryEmployee.getStatus())) {
-                            return false;
-                        }
-                        if (Objects.equals(manageRange.getTargetType(), TargetTypeEnum.ALL.getValue())) {
-                            return true;
-                        }
-                        if (Objects.equals(manageRange.getTargetType(), TargetTypeEnum.EMPLOYEE.getValue())
-                                && Objects.equals(manageRange.getTargetId(), salaryEmployee.getEmployeeId())) {
-                            return true;
-                        }
-                        if (Objects.equals(manageRange.getTargetType(), TargetTypeEnum.DEPT.getValue())
-                                && Objects.equals(manageRange.getTargetId(), salaryEmployee.getDepartmentId())) {
-                            return true;
-                        }
-                        if (Objects.equals(manageRange.getTargetType(), TargetTypeEnum.SUBCOMPANY.getValue())
-                                && Objects.equals(manageRange.getTargetId(), salaryEmployee.getSubcompanyid())) {
-                            return true;
-                        }
-                        if (Objects.equals(manageRange.getTargetType(), TargetTypeEnum.POSITION.getValue())
-                                && Objects.equals(manageRange.getTargetId(), salaryEmployee.getJobtitleId())) {
-                            return true;
-                        }
-                        return false;
-                    }).collect(Collectors.toList()));
-        }
-        // 去重
-        salaryEmployeeList = salaryEmployeeList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(DataCollectionEmployee::getEmployeeId))), ArrayList::new));
-        return salaryEmployeeList;
-    }
-
-
 }
diff --git a/src/com/engine/salary/util/SalaryDateUtil.java b/src/com/engine/salary/util/SalaryDateUtil.java
index 024780761..3a5f362e2 100644
--- a/src/com/engine/salary/util/SalaryDateUtil.java
+++ b/src/com/engine/salary/util/SalaryDateUtil.java
@@ -115,6 +115,19 @@ public class SalaryDateUtil {
         }
     }
 
+    public static String getFormatDate(Date localDate) {
+        if (localDate == null) {
+            return StringUtils.EMPTY;
+        }
+        try {
+            SimpleDateFormat simpleDateFormat = new SimpleDateFormat(DATE_FORMATTER_PATTERN);
+            return simpleDateFormat.format(localDate);
+        } catch (Exception e) {
+            log.warn("格式化日期错误", e);
+            return StringUtils.EMPTY;
+        }
+    }
+
     public static String getFormatLocalDate(LocalDateTime localDateTime) {
         if (localDateTime == null) {
             return StringUtils.EMPTY;
diff --git a/src/com/engine/salary/web/SIExportController.java b/src/com/engine/salary/web/SIExportController.java
index 4b749f9ed..7b7209bb5 100644
--- a/src/com/engine/salary/web/SIExportController.java
+++ b/src/com/engine/salary/web/SIExportController.java
@@ -162,8 +162,8 @@ public class SIExportController {
     @Path("/recession/export")
     @Produces(MediaType.APPLICATION_OCTET_STREAM)
     public Response exportRecession(@Context HttpServletRequest request, @Context HttpServletResponse response,
-                                        @QueryParam("billMonth") String billMonth,@QueryParam("creator") Long creator) {
-        InsuranceExportParam param = InsuranceExportParam.builder().billMonth(billMonth).creator(creator).build();
+                                        @QueryParam("billMonth") String billMonth,@QueryParam("creator") Long creator,@QueryParam("paymentOrganization") String paymentOrganization) {
+        InsuranceExportParam param = InsuranceExportParam.builder().billMonth(billMonth).creator(creator).paymentOrganization(paymentOrganization).build();
         User user = HrmUserVarify.getUser(request, response);
         XSSFWorkbook workbook = getSIExportWrapper(user).exportAccount(PaymentStatusEnum.RECESSION.getValue(),param);
         String time = LocalDate.now().toString();
diff --git a/src/com/engine/salary/web/TaxAgentController.java b/src/com/engine/salary/web/TaxAgentController.java
index 8695bf32b..55c43b0d7 100644
--- a/src/com/engine/salary/web/TaxAgentController.java
+++ b/src/com/engine/salary/web/TaxAgentController.java
@@ -1,7 +1,10 @@
 package com.engine.salary.web;
 
 import com.engine.common.util.ServiceUtil;
-import com.engine.salary.entity.taxagent.dto.*;
+import com.engine.salary.entity.taxagent.dto.TaxAgentFormDTO;
+import com.engine.salary.entity.taxagent.dto.TaxAgentManageRangeEmployeeDTO;
+import com.engine.salary.entity.taxagent.dto.TaxAgentManageRangeFormDTO;
+import com.engine.salary.entity.taxagent.dto.TaxAgentManageRangeListDTO;
 import com.engine.salary.entity.taxagent.param.*;
 import com.engine.salary.entity.taxagent.po.TaxAgentBasePO;
 import com.engine.salary.util.ResponseResult;
@@ -32,7 +35,7 @@ public class TaxAgentController {
     private TaxAgentSubAdminWrapper getTaxAgentSubAdminWrapper(User user) {
         return ServiceUtil.getService(TaxAgentSubAdminWrapper.class, user);
     }
-    
+
     private TaxAgentWrapper getTaxAgentWrapper(User user) {
         return ServiceUtil.getService(TaxAgentWrapper.class, user);
     }
@@ -50,6 +53,7 @@ public class TaxAgentController {
 
     /**
      * 权限信息
+     *
      * @param request
      * @param response
      * @return
@@ -284,6 +288,16 @@ public class TaxAgentController {
         return new ResponseResult<Long, List<TaxAgentManageRangeEmployeeDTO>>(user).run(getTaxAgentWrapper(user)::getEmpListInTaxAgent, id);
     }
 
+
+    //同步人员范围
+    @POST
+    @Path("/range/sync")
+    @Produces(MediaType.APPLICATION_JSON)
+    public String syncRange(@Context HttpServletRequest request, @Context HttpServletResponse response) {
+        User user = HrmUserVarify.getUser(request, response);
+        return new ResponseResult<Long, String>(user).run(getTaxAgentWrapper(user)::syncRange);
+    }
+
     /* ******* 个税扣缴义务人 end ***********************************************************************************************/
 
     /* ******* 分管理员 start ***********************************************************************************************/
diff --git a/src/com/engine/salary/wrapper/TaxAgentWrapper.java b/src/com/engine/salary/wrapper/TaxAgentWrapper.java
index 6dd21c58b..ac7aab10b 100644
--- a/src/com/engine/salary/wrapper/TaxAgentWrapper.java
+++ b/src/com/engine/salary/wrapper/TaxAgentWrapper.java
@@ -1,7 +1,9 @@
 package com.engine.salary.wrapper;
 
+import com.cloudstore.dev.api.util.Util_DataCache;
 import com.engine.common.util.ServiceUtil;
 import com.engine.core.impl.Service;
+import com.engine.salary.cache.SalaryCacheKey;
 import com.engine.salary.entity.datacollection.DataCollectionEmployee;
 import com.engine.salary.entity.hrm.HrmStatus;
 import com.engine.salary.entity.taxagent.bo.TaxAgentBO;
@@ -22,6 +24,7 @@ import org.apache.commons.collections.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.math.NumberUtils;
 import org.springframework.beans.BeanUtils;
+import weaver.general.Util;
 import weaver.hrm.User;
 
 import java.util.*;
@@ -350,10 +353,57 @@ public class TaxAgentWrapper extends Service {
 
     /**
      * 获取个税管理的人员情况
+     *
      * @param id
      * @return
      */
     public List<TaxAgentManageRangeEmployeeDTO> getEmpListInTaxAgent(Long id) {
         return getTaxAgentService(user).listTaxAgentAndEmployeeTree((long) user.getUID());
     }
+
+
+    /**
+     * 同步当前人员管理的个税扣缴义务人人员范围
+     *
+     * @return
+     */
+    public String syncRange() {
+        long currentEmployeeId = (long) user.getUID();
+        List<Long> taxAgentIds = this.getTaxAgentService(user).listAllTaxAgents(currentEmployeeId).stream().map(TaxAgentPO::getId).collect(Collectors.toList());
+
+        String index = SalaryCacheKey.TAX_AGENT_MANAGE_RANGE_SYNC + "-" + currentEmployeeId;
+        String syncRange = Util.null2String(Util_DataCache.getObjVal(index));
+        if (StringUtils.isEmpty(syncRange)) {
+            getTaxAgentManageRangeService(user).syncManageRange(taxAgentIds, index);
+//            try {
+//                TimeUnit.SECONDS.sleep(2);
+//            } catch (InterruptedException e) {
+//
+//            }
+        } else {
+            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(135788, "人员范围同步过于频繁，请稍后再试"));
+        }
+        return SalaryI18nUtil.getI18nLabel(93945, "同步成功");
+    }
+
+
+    /**
+     * 同步所有个税扣缴义务人的人员范围
+     *
+     * @return
+     */
+    public String syncAllRange() {
+        String syncRange = Util.null2String(Util_DataCache.getObjVal(SalaryCacheKey.TAX_AGENT_MANAGE_RANGE_SYNC));
+        if (StringUtils.isEmpty(syncRange)) {
+            getTaxAgentManageRangeService(user).syncManageRange(null, SalaryCacheKey.TAX_AGENT_MANAGE_RANGE_SYNC);
+//            try {
+//                TimeUnit.SECONDS.sleep(2);
+//            } catch (InterruptedException e) {
+//
+//            }
+        } else {
+            throw new SalaryRunTimeException(SalaryI18nUtil.getI18nLabel(135788, "人员范围同步过于频繁，请稍后再试"));
+        }
+        return SalaryI18nUtil.getI18nLabel(93945, "同步成功");
+    }
 }
diff --git a/src/com/engine/salary/wrapper/TaxDeclarationWrapper.java b/src/com/engine/salary/wrapper/TaxDeclarationWrapper.java
index 2b4a75e9b..df7acfb9a 100644
--- a/src/com/engine/salary/wrapper/TaxDeclarationWrapper.java
+++ b/src/com/engine/salary/wrapper/TaxDeclarationWrapper.java
@@ -4,9 +4,6 @@ import com.engine.common.util.ServiceUtil;
 import com.engine.core.impl.Service;
 import com.engine.salary.biz.EmployBiz;
 import com.engine.salary.component.WeaFormOption;
-import com.engine.salary.encrypt.datacollection.AddUpSituationEncrypt;
-import com.engine.salary.encrypt.taxdeclaration.TaxDeclarationDetailPOEncrypt;
-import com.engine.salary.entity.datacollection.AddUpSituation;
 import com.engine.salary.entity.datacollection.DataCollectionEmployee;
 import com.engine.salary.entity.taxagent.po.TaxAgentPO;
 import com.engine.salary.entity.taxdeclaration.bo.TaxDeclarationBO;
@@ -15,7 +12,6 @@ import com.engine.salary.entity.taxdeclaration.dto.TaxDeclarationInfoDTO;
 import com.engine.salary.entity.taxdeclaration.dto.TaxDeclarationListDTO;
 import com.engine.salary.entity.taxdeclaration.param.TaxDeclarationListQueryParam;
 import com.engine.salary.entity.taxdeclaration.param.TaxDeclarationSaveParam;
-import com.engine.salary.entity.taxdeclaration.po.TaxDeclarationDetailPO;
 import com.engine.salary.entity.taxdeclaration.po.TaxDeclarationPO;
 import com.engine.salary.exception.SalaryRunTimeException;
 import com.engine.salary.service.TaxAgentService;