Merge remote-tracking branch 'origin/master'

attendance-performance-manager/src/main/java/com/mortals/xhx/module/attendance/service/AttendanceRecordErrorService.java

 package com.mortals.xhx.module.attendance.service;
+
 import com.mortals.framework.model.Context;
 import com.mortals.framework.service.ICRUDService;
+import com.mortals.xhx.module.attendance.dao.AttendanceRecordErrorDao;
 import com.mortals.xhx.module.attendance.model.AttendanceRecordErrorEntity;
 import com.mortals.xhx.module.attendance.model.AttendanceRecordErrorQuery;
 import com.mortals.xhx.module.attendance.model.vo.ErrorSummaryVo;
+import com.mortals.xhx.module.perform.dao.PerformErrorMessageDao;
 
 import java.util.Date;
 import java.util.List;
 
 /**
-* AttendanceRecordErrorService
-*
-* 考勤打卡记录异常信息 service接口
-*
-* @author zxfei
-* @date 2023-04-08
-*/
-public interface AttendanceRecordErrorService extends ICRUDService<AttendanceRecordErrorEntity,Long>{
+ * AttendanceRecordErrorService
+ * <p>
+ * 考勤打卡记录异常信息 service接口
+ *
+ * @author zxfei
+ * @date 2023-04-08
+ */
+public interface AttendanceRecordErrorService extends ICRUDService<AttendanceRecordErrorEntity, Long> {
+
+
+    AttendanceRecordErrorDao getDao();
 
     /***
      * 考勤异常确认前检测，如果当天有请假记录则返回false
@@ -27,18 +33,21 @@ public interface AttendanceRecordErrorService extends ICRUDService<AttendanceRec
 
     /**
      * 自动处理异常考勤记录
+     *
      * @param date
      */
     void doAutoProcess(Date date);
 
     /**
      * 按时间从新生成已处理的考勤绩效核查数据
+     *
      * @param query
      */
     void doReprocess(AttendanceRecordErrorQuery query, Context context);
 
     /**
      * 统计每月异常次数top10
+     *
      * @param query
      * @return
      */

attendance-performance-manager/src/main/java/com/mortals/xhx/module/attendance/service/impl/AttendanceRecordErrorServiceImpl.java

@@ -244,6 +244,13 @@ public class AttendanceRecordErrorServiceImpl extends AbstractCRUDServiceImpl<At
         AttendanceRecordErrorQuery errorQuery = new AttendanceRecordErrorQuery();
         errorQuery.setIdList(Arrays.asList(ids));
         List<AttendanceRecordErrorEntity> delErrorList = this.find(errorQuery, context);
+/*        //改造循环查询
+        List<Long> staffIdList = delErrorList.stream().map(i -> i.getStaffId()).distinct().collect(Collectors.toList());
+
+        PerformAttendRecordQuery query = new PerformAttendRecordQuery();
+        query.setStaffIdList(staffIdList);
+        query.setRuleIdNotList(Arrays.asList(9L));*/
+
         for (AttendanceRecordErrorEntity attendanceRecordErrorEntity : delErrorList) {
             PerformAttendRecordQuery query = new PerformAttendRecordQuery();
             query.setStaffId(attendanceRecordErrorEntity.getStaffId());

attendance-performance-manager/src/main/java/com/mortals/xhx/module/attendance/service/impl/AttendanceRecordHikServiceImpl.java

@@ -111,6 +111,12 @@ public class AttendanceRecordHikServiceImpl extends AbstractCRUDServiceImpl<Atte
         Map<Long, AttendanceClassDetailEntity> classDetailEntityMap = attendanceClassDetailService.find(new AttendanceClassDetailQuery()).parallelStream().collect(Collectors.toMap(x -> x.getId(), y -> y, (o, n) -> n));
         Map<Long, List<AttendanceGroupFixedworkSpecialEntity>> fixedSpecialGroupMap = specialService.find(new AttendanceGroupFixedworkSpecialEntity()).parallelStream().collect(Collectors.groupingBy(x -> x.getFixedWorkId()));
 
+        //获取当日未处理异常记录
+        AttendanceRecordErrorQuery attendanceRecordErrorQuery = new AttendanceRecordErrorQuery();
+        attendanceRecordErrorQuery.setErrorDateTimeStart(attendanceRecordHikQuery.getAttendanceDateStart());
+        attendanceRecordErrorQuery.setErrorDateTimeEnd(attendanceRecordErrorQuery.getActualAttendanceDateTimeEnd());
+        Map<Long, List<AttendanceRecordErrorEntity>> errorGroupStaffMap = errorService.find(attendanceRecordErrorQuery).parallelStream().collect(Collectors.groupingBy(x -> x.getStaffId()));
+
         String attendanceDateStart = attendanceRecordHikQuery.getAttendanceDateStart();
         String attendanceDateEnd = attendanceRecordHikQuery.getAttendanceDateEnd();
 
@@ -122,6 +128,7 @@ public class AttendanceRecordHikServiceImpl extends AbstractCRUDServiceImpl<Atte
         List<AttendanceRecordEntity> saveList = new ArrayList<>();
         List<AttendanceRecordEntity> updateList = new ArrayList<>();
         listMap.entrySet().stream().forEach(itemEntry -> {
+        //listMap.entrySet().parallelStream().forEach(itemEntry -> {
             //按人员  todo 改为多线程并行计算
             Long staffId = itemEntry.getKey();
             List<AttendanceRecordHikEntity> recordHikEntityList = itemEntry.getValue();
@@ -179,6 +186,7 @@ public class AttendanceRecordHikServiceImpl extends AbstractCRUDServiceImpl<Atte
                     commonData.setRecordHikEntities(recordHikEntities);
                     commonData.setFixedSpecialGroupMap(fixedSpecialGroupMap);
                     commonData.setClassDetailEntityMap(classDetailEntityMap);
+                    commonData.setErrorGroupStaffMap(errorGroupStaffMap);
                     workAbstract.doHandleWork(commonData);
                 }
                 //如果考勤人员信息list长度大于1 则该考勤人员有多个考勤组.
@@ -204,6 +212,7 @@ public class AttendanceRecordHikServiceImpl extends AbstractCRUDServiceImpl<Atte
                         commonData.setRecordHikEntities(recordHikEntities);
                         commonData.setFixedSpecialGroupMap(fixedSpecialGroupMap);
                         commonData.setClassDetailEntityMap(classDetailEntityMap);
+                        commonData.setErrorGroupStaffMap(errorGroupStaffMap);
                         workAbstract.doHandleWork(commonData);
                     }
                 }

attendance-performance-manager/src/main/java/com/mortals/xhx/module/attendance/service/work/CommonData.java

@@ -41,6 +41,8 @@ public class CommonData {
 
     private  Map<Long, List<AttendanceGroupFixedworkSpecialEntity>> fixedSpecialGroupMap;
 
+    private Map<Long, List<AttendanceRecordErrorEntity>> errorGroupStaffMap;
+
 
    // private Map<Long, List<AttendanceLeaveRecordEntity>> leaveRecordGroupMap;
 

attendance-performance-manager/src/main/java/com/mortals/xhx/module/attendance/service/work/FixWorkOtherAttendance.java

@@ -6,14 +6,25 @@ import cn.hutool.core.date.DateUtil;
 import com.alibaba.fastjson.JSON;
 import com.mortals.framework.model.Context;
 import com.mortals.framework.model.OrderCol;
+import com.mortals.framework.util.ThreadPool;
 import com.mortals.xhx.common.code.*;
 import com.mortals.xhx.module.attendance.model.*;
 import com.mortals.xhx.module.attendance.service.*;
+import com.mortals.xhx.module.check.model.CheckAttendRecordEntity;
+import com.mortals.xhx.module.check.model.CheckAttendRecordQuery;
+import com.mortals.xhx.module.check.service.CheckAttendRecordService;
 import com.mortals.xhx.module.holiday.model.HolidayEntity;
 import com.mortals.xhx.module.holiday.model.HolidayQuery;
 import com.mortals.xhx.module.holiday.service.HolidayService;
+import com.mortals.xhx.module.perform.model.PerformAttendRecordEntity;
+import com.mortals.xhx.module.perform.model.PerformAttendRecordQuery;
+import com.mortals.xhx.module.perform.model.PerformErrorMessageEntity;
+import com.mortals.xhx.module.perform.model.PerformErrorMessageQuery;
+import com.mortals.xhx.module.perform.service.PerformAttendRecordService;
+import com.mortals.xhx.module.perform.service.PerformErrorMessageService;
 import com.mortals.xhx.utils.SpringUtils;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections4.CollectionUtils;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.util.ObjectUtils;
@@ -39,11 +50,23 @@ public class FixWorkOtherAttendance extends AttendanceWorkAbstract {
 
     private Map<Long, AttendanceClassDetailEntity> classDetailEntityMap;
 
+    private CommonData commonData;
+
+    private PerformAttendRecordService performAttendRecordService;
+
+    private CheckAttendRecordService checkAttendRecordService;
+
+    private PerformErrorMessageService performErrorMessageService;
+
     public FixWorkOtherAttendance(int type) {
         super(type);
         this.attendanceGroupFixedworkService = SpringUtils.getBean(AttendanceGroupFixedworkService.class);
         this.errorService = SpringUtils.getBean(AttendanceRecordErrorService.class);
         this.attendanceLeaveRecordService = SpringUtils.getBean(AttendanceLeaveRecordService.class);
+        this.performAttendRecordService = SpringUtils.getBean(PerformAttendRecordService.class);
+        this.checkAttendRecordService = SpringUtils.getBean(CheckAttendRecordService.class);
+        this.performErrorMessageService = SpringUtils.getBean(PerformErrorMessageService.class);
+
     }
 
     @Override
@@ -57,6 +80,7 @@ public class FixWorkOtherAttendance extends AttendanceWorkAbstract {
 
     @Override
     public void doHandleWork(CommonData commonData) {
+        this.commonData = commonData;
         AttendanceGroupFixedworkEntity attendanceGroupFixedworkEntity = attendanceGroupFixedworkService.selectOne(new AttendanceGroupFixedworkQuery()
                 .groupId(commonData.getAttendanceGroupEntity().getId()));
         Map<Long, AttendanceClassEntity> classEntityMap = commonData.getClassEntityMap();
@@ -287,11 +311,11 @@ public class FixWorkOtherAttendance extends AttendanceWorkAbstract {
             }
         }
         //生成异常记录
-        StopWatch stopWatch =new StopWatch();
-        stopWatch.start("生成异常记录耗时");
+        // StopWatch stopWatch = new StopWatch();
+        //  stopWatch.start("生成异常记录耗时");
         genErrorAttendRecord(commonData.getContext(), commonData.getDateStr(), commonData.getAttendanceRecordEntity(), commonData.getDetailEntityList());
-        stopWatch.stop();
-        log.info("生成异常记录耗时：{}ms", stopWatch.getLastTaskTimeMillis());
+        // stopWatch.stop();
+        // log.info("生成异常记录耗时：{}ms", stopWatch.getLastTaskTimeMillis());
     }
 
     /**
@@ -354,21 +378,6 @@ public class FixWorkOtherAttendance extends AttendanceWorkAbstract {
         }
     }
 
-    private void deleteErrorRecord(String dateStr, Long staffId, Context context) {
-        //删除当前员工当日未处理的异常后，重新添加
-        AttendanceRecordErrorQuery errorQuery = new AttendanceRecordErrorQuery();
-        errorQuery.setErrorDateTimeStart(dateStr);
-        errorQuery.setErrorDateTimeEnd(dateStr);
-        errorQuery.setStaffId(staffId);
-        errorQuery.setProcessStatus(YesNoEnum.NO.getValue());
-        List<AttendanceRecordErrorEntity> attendanceRecordErrorEntities = errorService.find(errorQuery);
-        Long[] errorIds = attendanceRecordErrorEntities.stream().map(i -> i.getId()).toArray(Long[]::new);
-        if (!ObjectUtils.isEmpty(errorIds)) {
-            //log.info("删除 {} 人员:{} 异常记录:{}",dateStr,staffId, JSON.toJSONString(attendanceRecordErrorEntities));
-            errorService.remove(errorIds, context);
-        }
-    }
-
 
     public void genErrorAttendRecord(Context context, String dateStr, AttendanceRecordEntity attendanceRecordEntity, List<AttendanceRecordDetailEntity> detailEntityList) {
         //处理异常打卡，所以异常打卡的 都新增一条记录
@@ -444,13 +453,118 @@ public class FixWorkOtherAttendance extends AttendanceWorkAbstract {
             }
         }
         //删除当前员工当日未处理的异常后，重新添加 处理的 不做删除
-        deleteErrorRecord(dateStr, attendanceRecordEntity.getStaffId(), context);
-        AttendanceRecordErrorQuery errorQuery;
+        //deleteErrorRecord(dateStr, attendanceRecordEntity.getStaffId(), context);
+        //todo 级联删除优化 耗时50秒
+        deleteErrorRecordCache(attendanceRecordEntity.getStaffId(), context);
         if (!ObjectUtils.isEmpty(errorEntityList)) {
             //过滤异常列表中存在相同的记录
             errorEntityList = errorEntityList.stream().distinct().collect(Collectors.toList());
             for (AttendanceRecordErrorEntity errorEntity : errorEntityList) {
-                //查看是否存在相同的异常记录，如果存在 则不添加
+                //查看是否存在相同的异常记录，如果存在 则不添加  todo 非数据库查询方式判断优化
+                List<AttendanceRecordErrorEntity> attendanceRecordErrorEntities = commonData.getErrorGroupStaffMap().getOrDefault(attendanceRecordEntity.getStaffId(), new ArrayList<>(0));
+                checkAndSaveCache(context, attendanceRecordErrorEntities, errorEntity);
+                // checkAndSave(context, errorEntity);
+            }
+        }
+    }
+
+    private void deleteErrorRecord(String dateStr, Long staffId, Context context) {
+        //删除当前员工当日未处理的异常后，重新添加
+        AttendanceRecordErrorQuery errorQuery = new AttendanceRecordErrorQuery();
+        errorQuery.setErrorDateTimeStart(dateStr);
+        errorQuery.setErrorDateTimeEnd(dateStr);
+        errorQuery.setStaffId(staffId);
+        errorQuery.setProcessStatus(YesNoEnum.NO.getValue());
+        List<AttendanceRecordErrorEntity> attendanceRecordErrorEntities = errorService.find(errorQuery);
+        Long[] errorIds = attendanceRecordErrorEntities.stream().map(i -> i.getId()).toArray(Long[]::new);
+        if (!ObjectUtils.isEmpty(errorIds)) {
+            //log.info("删除 {} 人员:{} 异常记录:{}",dateStr,staffId, JSON.toJSONString(attendanceRecordErrorEntities));
+            errorService.remove(errorIds, context);
+        }
+    }
+
+    private void deleteErrorRecordCache(Long staffId, Context context) {
+        //删除当前员工当日未处理的异常后，重新添加
+        List<AttendanceRecordErrorEntity> attendanceRecordErrorEntities = commonData.getErrorGroupStaffMap().getOrDefault(staffId, new ArrayList<>(0));
+
+        List<AttendanceRecordErrorEntity> delErrorList = attendanceRecordErrorEntities.stream()
+                .filter(f -> YesNoEnum.NO.getValue() == f.getProcessStatus())
+                .collect(Collectors.toList());
+        Long[] errorIds = delErrorList.stream().map(i -> i.getId()).toArray(Long[]::new);
+        if (!ObjectUtils.isEmpty(errorIds)) {
+            //log.info("删除 {} 人员:{} 异常记录:{}",dateStr,staffId, JSON.toJSONString(attendanceRecordErrorEntities));
+           // StopWatch stopWatch = new StopWatch();
+          //  stopWatch.start("删除异常记录耗时");
+            //todo 耗时长，删除优化
+            errorService.getDao().delete(errorIds);
+/*
+            //线程池去删除异常记录
+            Runnable runnable = new Runnable() {
+                @Override
+                public void run() {
+                    errorService.remove(errorIds, context);
+                }
+            };
+            ThreadPool.getInstance().execute(runnable);*/
+
+            PerformAttendRecordQuery query = new PerformAttendRecordQuery();
+            query.setStaffId(staffId);
+            query.setErrorTimeStart(DateUtil.formatDate(delErrorList.get(0).getErrorDateTime()));
+            query.setErrorTimeEnd(DateUtil.formatDate(delErrorList.get(0).getErrorDateTime()));
+            query.setRuleIdNotList(Arrays.asList(9L));
+            List<PerformAttendRecordEntity> attendRecords = performAttendRecordService.find(query, context);
+
+            List<PerformAttendRecordEntity> delAttendRecords = attendRecords.stream().map(item -> {
+                Date errorTime = item.getErrorTime();
+                for (AttendanceRecordErrorEntity attendRecord : delErrorList) {
+                    if (errorTime.getTime() == attendRecord.getErrorDateTime().getTime()) {
+                        return item;
+                    }
+                }
+                return null;
+            }).filter(f -> f != null).collect(Collectors.toList());
+
+            if (!ObjectUtils.isEmpty(delAttendRecords)) {
+                Long[] delIds = delAttendRecords.stream().map(i -> i.getId()).toArray(Long[]::new);
+                performAttendRecordService.getDao().delete(delIds);
+
+                CheckAttendRecordQuery checkAttendRecordQuery = new CheckAttendRecordQuery();
+                checkAttendRecordQuery.setRecordIdList(Arrays.asList(delIds));
+                List<CheckAttendRecordEntity> checkAttendRecordEntities = checkAttendRecordService.find(checkAttendRecordQuery, context);
+                if (!ObjectUtils.isEmpty(checkAttendRecordEntities)) {
+                    Long[] checkIds = checkAttendRecordEntities.stream().map(i -> i.getId()).toArray(Long[]::new);
+                    checkAttendRecordService.getDao().delete(checkIds);
+                    //  checkAttendRecordService.remove(checkIds, context);
+                    //  log.info("删除考勤核查记录成功,size:{}",checkIds.length);
+
+                    PerformErrorMessageQuery performErrorMessageQuery = new PerformErrorMessageQuery();
+                    performErrorMessageQuery.setPerformType(PerformTypeEnum.考勤绩效.getValue());
+                    performErrorMessageQuery.setCheckRecordIdList(Arrays.asList(checkIds));
+                    List<PerformErrorMessageEntity> errorList = performErrorMessageService.find(performErrorMessageQuery);
+                    if (CollectionUtils.isNotEmpty(errorList)) {
+                        Long[] deleteIds = errorList.stream().map(i -> i.getId()).toArray(Long[]::new);
+                        performErrorMessageService.remove(deleteIds, context);
+                    }
+                }
+            }
+           // stopWatch.stop();
+         //   log.info("删除异常记录耗时：{}ms", stopWatch.getLastTaskTimeMillis());
+        }
+
+    }
+
+    private void checkAndSaveCache(Context context, List<AttendanceRecordErrorEntity> attendanceRecordErrorEntities, AttendanceRecordErrorEntity errorEntity) {
+        AttendanceRecordErrorEntity attendanceRecordErrorEntity = attendanceRecordErrorEntities.stream()
+                .filter(f -> errorEntity.getErrorDateTime().getTime() == f.getErrorDateTime().getTime())
+                .filter(f -> errorEntity.getShiftsId().equals(f.getShiftsId()))
+                .filter(f -> YesNoEnum.YES.getValue() == f.getProcessStatus()).findAny().orElseGet(() -> null);
+        if (ObjectUtils.isEmpty(attendanceRecordErrorEntity)) {
+            errorService.save(errorEntity, context);
+        }
+    }
+
+    private void checkAndSave(Context context, AttendanceRecordErrorEntity errorEntity) {
+        AttendanceRecordErrorQuery errorQuery;
         errorQuery = new AttendanceRecordErrorQuery();
         errorQuery.setErrorDateTime(errorEntity.getErrorDateTime());
         errorQuery.setStaffId(errorEntity.getStaffId());
@@ -461,10 +575,6 @@ public class FixWorkOtherAttendance extends AttendanceWorkAbstract {
             errorService.save(errorEntity, context);
         }
     }
-        }
-    }
-
-
 
 
     public static void main(String[] args) {