feat(opmc): 新增调薪跟踪功能并优化考核周期处理逻辑

- 在EntityHelper中新增支持带ID创建实体的方法
- 修改AdminOrgHelper中的BOS_ORG常量值为小写
- 新增SalAdjTrackerConstant调薪情况常量类
- 优化CycleGenerateOpPlugin插件中实体创建方式
- 完善PerfManagerSaveOpPlugin插件的状态设置逻辑
- 重构SalaryAdjOpPlugin插件实现完整的调薪处理流程
- 添加对重复考核周期的校验及异常提示
- 实现调薪记录生成与相关数据匹配逻辑
- 增强考核周期结束与新周期生成机制
- 引入必要的工具类与服务帮助类依赖

code/base/nckd-jxccl-base-helper/src/main/java/nckd/jxccl/base/entity/helper/EntityHelper.java

@@ -24,6 +24,12 @@ public class EntityHelper {
     public static DynamicObject newEntity(String entityName){
         return BusinessDataServiceHelper.newDynamicObject(entityName);
     }
+
+    public static DynamicObject newEntity(String entityName, Long id){
+        DynamicObject dy =BusinessDataServiceHelper.newDynamicObject(entityName);
+        dy.set(FormConstant.ID_KEY, id);
+        return dy;
+    }
     /**
      * 创建一个状态为"可用"的基础资料对象
      * @param entityName 实体标识

code/base/nckd-jxccl-base-helper/src/main/java/nckd/jxccl/base/org/helper/AdminOrgHelper.java

@@ -20,7 +20,7 @@ import java.util.Set;
  */
 public class AdminOrgHelper {
 
-    public static final String BOS_ORG = "BOS_ORG";
+    public static final String BOS_ORG = "bos_org";
     /**
      * 获取当前组织下的所有子组织
      * @param adminOrgId 组织id

code/opmc/nckd-jxccl-opmc/src/main/java/nckd/jxccl/opmc/pm/common/SalAdjTrackerConstant.java

@@ -0,0 +1,47 @@
+package nckd.jxccl.opmc.pm.common;
+
+import nckd.jxccl.base.common.constant.FormConstant;
+
+/**
+ * 调薪情况常量类
+ *
+ * @author W.Y.C
+ * @version 1.0
+ * @date 2025-11-25 18:05:26
+ */
+public class SalAdjTrackerConstant extends FormConstant {
+    /** 调薪情况-实体标识 */
+    public static final String SALADJTRACKER_ENTITYID = "nckd_saladjtracker";
+    /** 考核周期 */
+    public static final String NCKD_PERFMANAGER = "NCKD_PERFMANAGER";
+    /** 原薪等 */
+    public static final String NCKD_OLDSALARYGRADE = "NCKD_OLDSALARYGRADE";
+    /** 原薪档 */
+    public static final String NCKD_OLDSALARYRANK = "NCKD_OLDSALARYRANK";
+    /** 原金额 */
+    public static final String NCKD_OLDMONEY = "NCKD_OLDMONEY";
+    /** 目标薪等 */
+    public static final String NCKD_SALARYGRADE = "NCKD_SALARYGRADE";
+    /** 目标薪档 */
+    public static final String NCKD_SALARYRANK = "NCKD_SALARYRANK";
+    /** 目标金额 */
+    public static final String NCKD_MONEY = "NCKD_MONEY";
+    /** 调档原因 */
+    public static final String NCKD_WAGEEXPLAIN = "NCKD_WAGEEXPLAIN";
+    /** 调薪类型 */
+    public static final String NCKD_APPRAISALTYPE = "NCKD_APPRAISALTYPE";
+    /** 处理状态 */
+    public static final String NCKD_WAGESTATUS = "NCKD_WAGESTATUS";
+    /** 统计年度 */
+    public static final String NCKD_TODOYEAR = "NCKD_TODOYEAR";
+    /** 原薪酬项目 */
+    public static final String NCKD_OLDSTANDARDITEM = "NCKD_OLDSTANDARDITEM";
+    /** 薪酬项目 */
+    public static final String NCKD_STANDARDITEM = "NCKD_STANDARDITEM";
+    /** 补差金额 */
+    public static final String NCKD_ADJMONEY = "NCKD_ADJMONEY";
+    /** 部门 */
+    public static final String NCKD_DEP = "NCKD_DEP";
+    /** 岗位 */
+    public static final String NCKD_POSITION = "NCKD_POSITION";
+}

code/opmc/nckd-jxccl-opmc/src/main/java/nckd/jxccl/opmc/pm/plugin/operate/cycle/CycleGenerateOpPlugin.java

@@ -92,7 +92,7 @@ public class CycleGenerateOpPlugin extends AbstractOperationServicePlugIn implem
         //调用save-op
         List<DynamicObject> savePerfManager = new ArrayList<>();
         for (PerfManagerSaveOpPlugin.PersonPerfInfo value : pendingCyclePersonnelMap.values()) {
-            DynamicObject newPerfManager = EntityHelper.newAvailableBasicEntity(PerfManagerFormConstant.PERFMANAGER_ENTITYID);
+            DynamicObject newPerfManager = EntityHelper.newEntity(PerfManagerFormConstant.PERFMANAGER_ENTITYID);
             String personName = value.getPerson().getString(FormConstant.NAME_KEY);
             newPerfManager.set(FormConstant.NCKD_EMPPOSORGREL, value.getEmpPosOrgRel());
             newPerfManager.set(FormConstant.NCKD_DEP, value.getAdminOrg());

code/opmc/nckd-jxccl-opmc/src/main/java/nckd/jxccl/opmc/pm/plugin/operate/cycle/PerfManagerSaveOpPlugin.java

@@ -32,7 +32,17 @@ import nckd.jxccl.opmc.pm.helper.PerfManagerHelper;
 import org.apache.commons.lang3.StringUtils;
 
 import java.time.LocalDateTime;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.StringJoiner;
 import java.util.stream.Collectors;
 
 /**
@@ -330,7 +340,10 @@ public class PerfManagerSaveOpPlugin extends AbstractOperationServicePlugIn impl
             LocalDateTime endYear = DateUtil.toLocalDateTime(dataEntity.getDate(PerfManagerFormConstant.NCKD_ENDYEAR));
             long personId = person.getLong(FormConstant.ID_KEY);
             String personName = person.getString(FormConstant.NAME_KEY);
-            dataEntity.set(PerfManagerFormConstant.NCKD_THESTATUS,EnableEnum.YES.getCode());
+            String theStatus = dataEntity.getString(PerfManagerFormConstant.NCKD_THESTATUS);
+            if(StringUtils.isBlank(theStatus)) {
+                dataEntity.set(PerfManagerFormConstant.NCKD_THESTATUS, EnableEnum.YES.getCode());
+            }
             // dataEntity.set(FormConstant.NCKD_ISCURRENTNEWEST, EnableEnum.YES.getCode());
             String name = dataEntity.getString(FormConstant.NAME_KEY);
             if(StringUtils.isBlank(name)){

code/opmc/nckd-jxccl-opmc/src/main/java/nckd/jxccl/opmc/pm/plugin/operate/salary/SalaryAdjOpPlugin.java

@@ -1,60 +1,76 @@
 package nckd.jxccl.opmc.pm.plugin.operate.salary;
 
-import kd.bos.algo.Algo;
-import kd.bos.algo.AlgoContext;
-import kd.bos.algo.DataSet;
-import kd.bos.algo.Row;
+import kd.bos.bd.pojo.CtrlStrategyEnum;
 import kd.bos.common.enums.EnableEnum;
 import kd.bos.consts.PermItemConst;
 import kd.bos.context.RequestContext;
+import kd.bos.dataentity.OperateOption;
 import kd.bos.dataentity.entity.DynamicObject;
+import kd.bos.dataentity.entity.DynamicObjectCollection;
 import kd.bos.entity.EntityMetadataCache;
+import kd.bos.entity.MainEntityType;
 import kd.bos.entity.QueryEntityType;
+import kd.bos.entity.operate.OperateOptionConst;
+import kd.bos.entity.operate.result.IOperateInfo;
+import kd.bos.entity.operate.result.OperationResult;
 import kd.bos.entity.plugin.AbstractOperationServicePlugIn;
 import kd.bos.entity.plugin.args.BeginOperationTransactionArgs;
 import kd.bos.entity.validate.BillStatus;
-import kd.bos.ext.hr.service.query.QueryEntityHelper;
 import kd.bos.logging.Log;
 import kd.bos.logging.LogFactory;
 import kd.bos.orm.query.QCP;
 import kd.bos.orm.query.QFilter;
+import kd.bos.servicehelper.BusinessDataServiceHelper;
 import kd.bos.servicehelper.DispatchServiceHelper;
+import kd.bos.servicehelper.MetadataServiceHelper;
+import kd.bos.servicehelper.QueryServiceHelper;
+import kd.bos.servicehelper.basedata.BaseDataServiceHelper;
+import kd.bos.servicehelper.operation.SaveServiceHelper;
+import kd.bos.servicehelper.user.UserServiceHelper;
 import kd.hr.hbp.common.model.AuthorizedOrgResultWithSub;
 import kd.hr.hbp.common.model.OrgSubInfo;
 import kd.sdk.hr.hbp.business.helper.permission.HRPermissionServiceHelper;
 import kd.sdk.plugin.Plugin;
 import kd.sdk.swc.hcdm.business.helper.HCDMAdjFileServiceHelper;
+import kd.sdk.swc.hcdm.business.helper.HCDMSalaryStdServiceHelper;
+import kd.sdk.swc.hcdm.common.dto.stdtab.match.StdTableDataMatchParam;
+import kd.sdk.swc.hcdm.common.dto.stdtab.match.StdTableDataMatchResult;
 import nckd.jxccl.base.common.constant.FormConstant;
 import nckd.jxccl.base.common.enums.AppraisalResultEnum;
 import nckd.jxccl.base.common.exception.ValidationException;
 import nckd.jxccl.base.common.utils.ConvertUtil;
 import nckd.jxccl.base.common.utils.DateUtil;
 import nckd.jxccl.base.common.utils.QueryFieldBuilder;
+import nckd.jxccl.base.common.utils.StrFormatter;
 import nckd.jxccl.base.entity.helper.EntityHelper;
+import nckd.jxccl.base.org.helper.AdminOrgHelper;
 import nckd.jxccl.opmc.pm.common.PerfManagerFormConstant;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import nckd.jxccl.opmc.pm.common.SalAdjTrackerConstant;
+import org.apache.commons.lang3.StringUtils;
 
 import java.math.BigDecimal;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Calendar;
+import java.util.Collections;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
+import java.util.StringJoiner;
 import java.util.stream.Collectors;
 
 /**
-* 生成调薪
-* 实体标识：nckd_saladjtracker
-* @author W.Y.C
-* @date 2025/11/24 13:14
-* @version 1.0
-*/
+ * 生成调薪
+ * 实体标识：nckd_saladjtracker
+ * @author W.Y.C
+ * @date 2025/11/24 13:14
+ * @version 1.0
+ */
 public class SalaryAdjOpPlugin extends AbstractOperationServicePlugIn implements Plugin {
 
     private static final Log logger = LogFactory.getLog(SalaryAdjOpPlugin.class);
@@ -63,13 +79,13 @@ public class SalaryAdjOpPlugin extends AbstractOperationServicePlugIn implements
     /**不及格降档*/
     private static final int TYPE_DEMOTE_FOR_FAIL = -1;
     /**及格升档*/
-    private static final int TYPE_NO_CHANGE = 0;         // 不升不降档
+    private static final int TYPE_NO_CHANGE = 0;
     /**双优升档*/
-    private static final int TYPE_PROMOTE_FOR_TWO_EXCELLENT = 1;  // 双优升档
+    private static final int TYPE_PROMOTE_FOR_TWO_EXCELLENT = 1;
     /**三及格升档*/
-    private static final int TYPE_PROMOTE_FOR_THREE_PASS = 2;     // 三及格升档
+    private static final int TYPE_PROMOTE_FOR_THREE_PASS = 2;
     /**双优以及三及格升档*/
-    private static final int TYPE_PROMOTE_FOR_TWO_EXCELLENT_AND_THREE_PASS = 3; // 双优以及三及格
+    private static final int TYPE_PROMOTE_FOR_TWO_EXCELLENT_AND_THREE_PASS = 3;
     /**连续两年考核结果为优秀且另一年考核结果为合格及以上*/
     private static final int TYPE_PROMOTE_FOR_TWO_EXCELLENT_AND_THREE_PASS_FOR_TWO_YEARS = 4;
     /** 岗位工资标准（jt002）*/
@@ -83,6 +99,7 @@ public class SalaryAdjOpPlugin extends AbstractOperationServicePlugIn implements
 
 
         Long currUserId = RequestContext.get().getCurrUserId();
+        DynamicObject currUser = UserServiceHelper.getUserInfoByID(currUserId, FormConstant.ID_KEY);
         // 只处理权限范围内的人员
         AuthorizedOrgResultWithSub userAdminOrgWithSub = HRPermissionServiceHelper.getUserAdminOrgsWithSub(
                 currUserId, "nckd_pm", PerfManagerFormConstant.PERFMANAGER_ENTITYID,
@@ -92,101 +109,123 @@ public class SalaryAdjOpPlugin extends AbstractOperationServicePlugIn implements
         QueryFieldBuilder perfManagerQueryFieldBuilder = buildPerfManagerQueryFieldBuilder();
         QueryEntityType perfManagerQueryEntityType = (QueryEntityType) EntityMetadataCache.getDataEntityType("nckd_perfmanager_query");
 
-        Map<Long,SalaryAdjustmentResult> salaryAdjustmentResultMap = new HashMap<>();
-        try (AlgoContext context = Algo.newContext()) {
-            // 查询权限范围内的考核周期
-            DataSet queryDataSet = QueryEntityHelper.getInstance().getQueryDataSet(
-                    perfManagerQueryEntityType, perfManagerQueryFieldBuilder.buildSelectLowerCase(),
-                    new QFilter[]{perfManagerFilter}, perfManagerQueryFieldBuilder.buildOrder());
-            queryDataSet.print(true);
-            while (queryDataSet.hasNext()) {
-                Row next = queryDataSet.next();
-                //对应：Personappraisaladminid
-                long id = next.getLong(FormConstant.ID_KEY);
-                long personId = next.getLong(String.join(".", FormConstant.NCKD_PERSON, FormConstant.ID_KEY));
-                LocalDateTime beginDate = DateUtil.toLocalDateTime(next.getDate(PerfManagerFormConstant.NCKD_BEGINYEAR));
-                int beginYear = beginDate.getYear();
-                LocalDateTime endDate = DateUtil.toLocalDateTime(next.getDate(PerfManagerFormConstant.NCKD_ENDYEAR));
-                int endYear = endDate.getYear();
-                Date actEndDate = next.getDate(PerfManagerFormConstant.NCKD_ACTENDYEAR);
-                LocalDateTime actEndLocalDateTime = actEndDate != null ? DateUtil.toLocalDateTime(actEndDate) : endDate;
-                int actEndYear = actEndLocalDateTime.getYear();
-                String theStatus = next.getString(PerfManagerFormConstant.NCKD_THESTATUS);
-                if (actEndYear <= passYear) {
-                    logger.info(">>>周期开始时间在上线前!PASS!!");
-                    continue;
-                }
-                if (theStatus != null && !"1".equals(theStatus)) {
-                    logger.info(">>>周期状态非正常!PASS!!");
-                    continue;
-                }
-                int nowYear = Calendar.getInstance().get(Calendar.YEAR);
-                if (nowYear < beginYear) {
-                    logger.info(">>>还未到周期开始时间!PASS!!");
-                    continue;
-                }
-                //第一年考核结果
-                String firstYearResultNumber = next.getString(String.join(".", PerfManagerFormConstant.NCKD_FIRSTYEARRESULT, FormConstant.NUMBER_KEY));
-                AppraisalResultEnum firstYearResult = AppraisalResultEnum.getByCode(firstYearResultNumber);
-                //第二年考核结果
-                String secondYearResultNumber = next.getString(String.join(".", PerfManagerFormConstant.NCKD_SECONDYEARRESULT, FormConstant.NUMBER_KEY));
-                AppraisalResultEnum secondYearResult = AppraisalResultEnum.getByCode(secondYearResultNumber);
-                //第三年考核结果
-                String thirdYearResultNumber = next.getString(String.join(".", PerfManagerFormConstant.NCKD_THIRDYEARRESULT, FormConstant.NUMBER_KEY));
-                AppraisalResultEnum thirdYearResult = AppraisalResultEnum.getByCode(thirdYearResultNumber);
-                
-                // 计算调薪档次
-                SalaryAdjustmentResult result = calculateSalaryAdjustmentLevel(firstYearResult, secondYearResult, thirdYearResult, beginYear, endYear);
-                logger.info("人员ID: {} 的调薪档次为: {}，调薪类型: {}，调薪说明: {}", personId, result.level, result.type, result.reason);
-                if(result.level > 0){
-                    salaryAdjustmentResultMap.put(personId, result);
+        DynamicObjectCollection perfManagerList = QueryServiceHelper.query(PerfManagerFormConstant.PERFMANAGER_ENTITYID, perfManagerQueryFieldBuilder.buildSelect(), new QFilter[]{perfManagerFilter});
+
+        List<SalaryAdjustmentResult> salaryAdjustmentResultList = new ArrayList<>();
+        for (DynamicObject perfManager : perfManagerList) {
+            long id = perfManager.getLong(FormConstant.ID_KEY);
+            long personId = perfManager.getLong(String.join(".", FormConstant.NCKD_PERSON, FormConstant.ID_KEY));
+            String personName = perfManager.getString(String.join(".", FormConstant.NCKD_PERSON, FormConstant.NAME_KEY));
+            LocalDateTime beginDate = DateUtil.toLocalDateTime(perfManager.getDate(PerfManagerFormConstant.NCKD_BEGINYEAR));
+            int beginYear = beginDate.getYear();
+            LocalDateTime endDate = DateUtil.toLocalDateTime(perfManager.getDate(PerfManagerFormConstant.NCKD_ENDYEAR));
+            int endYear = endDate.getYear();
+            Date actEndDate = perfManager.getDate(PerfManagerFormConstant.NCKD_ACTENDYEAR);
+            LocalDateTime actEndLocalDateTime = actEndDate != null ? DateUtil.toLocalDateTime(actEndDate) : endDate;
+            int actEndYear = actEndLocalDateTime.getYear();
+            String theStatus = perfManager.getString(PerfManagerFormConstant.NCKD_THESTATUS);
+
+
+            if (actEndYear <= passYear) {
+                logger.info(">>>周期开始时间在上线前!PASS!!");
+                continue;
+            }
+            if (theStatus != null && !"1".equals(theStatus)) {
+                logger.info(">>>周期状态非正常!PASS!!");
+                continue;
+            }
+            int nowYear = Calendar.getInstance().get(Calendar.YEAR);
+            if (nowYear < beginYear) {
+                logger.info(">>>还未到周期开始时间!PASS!!");
+                continue;
+            }
+            //第一年考核结果
+            String firstYearResultNumber = perfManager.getString(String.join(".", PerfManagerFormConstant.NCKD_FIRSTYEARRESULT, FormConstant.NUMBER_KEY));
+            AppraisalResultEnum firstYearResult = AppraisalResultEnum.getByCode(firstYearResultNumber);
+            //第二年考核结果
+            String secondYearResultNumber = perfManager.getString(String.join(".", PerfManagerFormConstant.NCKD_SECONDYEARRESULT, FormConstant.NUMBER_KEY));
+            AppraisalResultEnum secondYearResult = AppraisalResultEnum.getByCode(secondYearResultNumber);
+            //第三年考核结果
+            String thirdYearResultNumber = perfManager.getString(String.join(".", PerfManagerFormConstant.NCKD_THIRDYEARRESULT, FormConstant.NUMBER_KEY));
+            AppraisalResultEnum thirdYearResult = AppraisalResultEnum.getByCode(thirdYearResultNumber);
+
+            //校验当前考核周期是否已经在调薪列表中
+            // 计算调薪档次
+            SalaryAdjustmentResult result = calculateSalaryAdjustmentLevel(firstYearResult, secondYearResult, thirdYearResult, beginYear, endYear);
+            logger.info("人员ID: {} 的调薪档次为: {}，调薪类型: {}，调薪说明: {}", personId, result.level, result.type, result.reason);
+            if(result.level != 0){
+                long companyId = perfManager.getLong(String.join(".", FormConstant.NCKD_DEP, FormConstant.NCKD_SECONDORG,FormConstant.ID_KEY));
+                long empPosOrgRelId = perfManager.getLong(String.join(".", FormConstant.NCKD_EMPPOSORGREL,FormConstant.ID_KEY));
+                long depId = perfManager.getLong(String.join(".", FormConstant.NCKD_DEP,FormConstant.ID_KEY));
+                long positionId = perfManager.getLong(String.join(".",FormConstant.NCKD_EMPPOSORGREL, FormConstant.POSITION_KEY,FormConstant.ID_KEY));
+                result.id = id;
+                result.companyId = personId;
+                result.depId = depId;
+                result.positionId = positionId;
+                result.empPosOrgRelId = empPosOrgRelId;
+                result.personId = personId;
+                result.personName = personName;
+                result.beginDate = beginDate;
+                result.endDate = endDate;
+                salaryAdjustmentResultList.add(result);
+            }
+        }
+
+        //判断有没有同一人员存在多条正常状态的考核周期
+        Map<Long, List<SalaryAdjustmentResult>> personGroups = salaryAdjustmentResultList.stream()
+                .collect(Collectors.groupingBy(result -> result.personId));
+        StringJoiner duplicateMsgJoiner = new StringJoiner(StrFormatter.LINE_SEPARATOR);
+        for (Map.Entry<Long, List<SalaryAdjustmentResult>> entry : personGroups.entrySet()) {
+            if (entry.getValue().size() > 1) {
+                // 存在重复的personId
+                SalaryAdjustmentResult firstResult = entry.getValue().get(0);
+                String personName = firstResult.personName;
+                StringJoiner periodJoiner = new StringJoiner("，");
+                for (SalaryAdjustmentResult result : entry.getValue()) {
+                    String period = String.format("%d~%d",
+                            result.beginDate.getYear(),
+                            result.endDate.getYear());
+                    periodJoiner.add(period);
                 }
+                String message = StrFormatter.format("【{}】存在多个状态【正常】的周期；{}",
+                        personName, periodJoiner.toString());
+                duplicateMsgJoiner.add(message);
             }
         }
-//        if(!salaryAdjustmentResultMap.isEmpty()){
-        DynamicObject standardItem = EntityHelper.newEntity(FormConstant.HSBS_STANDARDITEM);
-        standardItem.set(FormConstant.ID_KEY, standardItemId);
-        List<Long> personIds = new ArrayList<>();
-            personIds.add(2311775636290546688L);
-            personIds.add(2313784485549715456L);
-            personIds.add(2313784485549715456L);
-            personIds.add(2313986306029400064L);
-            personIds.add(2313986306029400064L);
-            personIds.add(2313985716754853888L);
-            personIds.add(2313985716754853888L);
-            personIds.add(2324801894234460160L);
-            personIds.add(2321890608861426688L);
-            personIds.add(2321890608861426688L);
-            personIds.add(2324801894234460160L);
-            personIds.add(2311773642125487104L);
-            personIds.add(2311773642125487104L);
-            personIds.add(2311775067064774656L);
-            personIds.add(2311775636290546688L);
-            personIds.add(2311775067064774656L);
-            personIds.add(2329770917598607370L);
-            personIds.add(2330584474036731904L);
-            personIds.add(2329770917598607370L);
-            personIds.add(2329770917598607370L);
-            personIds.add(2330584474036731904L);
-            personIds.add(2330584474036731904L);
-            personIds.add(2313985716754853888L);
-            personIds.add(2313985716754853888L);
-            Map<String, Object> params = new HashMap<>();
-            params.put("employees", personIds);
+        if (duplicateMsgJoiner.length() > 0) {
+            throw new ValidationException(duplicateMsgJoiner.toString());
+        }
+
+        if (!salaryAdjustmentResultList.isEmpty()) {
+            List<Long> allPersonIds = salaryAdjustmentResultList.stream()
+                    .map(result -> result.personId)
+                    .collect(Collectors.toList());
+            List<Long> allEmpPosOrgRelIds = salaryAdjustmentResultList.stream()
+                    .map(result -> result.empPosOrgRelId)
+                    .collect(Collectors.toList());
+
+            DynamicObject standardItem = EntityHelper.newEntity(FormConstant.HSBS_STANDARDITEM);
+            standardItem.set(FormConstant.ID_KEY, standardItemId);
+            Map<String, Object> adjFileParams = new HashMap<>();
+            adjFileParams.put("employees", allPersonIds);
             List<String> status = new ArrayList<>();
             status.add(BillStatus.C.toString());
-            params.put("status", status);
+            adjFileParams.put("status", status);
             //获取人员定薪档案
-            Map<String, Object> result = DispatchServiceHelper.invokeBizService("swc", "hcdm", "IAdjFileInfoService", "queryAdjFileBoByEmp", params);
-            if(ConvertUtil.toBoolean(result.get("success"))){
-                List<Map> list = ConvertUtil.toList(result.get("data"), ArrayList::new);
+            Map<String, Object> adjFileResult = DispatchServiceHelper.invokeBizService("swc", "hcdm", "IAdjFileInfoService", "queryAdjFileBoByEmp", adjFileParams);
+            if (ConvertUtil.toBoolean(adjFileResult.get("success"))) {
+                List<Map> list = ConvertUtil.toList(adjFileResult.get("data"), ArrayList::new);
                 List<Long> adjFileIds = new ArrayList<>();
                 for (Map map : list) {
                     Long id = ConvertUtil.toLong(map.get(FormConstant.ID_KEY));
-                    adjFileIds.add(id);
+                    //根据员工任职匹配
+                    Long empPosOrgRelId = ConvertUtil.toLong(map.get("empposorgrel_id"));
+                    if(allEmpPosOrgRelIds.contains(empPosOrgRelId)) {
+                        adjFileIds.add(id);
+                    }
                 }
-                System.out.println();
-                Map<String, Object> param = new HashMap<>();
+                //构建定调薪记录查询条件
+                Map<String, Object> adjRecordParams = new HashMap<>();
                 List<Map<String, Object>> dataList = new ArrayList<>();
                 for (Long adjFileId : adjFileIds) {
                     Map<String, Object> dataItem = new HashMap<>();
@@ -197,46 +236,273 @@ public class SalaryAdjOpPlugin extends AbstractOperationServicePlugIn implements
                     // 查询基准日期
                     dataItem.put("startdate", new Date());
                     // 唯一标识
-                    dataItem.put("_uniquecode", "unique"+adjFileId);
+                    dataItem.put("_uniquecode", "unique" + adjFileId);
                     dataList.add(dataItem);
                 }
 
-                param.put("data", dataList);
+
+                adjRecordParams.put("data", dataList);
+                adjRecordParams.put("selprops", "salarystdv.rankentry.rank.id,salarystdv.rankentry.rank.name,salarystdv.rankentry.rank.number,salarystdv.rankentry.rank.index,salarystdv.rankentry.frankindex,company.id,company.name,");
                 //查询定调薪记录
-                Map<String, Object> lastDecAdjRecords = HCDMAdjFileServiceHelper.getLastDecAdjRecords(param);
-                if(ConvertUtil.toBoolean(lastDecAdjRecords.get("success"))){
-                    List<Map> datas = ConvertUtil.toList(lastDecAdjRecords.get("data"), ArrayList::new);
+                Map<String, Object> lastDecAdjRecordMap = HCDMAdjFileServiceHelper.getLastDecAdjRecords(adjRecordParams);
+                if (ConvertUtil.toBoolean(lastDecAdjRecordMap.get("success"))) {
+                    List<Map> datas = ConvertUtil.toList(lastDecAdjRecordMap.get("data"), ArrayList::new);
                     for (Map data : datas) {
-                        if(ConvertUtil.toBoolean(data.get("success"))){
+                        if (ConvertUtil.toBoolean(data.get("success"))) {
                             List<DynamicObject> adjRecordList = ConvertUtil.toList(data.get("data"), ArrayList::new);
                             for (DynamicObject dynamicObject : adjRecordList) {
-                                //薪等（01岗、02岗）
-                                DynamicObject salaryGrade = dynamicObject.getDynamicObject("salarygrade");
-                                //薪档（1档、2档）
-                                DynamicObject salaryRank = dynamicObject.getDynamicObject("salaryrank");
+                                DynamicObject company = dynamicObject.getDynamicObject(FormConstant.COMPANY_KEY);
+                                long companyId = company.getLong(FormConstant.ID_KEY);
                                 // 人员
                                 DynamicObject employee = dynamicObject.getDynamicObject("adjfile").getDynamicObject("employee");
-                                //金额
-                                BigDecimal amount = dynamicObject.getBigDecimal("amount");
-                                SalaryAdjustmentResult salaryAdjustmentResult = salaryAdjustmentResultMap.get(employee.getLong(FormConstant.ID_KEY));
-                                salaryAdjustmentResult.oldStandardItem = standardItem;
-                                salaryAdjustmentResult.oldSalaryGrade = salaryGrade;
-                                salaryAdjustmentResult.oldSalaryRank = salaryRank;
-                                salaryAdjustmentResult.oldAmount = amount;
+                                SalaryAdjustmentResult salaryAdjustmentResult = null;
+                                for (SalaryAdjustmentResult result : salaryAdjustmentResultList) {
+                                    if(result.personId == employee.getLong(FormConstant.ID_KEY)){
+                                        salaryAdjustmentResult = result;
+                                    }
+                                }
+                                if(salaryAdjustmentResult != null) {
+                                    //薪酬标准表版本
+                                    DynamicObject salaryStDv = dynamicObject.getDynamicObject("salarystdv");
+                                    //薪等（01岗、02岗）
+                                    DynamicObject salaryGrade = dynamicObject.getDynamicObject("salarygrade");
+                                    //薪档（1档、2档）
+                                    DynamicObject salaryRank = dynamicObject.getDynamicObject("salaryrank");
+                                    //金额
+                                    BigDecimal amount = dynamicObject.getBigDecimal("amount");
+                                    salaryAdjustmentResult.salaryStDv = salaryStDv;
+                                    salaryAdjustmentResult.oldStandardItem = standardItem;
+                                    salaryAdjustmentResult.oldSalaryGrade = salaryGrade;
+                                    salaryAdjustmentResult.oldSalaryRank = salaryRank;
+                                    salaryAdjustmentResult.oldAmount = amount;
+                                }
                             }
                         }
                     }
-                }else{
+                } else {
                     logger.error("查询定调薪记录失败");
-                    throw new ValidationException("查询定调薪记录失败");
+                    this.operationResult.setSuccess(false);
+                    this.operationResult.setMessage("查询定调薪记录失败");
                 }
-            }else{
+            } else {
                 logger.error("获取人员定薪档案失败");
-                throw new ValidationException("获取人员定薪档案失败");
+                this.operationResult.setSuccess(false);
+                this.operationResult.setMessage("获取人员定薪档案失败");
             }
 
 
-//        }
+            Set<Long> salarystandarId = new HashSet(salaryAdjustmentResultList.size());
+            for (SalaryAdjustmentResult result : salaryAdjustmentResultList) {
+                if(result.salaryStDv != null) {
+                    DynamicObject salaryStDv = result.salaryStDv;
+                    long stdTableId = salaryStDv.getLong(FormConstant.ID_KEY);
+                    salarystandarId.add(stdTableId);
+                }
+            }
+            //重新加载薪酬标准表（不然超过三级限制取不到薪档序号）
+            QueryFieldBuilder salaryStandFieldBuilder = QueryFieldBuilder.create()
+                    .add(FormConstant.ID_KEY)
+                    .addIdNumberNameWithExtras(new String[]{"rankentry", "rank", FormConstant.INDEX_KEY});
+            DynamicObject[] salaryStandardArray = BusinessDataServiceHelper.load("hcdm_salarystandard", salaryStandFieldBuilder.buildSelect(), new QFilter[]{new QFilter(FormConstant.ID_KEY, QCP.in, salarystandarId)});
+            Map<Long, DynamicObject> salaryStandardMap = Arrays.stream(salaryStandardArray)
+                    .collect(Collectors.toMap(
+                            obj -> obj.getLong(FormConstant.ID_KEY),
+                            obj -> obj
+                    ));
+
+            StringJoiner msgJoiner = new StringJoiner(StrFormatter.LINE_SEPARATOR);
+            for (SalaryAdjustmentResult result : salaryAdjustmentResultList) {
+                if (result.salaryStDv == null || result.oldStandardItem == null || result.oldSalaryRank == null) {
+                    msgJoiner.add(StrFormatter.format("【{}】没有定调薪档案或没有定薪项目【岗位工资标准】，无法调档", result.personName));
+                } else {
+                    long salaryStDvId = result.salaryStDv.getLong(FormConstant.ID_KEY);
+                    DynamicObject salaryStandard = salaryStandardMap.get(salaryStDvId);
+
+                    //薪酬标准中薪档（薪档名称不等于档差和等差）
+                    DynamicObjectCollection rankEntry = salaryStandard.getDynamicObjectCollection("rankentry");
+                    Map<Integer, DynamicObject> rankMap = rankEntry.stream().filter(rank -> !rank.getDynamicObject("rank").getString(FormConstant.NAME_KEY).contains("差"))
+                            .collect(Collectors.toMap(
+                                    rank -> rank.getDynamicObject("rank").getInt(FormConstant.INDEX_KEY),
+                                    rank -> rank.getDynamicObject("rank"),
+                                    (existing, replacement) -> replacement // 处理重复键，保留后来的值
+                            ));
+                    Optional<DynamicObject> diffRecord = rankEntry.stream()
+                            .filter(rank -> rank.getDynamicObject("rank").getString(FormConstant.NAME_KEY).contains("档差"))
+                            .findFirst();
+
+                    DynamicObject diffRank = null;
+                    if (diffRecord.isPresent()) {
+                        diffRank = diffRecord.get().getDynamicObject("rank");
+                    }
+                    if (!rankMap.isEmpty()) {
+                        //原薪档
+                        DynamicObject oldSalaryRank = result.oldSalaryRank;
+                        int oldIndex = oldSalaryRank.getInt(FormConstant.INDEX_KEY);
+                        //调整后薪档序号
+                        int finalRankIndex = oldIndex + result.level;
+                        DynamicObject newSalaryRank;
+                        //判断是否超过薪档的最大序号或最小序号，如果超过则取最小或最大
+                        int maxRankIndex = Collections.max(rankMap.keySet());
+                        int minRankIndex = Collections.min(rankMap.keySet());
+                        if (finalRankIndex > maxRankIndex) {
+                            // 超过最大值，取最大值
+                            newSalaryRank = rankMap.get(maxRankIndex);
+                        } else if (finalRankIndex < minRankIndex) {
+                            // 低于最小值，取最小值
+                            newSalaryRank = rankMap.get(minRankIndex);
+                        }else{
+                            newSalaryRank = rankMap.get(finalRankIndex);
+                        }
+                        result.salaryRank = newSalaryRank;
+                        result.reason+=StrFormatter.format("；{}->{}",oldSalaryRank.getString(FormConstant.NAME_KEY),newSalaryRank.getString(FormConstant.NAME_KEY));
+                        List<StdTableDataMatchParam> matchParams = new ArrayList<>();
+                        StdTableDataMatchParam stdTableDataMatchParam = new StdTableDataMatchParam();
+                        stdTableDataMatchParam.setStdTableId(result.salaryStDv.getLong(FormConstant.ID_KEY));
+                        stdTableDataMatchParam.setStdItemId(standardItemId);
+                        stdTableDataMatchParam.setGradeId(result.oldSalaryGrade.getLong(FormConstant.ID_KEY));
+                        stdTableDataMatchParam.setRankId(newSalaryRank.getLong(FormConstant.ID_KEY));
+                        matchParams.add(stdTableDataMatchParam);
+                        //获取薪酬项目、薪等、薪档对应金额
+                        List<StdTableDataMatchResult> stdTableDataMatchResults = HCDMSalaryStdServiceHelper.matchStdTableData(matchParams);
+                        if(!stdTableDataMatchResults.isEmpty()){
+                            result.amount = stdTableDataMatchResults.get(0).getAmount();
+                        }
+                        msgJoiner.add(StrFormatter.format("【{}】{}", result.personName, result.reason));
+                    }
+                }
+            }
+            List<DynamicObject> addSalAdjTrackerList = new ArrayList<>();
+            List<Long> ids = new ArrayList<>(salaryAdjustmentResultList.size());
+            List<Long> createOrgList = BaseDataServiceHelper.getCreateOrgList(SalAdjTrackerConstant.SALADJTRACKER_ENTITYID);
+            MainEntityType bosOrgEntityType = EntityMetadataCache.getDataEntityType(AdminOrgHelper.BOS_ORG);
+            DynamicObject org = new DynamicObject(bosOrgEntityType);
+            if (!createOrgList.isEmpty()) {
+                org.set(FormConstant.ID_KEY, createOrgList.get(0));
+            }
+            for (SalaryAdjustmentResult result : salaryAdjustmentResultList) {
+                if (result.salaryStDv != null && result.oldStandardItem != null && result.oldSalaryRank != null) {
+                    DynamicObject newSalAdjTracker = EntityHelper.newEntity(SalAdjTrackerConstant.SALADJTRACKER_ENTITYID);
+                    newSalAdjTracker.set(FormConstant.CREATEORG_KEY, org);
+                    newSalAdjTracker.set(FormConstant.CTRLSTRATEGY_KEY, CtrlStrategyEnum.GLOBAL_SHARE.getCtrlStrategy());
+                    newSalAdjTracker.set(FormConstant.NAME_KEY,StrFormatter.format("{}的调薪", result.personName));
+                    newSalAdjTracker.set(SalAdjTrackerConstant.NCKD_PERFMANAGER,EntityHelper.newEntity(PerfManagerFormConstant.PERFMANAGER_ENTITYID, result.id));
+                    newSalAdjTracker.set(SalAdjTrackerConstant.NCKD_OLDSALARYGRADE, result.oldSalaryGrade);
+                    newSalAdjTracker.set(SalAdjTrackerConstant.NCKD_OLDSALARYRANK, result.oldSalaryRank);
+                    newSalAdjTracker.set(SalAdjTrackerConstant.NCKD_OLDMONEY, result.oldAmount);
+                    newSalAdjTracker.set(SalAdjTrackerConstant.NCKD_SALARYGRADE, result.oldSalaryGrade);
+                    newSalAdjTracker.set(SalAdjTrackerConstant.NCKD_SALARYRANK, result.salaryRank);
+                    newSalAdjTracker.set(SalAdjTrackerConstant.NCKD_MONEY, result.amount);
+                    newSalAdjTracker.set(SalAdjTrackerConstant.NCKD_WAGEEXPLAIN, result.reason);
+                    newSalAdjTracker.set(SalAdjTrackerConstant.NCKD_APPRAISALTYPE, result.type);
+                    newSalAdjTracker.set(SalAdjTrackerConstant.NCKD_WAGESTATUS,"1");
+                    newSalAdjTracker.set(SalAdjTrackerConstant.NCKD_OLDSTANDARDITEM, result.oldStandardItem);
+                    newSalAdjTracker.set(SalAdjTrackerConstant.NCKD_STANDARDITEM, result.oldStandardItem);
+                    newSalAdjTracker.set(SalAdjTrackerConstant.NCKD_ADJMONEY, result.amount.subtract(result.oldAmount));
+                    newSalAdjTracker.set(SalAdjTrackerConstant.NCKD_DEP,EntityHelper.newEntity(FormConstant.ADMINORGHR_ENTITYID, result.depId));
+                    newSalAdjTracker.set(SalAdjTrackerConstant.NCKD_POSITION,EntityHelper.newEntity(PerfManagerFormConstant.HBPM_POSITIONHR, result.positionId));
+                    ids.add(result.id);
+                    addSalAdjTrackerList.add(newSalAdjTracker);
+                }
+            }
+            MainEntityType dataEntityType = MetadataServiceHelper.getDataEntityType(PerfManagerFormConstant.PERFMANAGER_ENTITYID);
+            DynamicObject[] perfManagerArray = BusinessDataServiceHelper.load(ids.toArray(new Long[0]), dataEntityType);
+            List<DynamicObject> addPerfManagerList = new ArrayList<>();
+            for (DynamicObject perfManager : perfManagerArray) {
+                perfManager.set(PerfManagerFormConstant.NCKD_WHYEND,"调档后结束");
+                perfManager.set(PerfManagerFormConstant.NCKD_THESTATUS,"2");
+                perfManager.set(PerfManagerFormConstant.NCKD_LOCKUSER,currUser);
+                LocalDateTime beginDate = DateUtil.toLocalDateTime(perfManager.getDate(PerfManagerFormConstant.NCKD_BEGINYEAR));
+                LocalDateTime endDate = DateUtil.toLocalDateTime(perfManager.getDate(PerfManagerFormConstant.NCKD_ENDYEAR));
+                //第一年考核结果
+                String firstYearResultNumber = null;
+                DynamicObject firstYearResultObj = perfManager.getDynamicObject(PerfManagerFormConstant.NCKD_FIRSTYEARRESULT);
+                if (firstYearResultObj != null) {
+                    firstYearResultNumber = firstYearResultObj.getString(FormConstant.NUMBER_KEY);
+                }
+                AppraisalResultEnum firstYearResult = AppraisalResultEnum.getByCode(firstYearResultNumber);
+                //第二年考核结果
+                String secondYearResultNumber = null;
+                DynamicObject secondYearResultObj = perfManager.getDynamicObject(PerfManagerFormConstant.NCKD_SECONDYEARRESULT);
+                if (secondYearResultObj != null) {
+                    secondYearResultNumber = secondYearResultObj.getString(FormConstant.NUMBER_KEY);
+                }
+                AppraisalResultEnum secondYearResult = AppraisalResultEnum.getByCode(secondYearResultNumber);
+                //第三年考核结果
+                String thirdYearResultNumber = null;
+                DynamicObject thirdYearResultObj = perfManager.getDynamicObject(PerfManagerFormConstant.NCKD_THIRDYEARRESULT);
+                if (thirdYearResultObj != null) {
+                    thirdYearResultNumber = thirdYearResultObj.getString(FormConstant.NUMBER_KEY);
+                }
+                AppraisalResultEnum thirdYearResult = AppraisalResultEnum.getByCode(thirdYearResultNumber);
+
+                LocalDateTime actEndYear = null;
+                if(isAppraisalResult(firstYearResult) && isAppraisalResult(secondYearResult) && !isAppraisalResult(thirdYearResult)){
+                    actEndYear = DateUtil.minusYears(endDate,1);
+                }else{
+                    actEndYear = endDate;
+                }
+                perfManager.set(PerfManagerFormConstant.NCKD_ACTENDYEAR,DateUtil.toDate(actEndYear));
+
+                DynamicObject newPerfManager = EntityHelper.newEntity(PerfManagerFormConstant.PERFMANAGER_ENTITYID);
+                DynamicObject person = perfManager.getDynamicObject(FormConstant.NCKD_PERSON);
+                String personName = person.getString(FormConstant.NAME_KEY);
+                newPerfManager.set(FormConstant.CREATEORG_KEY, perfManager.get(FormConstant.CREATEORG_KEY));
+                newPerfManager.set(FormConstant.NCKD_EMPPOSORGREL, perfManager.getDynamicObject(FormConstant.NCKD_EMPPOSORGREL));
+                newPerfManager.set(FormConstant.NCKD_DEP, perfManager.getDynamicObject(FormConstant.NCKD_DEP));
+                newPerfManager.set(FormConstant.NCKD_PERSON, person);
+                LocalDateTime newBeginDate = DateUtil.addYears(actEndYear, 1);
+                LocalDateTime newEndDate = DateUtil.addYears(actEndYear, 3);
+                newPerfManager.set(PerfManagerFormConstant.NCKD_BEGINYEAR, DateUtil.toDate(newBeginDate));
+                newPerfManager.set(PerfManagerFormConstant.NCKD_ENDYEAR, DateUtil.toDate(newEndDate));
+                newPerfManager.set(PerfManagerFormConstant.DESCRIPTION_KEY, "调档后生成新周期");
+                newPerfManager.set(PerfManagerFormConstant.CTRLSTRATEGY_KEY, CtrlStrategyEnum.GLOBAL_SHARE.getCtrlStrategy());
+                newPerfManager.set(FormConstant.NAME_KEY, StrFormatter.format("【{}】{}~{}的考核周期",personName,newBeginDate.getYear(),newEndDate.getYear()));
+                addPerfManagerList.add(newPerfManager);
+            }
+            OperateOption option = OperateOption.create();
+            option.setVariableValue(OperateOptionConst.IGNOREINTERACTION, Boolean.TRUE+"");
+            option.setVariableValue("isUpdate", Boolean.TRUE+"");
+            OperationResult operationResult = SaveServiceHelper.saveOperate(FormConstant.SAVE_OP, PerfManagerFormConstant.PERFMANAGER_ENTITYID, perfManagerArray, option);
+            if (!operationResult.isSuccess()) {
+                StringJoiner errorMsgJoiner = new StringJoiner(StrFormatter.LINE_SEPARATOR);
+                for (IOperateInfo error : operationResult.getAllErrorOrValidateInfo()) {
+                    errorMsgJoiner.add(error.getMessage());
+                }
+                String errorMsg = errorMsgJoiner.toString();
+                if(StringUtils.isBlank(errorMsg)){
+                    errorMsg = operationResult.getMessage();
+                }
+                throw new ValidationException("保存考核周期失败，原因："+errorMsg);
+            }else{
+                OperateOption addPerfManagerOption = OperateOption.create();
+                addPerfManagerOption.setVariableValue(OperateOptionConst.IGNOREINTERACTION, Boolean.TRUE + "");
+                addPerfManagerOption.setVariableValue("cyclegenerate", Boolean.TRUE + "");
+                OperationResult addPerfManagerResult = SaveServiceHelper.saveOperate(FormConstant.SAVE_OP, PerfManagerFormConstant.PERFMANAGER_ENTITYID, addPerfManagerList.toArray(new DynamicObject[0]), addPerfManagerOption);
+
+                if (!addPerfManagerResult.isSuccess()) {
+                    StringJoiner errorMsg = new StringJoiner(StrFormatter.LINE_SEPARATOR);
+                    for (IOperateInfo error : addPerfManagerResult.getAllErrorOrValidateInfo()) {
+                        errorMsg.add(error.getMessage());
+                    }
+                    throw new ValidationException(errorMsg.toString());
+                }else{
+                    OperationResult salAdjTrackerResult = SaveServiceHelper.saveOperate(FormConstant.SAVE_OP, SalAdjTrackerConstant.SALADJTRACKER_ENTITYID, addSalAdjTrackerList.toArray(new DynamicObject[0]), OperateOption.create());
+                    if (!salAdjTrackerResult.isSuccess()) {
+                        StringJoiner errorMsgJoiner = new StringJoiner(StrFormatter.LINE_SEPARATOR);
+                        for (IOperateInfo error : salAdjTrackerResult.getAllErrorOrValidateInfo()) {
+                            errorMsgJoiner.add(error.getMessage());
+                        }
+                        String errorMsg = errorMsgJoiner.toString();
+                        if(StringUtils.isBlank(errorMsg)){
+                            errorMsg = salAdjTrackerResult.getMessage();
+                        }
+                        throw new ValidationException("保存调薪情况失败，原因："+errorMsg);
+                    }
+                }
+            }
+            this.operationResult.setSuccess(true);
+            this.operationResult.setMessage(msgJoiner.toString());
+        }
 
     }
 
@@ -263,9 +529,9 @@ public class SalaryAdjOpPlugin extends AbstractOperationServicePlugIn implements
 
 
         // 判断各年份是否存在并获取相应值
-        boolean isFirstYearPresent = isFirstYearPresent(firstYear);
-        boolean isSecondYearPresent = isSecondYearPresent(secondYear);
-        boolean isThirdYearPresent = isThirdYearPresent(thirdYear);
+        boolean isFirstYearPresent = isAppraisalResult(firstYear);
+        boolean isSecondYearPresent = isAppraisalResult(secondYear);
+        boolean isThirdYearPresent = isAppraisalResult(thirdYear);
 
         // 判断是否为优秀（包括视同优秀）
         boolean isFirstYearExcellent = isFirstYearPresent && EXCELLENT_LEVELS.contains(firstYear);
@@ -342,22 +608,8 @@ public class SalaryAdjOpPlugin extends AbstractOperationServicePlugIn implements
     /**
      * 检查第一年考核结果是否存在
      */
-    private boolean isFirstYearPresent(AppraisalResultEnum firstYear) {
-        return firstYear != null;
-    }
-
-    /**
-     * 检查第二年考核结果是否存在
-     */
-    private boolean isSecondYearPresent(AppraisalResultEnum secondYear) {
-        return secondYear != null;
-    }
-
-    /**
-     * 检查第三年考核结果是否存在
-     */
-    private boolean isThirdYearPresent(AppraisalResultEnum thirdYear) {
-        return thirdYear != null;
+    private boolean isAppraisalResult(AppraisalResultEnum appraisalResult) {
+        return appraisalResult != null;
     }
 
 
@@ -368,11 +620,9 @@ public class SalaryAdjOpPlugin extends AbstractOperationServicePlugIn implements
         QFilter perfManagerFilter = QFilter.of("1=1");
         if (!userAdminOrgWithSub.isHasAllOrgPerm()) {
             List<Long> orgIds = extractOrgIds(userAdminOrgWithSub.getHasPermOrgsWithSub());
-            perfManagerFilter.and(String.join(".", FormConstant.HRPI_EMPPOSORGREL, FormConstant.ADMINORG), QCP.in, orgIds);
+            perfManagerFilter.and(String.join(".", FormConstant.NCKD_EMPPOSORGREL, FormConstant.ADMINORG), QCP.in, orgIds);
         }
-        perfManagerFilter.and(String.join(".", FormConstant.HRPI_EMPPOSORGREL, FormConstant.IS_SEQLATESTRECORD), QCP.equals, EnableEnum.YES.getCode());
         perfManagerFilter.and(PerfManagerFormConstant.NCKD_THESTATUS, QCP.equals, EnableEnum.YES.getCode());
-        perfManagerFilter.and(PerfManagerFormConstant.NCKD_PERSON, QCP.equals, "2348152690355230726");
         return perfManagerFilter;
     }
 
@@ -388,6 +638,10 @@ public class SalaryAdjOpPlugin extends AbstractOperationServicePlugIn implements
                 .add(PerfManagerFormConstant.NCKD_ACTENDYEAR)
                 .add(PerfManagerFormConstant.NCKD_THESTATUS)
                 .addIdNumberName(FormConstant.NCKD_PERSON)
+                .addGroup(new String[]{FormConstant.NCKD_EMPPOSORGREL},FormConstant.ID_KEY)
+                .addIdNumberName(FormConstant.NCKD_DEP)
+                .addIdNumberName(FormConstant.NCKD_EMPPOSORGREL,FormConstant.POSITION_KEY)
+                .addIdNumberName(FormConstant.NCKD_DEP,FormConstant.NCKD_SECONDORG)
                 .addIdNumberName(PerfManagerFormConstant.NCKD_FIRSTYEARRESULT)
                 .addIdNumberName(PerfManagerFormConstant.NCKD_SECONDYEARRESULT)
                 .addIdNumberName(PerfManagerFormConstant.NCKD_THIRDYEARRESULT);
@@ -401,15 +655,33 @@ public class SalaryAdjOpPlugin extends AbstractOperationServicePlugIn implements
                 .collect(Collectors.toList());
     }
 
-    
+
     // 调薪结果类
     class SalaryAdjustmentResult {
+        /**id*/
+        long id;
+        /** 人员ID*/
+        long personId;
+        /** 人员姓名*/
+        String personName;
+        //所属公司ID
+        long companyId;
+        //所属部门
+        long depId;
+        //所属部门
+        long positionId;
+        //任职经历
+        long empPosOrgRelId;
+        LocalDateTime beginDate;
+        LocalDateTime endDate;
         /** 调薪类型*/
         int type;
         /** 调薪档次*/
         int level;
         /** 调薪原因*/
         String reason;
+        /**薪酬标准表*/
+        DynamicObject salaryStDv;
         /** 原定调薪项目 */
         DynamicObject oldStandardItem;
         /** 原薪等（01岗、02岗）*/
@@ -418,15 +690,11 @@ public class SalaryAdjOpPlugin extends AbstractOperationServicePlugIn implements
         DynamicObject oldSalaryRank;
         //金额
         BigDecimal oldAmount;
-        /** 定调薪项目 */
-        DynamicObject standardItem;
-        /** 薪等（01岗、02岗）*/
-        DynamicObject salaryGrade;
         /** 薪档（1档、2档）*/
         DynamicObject salaryRank;
         //金额
         BigDecimal amount;
-        
+
         SalaryAdjustmentResult(int type, int level, String reason) {
             this.type = type;
             this.level = level;