Merge branch 'refs/heads/feat-opmc-pm_1.0'

code/opmc/nckd-jxccl-opmc/src/main/java/nckd/jxccl/opmc/pm/helper/PerfManagerHelper.java

@@ -143,6 +143,48 @@ public class PerfManagerHelper {
         return BusinessDataServiceHelper.load(PerfManagerFormConstant.PERFMANAGER_ENTITYID,
                 queryFieldBuilder.buildSelect(), new QFilter[]{filter});
     }
+    
+    /**
+     * 批量查询不同人员在各自指定日期前的考核周期
+     *
+     * @param personDateMap 人员ID与日期的映射关系
+     * @param otherFilter   其他过滤条件
+     * @return 符合条件的考核周期数组
+     */
+    public static DynamicObject[] getBeforeBeginYear(Map<Long, Date> personDateMap, QFilter otherFilter) {
+        if (personDateMap == null || personDateMap.isEmpty()) {
+            return new DynamicObject[0];
+        }
+
+        QueryFieldBuilder queryFieldBuilder = createDefaultQueryFieldBuilder();
+
+        // 构建OR条件查询不同人员的不同日期
+        QFilter orFilter = null;
+        for (Map.Entry<Long, Date> entry : personDateMap.entrySet()) {
+            Long personId = entry.getKey();
+            Date beginYear = entry.getValue();
+            
+            // 为每个人员构建独立的查询条件
+            QFilter personFilter = new QFilter(PerfManagerFormConstant.NCKD_BEGINYEAR, QCP.less_equals, beginYear)
+                    .and(new QFilter(PerfManagerFormConstant.NCKD_THESTATUS, QCP.equals, EnableEnum.YES.getCode()))
+                    .and(new QFilter(PerfManagerFormConstant.NCKD_PERSON, QCP.equals, personId));
+            
+            // 使用OR连接所有人员的条件
+            if (orFilter == null) {
+                orFilter = personFilter;
+            } else {
+                orFilter = orFilter.or(personFilter);
+            }
+        }
+
+        QFilter finalFilter = orFilter;
+        if (otherFilter != null) {
+            finalFilter.and(otherFilter);
+        }
+
+        return BusinessDataServiceHelper.load(PerfManagerFormConstant.PERFMANAGER_ENTITYID,
+                queryFieldBuilder.buildSelect(), new QFilter[]{finalFilter});
+    }
 
     /**
      * 根据人员获取当前最新的考核周期

code/opmc/nckd-jxccl-opmc/src/main/java/nckd/jxccl/opmc/pm/plugin/form/cycle/PerfManagerListPlugin.java

@@ -3,31 +3,43 @@ package nckd.jxccl.opmc.pm.plugin.form.cycle;
 import kd.bos.dataentity.OperateOption;
 import kd.bos.dataentity.entity.DynamicObject;
 import kd.bos.dataentity.entity.DynamicObjectCollection;
+import kd.bos.dataentity.entity.LocaleString;
+import kd.bos.entity.datamodel.IListModel;
 import kd.bos.entity.datamodel.ListSelectedRowCollection;
 import kd.bos.entity.datamodel.events.PackageDataEvent;
 import kd.bos.entity.operate.OperateOptionConst;
 import kd.bos.entity.operate.result.OperationResult;
-import kd.bos.form.CloseCallBack;
-import kd.bos.form.FormShowParameter;
-import kd.bos.form.MessageBoxOptions;
-import kd.bos.form.ShowType;
-import kd.bos.form.StyleCss;
+import kd.bos.form.*;
 import kd.bos.form.control.events.ItemClickEvent;
 import kd.bos.form.events.AfterDoOperationEventArgs;
+import kd.bos.form.events.BeforeCreateListColumnsArgs;
 import kd.bos.form.events.BeforeCreateListDataProviderArgs;
 import kd.bos.form.events.BeforeDoOperationEventArgs;
 import kd.bos.form.operate.FormOperate;
+import kd.bos.list.IListColumn;
+import kd.bos.list.IListView;
+import kd.bos.list.ListColumn;
 import kd.bos.list.plugin.AbstractListPlugin;
 import kd.bos.mvc.list.ListDataProvider;
+import kd.bos.mvc.list.QueryBuilderFactory;
+import kd.bos.orm.query.QCP;
+import kd.bos.orm.query.QFilter;
+import kd.bos.servicehelper.QueryServiceHelper;
 import kd.bos.servicehelper.operation.OperationServiceHelper;
+import kd.sdk.hr.haos.business.helper.HAOSServiceHelper;
 import kd.sdk.plugin.Plugin;
 import nckd.jxccl.base.common.constant.FormConstant;
 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.entity.helper.EntityHelper;
 import nckd.jxccl.opmc.pm.common.PerfManagerFormConstant;
 
+import java.util.EventObject;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 /**
@@ -53,18 +65,58 @@ public class PerfManagerListPlugin extends AbstractListPlugin implements Plugin
         }
     }
 
+
+    @Override
+    public void packageData(PackageDataEvent e) {
+        if(!adminOrgIds.isEmpty()){
+            QueryFieldBuilder queryFieldBuilder = QueryFieldBuilder.create()
+                    .addIdNumberName(FormConstant.NCKD_FIRSTORG)
+                    .addIdNumberName(FormConstant.NCKD_SECONDORG)
+                    .addIdNumberName(FormConstant.NCKD_THIRDORG)
+                    .addIdNumberName(FormConstant.NCKD_FOURTHORG)
+                    .addIdNumberName(FormConstant.NCKD_FIFTHORG)
+                    .addIdNumberName(FormConstant.NCKD_SIXTHORG);
+            QFilter qFilter = new QFilter(FormConstant.ID_KEY, QCP.in, adminOrgIds);
+            DynamicObject dynamicObject = QueryServiceHelper.queryOne(FormConstant.ADMINORGHR_ENTITYID, queryFieldBuilder.buildSelect(), new QFilter[]{qFilter});
+            String colKey = e.getColKey();
+            int year = DateUtil.now().getYear();
+
+            if (FormConstant.NCKD_FIRSTORG.equalsIgnoreCase(colKey)) {
+                e.setFormatValue(dynamicObject.getString(String.join(".", FormConstant.NCKD_FIRSTORG, FormConstant.NAME_KEY)));
+            } else if (FormConstant.NCKD_SECONDORG.equalsIgnoreCase(colKey)) {
+                e.setFormatValue(dynamicObject.getString(String.join(".", FormConstant.NCKD_SECONDORG, FormConstant.NAME_KEY)));
+            } else if (FormConstant.NCKD_THIRDORG.equalsIgnoreCase(colKey)) {
+                e.setFormatValue(dynamicObject.getString(String.join(".", FormConstant.NCKD_THIRDORG, FormConstant.NAME_KEY)));
+            } else if (FormConstant.NCKD_FOURTHORG.equalsIgnoreCase(colKey)) {
+                e.setFormatValue(dynamicObject.getString(String.join(".", FormConstant.NCKD_FOURTHORG, FormConstant.NAME_KEY)));
+            } else if (FormConstant.NCKD_FIFTHORG.equalsIgnoreCase(colKey)) {
+                e.setFormatValue(dynamicObject.getString(String.join(".", FormConstant.NCKD_FIFTHORG, FormConstant.NAME_KEY)));
+            } else if (FormConstant.NCKD_SIXTHORG.equalsIgnoreCase(colKey)) {
+                e.setFormatValue(dynamicObject.getString(String.join(".", FormConstant.NCKD_SIXTHORG, FormConstant.NAME_KEY)));
+            }
+        }
+
+    }
+
+    Set<Long> adminOrgIds = new HashSet<>();
     @Override
     public void beforeCreateListDataProvider(BeforeCreateListDataProviderArgs args) {
         args.setListDataProvider(new ListDataProvider() {
             @Override
             public DynamicObjectCollection getData(int start, int size) {
                 DynamicObjectCollection rows = super.getData(start, size);
-
-                // 为动态列设置值
+                IPageCache pageCache = getView().getPageCache();
                 for (DynamicObject row : rows) {
-                    DynamicObject adminOrg = row.getDynamicObject(FormConstant.NCKD_EMPPOSORGREL).getDynamicObject(FormConstant.ADMINORG);
+                    if(row.containsProperty(FormConstant.NCKD_EMPPOSORGREL)){
+                        DynamicObject empPosOrgRel = row.getDynamicObject(FormConstant.NCKD_EMPPOSORGREL);
+                        if(empPosOrgRel != null){
+                            DynamicObject adminOrg = empPosOrgRel.getDynamicObject(FormConstant.ADMINORG);
+                            if(adminOrg != null) {
+                                adminOrgIds.add(adminOrg.getLong(FormConstant.ID_KEY));
+                            }
+                        }
+                    }
                 }
-
                 return rows;
             }
         });

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

@@ -32,15 +32,7 @@ import nckd.jxccl.opmc.pm.helper.PerfManagerHelper;
 import org.apache.commons.lang3.StringUtils;
 
 import java.time.LocalDateTime;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.StringJoiner;
+import java.util.*;
 import java.util.stream.Collectors;
 
 /**
@@ -65,6 +57,7 @@ public class PerfManagerSaveOpPlugin extends AbstractOperationServicePlugIn impl
         e.addValidator(new AbstractValidator() {
             @Override
             public void validate() {
+                Boolean isCycleGenerate = ConvertUtil.toBoolean(this.getOption().getVariableValue("cyclegenerate",StringUtils.EMPTY),Boolean.FALSE);
                 //第一个循环先获取表单数据，这里需要兼容单人和批量的数据包
                 Map<Long, List<PersonPerfInfo>> currentBatchData = new HashMap<>();
                 for (ExtendedDataEntity rowDataEntity : getDataEntities()) {
@@ -94,33 +87,34 @@ public class PerfManagerSaveOpPlugin extends AbstractOperationServicePlugIn impl
 
                     currentBatchData.computeIfAbsent(personId, k -> new ArrayList<>()).add(perfInfo);
                 }
-
-                //检查同一批次内同一人员的周期重叠
-                for (Map.Entry<Long, List<PersonPerfInfo>> entry : currentBatchData.entrySet()) {
-                    List<PersonPerfInfo> personPerfList = entry.getValue();
-                    if (personPerfList.size() > 1) {
-                        // 对同一人员的多个周期进行相互比较
-                        for (int i = 0; i < personPerfList.size(); i++) {
-                            PersonPerfInfo info1 = personPerfList.get(i);
-                            for (int j = i + 1; j < personPerfList.size(); j++) {
-                                PersonPerfInfo info2 = personPerfList.get(j);
-                                String personName = info2.getPerson().getString(FormConstant.NAME_KEY);
-
-                                // 检查开始年份是否相同
-                                if (isSameYear(info1.getBeginYear(), info2.getBeginYear())) {
-                                    addFatalErrorMessage(getDataEntities()[info1.getDataEntityIndex()],
-                                            StrFormatter.format("同批次数据中，人员【{}】存在相同的周期开始年份：{}",
-                                                    personName,info1.getBeginYear().getYear()));
-                                } else {
-                                    // 只有开始年份不相同时才检查重叠
-                                    // 检查周期是否重叠
-                                    String overlapInfo = getCycleOverlapInfo(
-                                            info1.getBeginYear(), info1.getEndYear(), null,
-                                            info2.getBeginYear(), info2.getEndYear(), null);
-
-                                    if (StringUtils.isNotBlank(overlapInfo)) {
+                if(!isCycleGenerate) {
+                    //检查同一批次内同一人员的周期重叠
+                    for (Map.Entry<Long, List<PersonPerfInfo>> entry : currentBatchData.entrySet()) {
+                        List<PersonPerfInfo> personPerfList = entry.getValue();
+                        if (personPerfList.size() > 1) {
+                            // 对同一人员的多个周期进行相互比较
+                            for (int i = 0; i < personPerfList.size(); i++) {
+                                PersonPerfInfo info1 = personPerfList.get(i);
+                                for (int j = i + 1; j < personPerfList.size(); j++) {
+                                    PersonPerfInfo info2 = personPerfList.get(j);
+                                    String personName = info2.getPerson().getString(FormConstant.NAME_KEY);
+
+                                    // 检查开始年份是否相同
+                                    if (isSameYear(info1.getBeginYear(), info2.getBeginYear())) {
                                         addFatalErrorMessage(getDataEntities()[info1.getDataEntityIndex()],
-                                                StrFormatter.format("同批次数据中，人员【{}】存在重叠周期：{}",personName ,overlapInfo));
+                                                StrFormatter.format("同批次数据中，人员【{}】存在相同的周期开始年份：{}",
+                                                        personName, info1.getBeginYear().getYear()));
+                                    } else {
+                                        // 只有开始年份不相同时才检查重叠
+                                        // 检查周期是否重叠
+                                        String overlapInfo = getCycleOverlapInfo(
+                                                info1.getBeginYear(), info1.getEndYear(), null,
+                                                info2.getBeginYear(), info2.getEndYear(), null);
+
+                                        if (StringUtils.isNotBlank(overlapInfo)) {
+                                            addFatalErrorMessage(getDataEntities()[info1.getDataEntityIndex()],
+                                                    StrFormatter.format("同批次数据中，人员【{}】存在重叠周期：{}", personName, overlapInfo));
+                                        }
                                     }
                                 }
                             }
@@ -172,12 +166,14 @@ public class PerfManagerSaveOpPlugin extends AbstractOperationServicePlugIn impl
                         Date actEndYear = dynamicObject.getDate(PerfManagerFormConstant.NCKD_ACTENDYEAR);
                         LocalDateTime dbActEndYear = actEndYear != null ? DateUtil.toLocalDateTime(actEndYear) : null;
 
-                        // 判断周期是否重叠并获取重叠信息，已结束周期使用实际结束时间
-                        String overlapInfo = getCycleOverlapInfo(beginYear, endYear, null, dbBeginYear, dbEndYear, dbActEndYear);
-                        if (StringUtils.isNotBlank(overlapInfo)) {
-                            addFatalErrorMessage(rowDataEntity,
-                                    StrFormatter.format("人员【{}】的考核周期与已有周期在{}重叠，请检查！",
-                                            personName, overlapInfo));
+                        if(!isCycleGenerate) {
+                            // 判断周期是否重叠并获取重叠信息，已结束周期使用实际结束时间
+                            String overlapInfo = getCycleOverlapInfo(beginYear, endYear, null, dbBeginYear, dbEndYear, dbActEndYear);
+                            if (StringUtils.isNotBlank(overlapInfo)) {
+                                addFatalErrorMessage(rowDataEntity,
+                                        StrFormatter.format("人员【{}】的考核周期与已有周期在{}重叠，请检查！",
+                                                personName, overlapInfo));
+                            }
                         }
 
                         //判断beginYear和dbBeginYear的年份是否相同
@@ -187,6 +183,7 @@ public class PerfManagerSaveOpPlugin extends AbstractOperationServicePlugIn impl
                                             personName,
                                             beginYear.getYear()));
                         }
+
                         //当前周期必须大于之前周期的开始时间
                         /*if (beginYear != null && beginYear.isBefore(dbBeginYear)) {
                             addFatalErrorMessage(rowDataEntity,
@@ -484,9 +481,23 @@ public class PerfManagerSaveOpPlugin extends AbstractOperationServicePlugIn impl
         PerfManagerHelper.markAsCurrentNewest(personBeginYearMap.keySet(),null);
 
         //上一周期标记为“已结束”并设置“实际结束时间” begin
+        Set<Long> personIds = new HashSet<>();
+        for (DynamicObject dataEntity : e.getDataEntities()) {
+            DynamicObject person = dataEntity.getDynamicObject(FormConstant.NCKD_PERSON);
+            person = person == null ? dataEntity.getDynamicObject(FormConstant.NCKD_EMPPOSORGREL).getDynamicObject(FormConstant.EMPLOYEE_KEY) : person;
+            long personId = person.getLong(FormConstant.ID_KEY);
+            personIds.add(personId);
+        }
+
+
         Boolean isCycleGenerate = ConvertUtil.toBoolean(this.getOption().getVariableValue("cyclegenerate",StringUtils.EMPTY),Boolean.FALSE);
         Boolean isUpdate = ConvertUtil.toBoolean(this.getOption().getVariableValue("isUpdate",StringUtils.EMPTY),Boolean.FALSE);
+        DynamicObject[] beforeBeginYearList = null;
+        if(!isUpdate){
+            beforeBeginYearList = PerfManagerHelper.getByPersonId(personIds, null);
+        }
         List<DynamicObject> updatePerManager = new ArrayList<>();
+        List<DynamicObject> updateDataEntity = new ArrayList<>();
         for (DynamicObject dataEntity : e.getDataEntities()) {
             long id = dataEntity.getLong(FormConstant.ID_KEY);
             DynamicObject person = dataEntity.getDynamicObject(FormConstant.NCKD_PERSON);
@@ -502,10 +513,25 @@ public class PerfManagerSaveOpPlugin extends AbstractOperationServicePlugIn impl
                 if (id > 0) {
                     filter = new QFilter(FormConstant.ID_KEY, QCP.not_in, id);
                 }
-                DynamicObject[] beforeBeginYear = PerfManagerHelper.getBeforeBeginYear(DateUtil.toDate(beginYear), Collections.singletonList(personId), filter);
-                if (beforeBeginYear != null && beforeBeginYear.length > 0) {
-                    DynamicObject[] allPerfManagerArray = PerfManagerHelper.getByPersonId(Collections.singletonList(personId), filter);
-                    List<DynamicObject> allPerfManagerList = new ArrayList<>(Arrays.asList(allPerfManagerArray));
+//                DynamicObject[] beforeBeginYear = PerfManagerHelper.getBeforeBeginYear(DateUtil.toDate(beginYear), Collections.singletonList(personId), filter);
+                List<DynamicObject> beforeBeginYear = Arrays.stream(beforeBeginYearList)
+                        .filter(obj -> {
+                            Date dbBeginYear = obj.getDate(PerfManagerFormConstant.NCKD_BEGINYEAR);
+                            Long dbPersonId = obj.getDynamicObject(FormConstant.NCKD_PERSON).getLong(FormConstant.ID_KEY);
+                            Long dbId = obj.getLong(FormConstant.ID_KEY);
+                            String theStatus = obj.getString(PerfManagerFormConstant.NCKD_THESTATUS);
+                            return dbBeginYear != null && dbBeginYear.compareTo(DateUtil.toDate(beginYear)) <= 0 && dbPersonId.equals(personId) && !dbId.equals(id) && theStatus.equalsIgnoreCase(EnableEnum.YES.getCode());
+                        })
+                        .collect(Collectors.toList());
+                if (!beforeBeginYear.isEmpty()) {
+//                    DynamicObject[] allPerfManagerArray = PerfManagerHelper.getByPersonId(Collections.singletonList(personId), filter);
+                    List<DynamicObject> allPerfManagerList = Arrays.stream(beforeBeginYearList)
+                            .filter(obj -> {
+                                Long dbPersonId = obj.getDynamicObject(FormConstant.NCKD_PERSON).getLong(FormConstant.ID_KEY);
+                                Long dbId = obj.getLong(FormConstant.ID_KEY);
+                                return  dbPersonId.equals(personId) && !dbId.equals(id);
+                            })
+                            .collect(Collectors.toList());
                     allPerfManagerList.add(dataEntity);
                     for (DynamicObject lastPerfManager : beforeBeginYear) {
                         lastPerfManager.set(PerfManagerFormConstant.NCKD_THESTATUS, "3");
@@ -539,7 +565,7 @@ public class PerfManagerSaveOpPlugin extends AbstractOperationServicePlugIn impl
                     DynamicObject previousCycle = findPreviousCycle(allPerfManagerList, DateUtil.toDate(beginYear));
                     if (previousCycle != null) {
                         dataEntity.set(PerfManagerFormConstant.NCKD_LASTPERFMANAGER, previousCycle);
-                        SaveServiceHelper.update(dataEntity);
+                        updateDataEntity.add(dataEntity);
                     }
                 }
             }
@@ -549,6 +575,9 @@ public class PerfManagerSaveOpPlugin extends AbstractOperationServicePlugIn impl
             DynamicObject[] lastPerfManagerArray = updatePerManager.toArray(new DynamicObject[0]);
             SaveServiceHelper.update(lastPerfManagerArray);
         }
+        if(!updateDataEntity.isEmpty()) {
+            SaveServiceHelper.update(updateDataEntity.toArray(new DynamicObject[0]));
+        }
         //上一周期标记为“已结束”并设置“实际结束时间” end
     }