feat: add service config templates and extraction script

Former-commit-id: 1de24b7eb79676d1aba9d799a58c5a753290cf52

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/AttendanceFeignConfiguration.java

@@ -0,0 +1,86 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.cloud.context.CloudwalkSessionContextHolder
+ *  cn.cloudwalk.cloud.context.CloudwalkSessionObject
+ *  cn.cloudwalk.common.ninca.attendance.config.FeignThreadLocalUtil
+ *  cn.cloudwalk.common.ninca.attendance.util.StringUtils
+ *  feign.RequestInterceptor
+ *  feign.RequestTemplate
+ *  javax.servlet.http.HttpServletRequest
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.context.annotation.Configuration
+ *  org.springframework.web.context.request.RequestContextHolder
+ *  org.springframework.web.context.request.ServletRequestAttributes
+ */
+package cn.cloudwalk.service.ninca.attendance;
+
+import cn.cloudwalk.cloud.context.CloudwalkSessionContextHolder;
+import cn.cloudwalk.cloud.context.CloudwalkSessionObject;
+import cn.cloudwalk.common.ninca.attendance.config.FeignThreadLocalUtil;
+import cn.cloudwalk.common.ninca.attendance.util.StringUtils;
+import feign.RequestInterceptor;
+import feign.RequestTemplate;
+import java.util.Map;
+import javax.servlet.http.HttpServletRequest;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+
+@Configuration
+public class AttendanceFeignConfiguration
+implements RequestInterceptor {
+    protected final Logger logger = LoggerFactory.getLogger(this.getClass());
+    @Autowired
+    private CloudwalkSessionContextHolder cloudwalkSessionContextHolder;
+
+    public void apply(RequestTemplate requestTemplate) {
+        Map map = FeignThreadLocalUtil.get();
+        if (map != null && !map.isEmpty()) {
+            requestTemplate.header("platformuserid", new String[]{(String)map.get("platformuserid")});
+            requestTemplate.header("loginid", new String[]{(String)map.get("loginid")});
+            requestTemplate.header("businessid", new String[]{(String)map.get("businessid")});
+            requestTemplate.header("username", new String[]{(String)map.get("username")});
+            requestTemplate.header("applicationid", new String[]{(String)map.get("applicationid")});
+            requestTemplate.header("authorization", new String[]{(String)map.get("authorization")});
+        } else {
+            Map headerMap = requestTemplate.headers();
+            ServletRequestAttributes attributes = (ServletRequestAttributes)RequestContextHolder.getRequestAttributes();
+            if (null != attributes) {
+                HttpServletRequest request = attributes.getRequest();
+                if (!headerMap.containsKey("platformuserid")) {
+                    requestTemplate.header("platformuserid", new String[]{request.getHeader("platformuserid")});
+                }
+                if (!headerMap.containsKey("loginid")) {
+                    requestTemplate.header("loginid", new String[]{request.getHeader("loginid")});
+                }
+                if (!headerMap.containsKey("businessid")) {
+                    requestTemplate.header("businessid", new String[]{request.getHeader("businessid")});
+                }
+                if (!headerMap.containsKey("username")) {
+                    requestTemplate.header("username", new String[]{request.getHeader("username")});
+                }
+                if (!headerMap.containsKey("applicationid")) {
+                    requestTemplate.header("applicationid", new String[]{request.getHeader("applicationid")});
+                }
+                if (!headerMap.containsKey("authorization")) {
+                    requestTemplate.header("authorization", new String[]{request.getHeader("authorization")});
+                }
+                CloudwalkSessionObject session = this.cloudwalkSessionContextHolder.getSession();
+                if (StringUtils.isBlank((String)request.getHeader("businessid")) && session != null) {
+                    requestTemplate.header("businessid", new String[]{session.getCompany().getCompanyId()});
+                }
+                if (StringUtils.isBlank((String)request.getHeader("applicationid")) && session != null) {
+                    requestTemplate.header("applicationid", new String[]{session.getApplicationId()});
+                }
+            }
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/capture/BiologyFeatureServiceImpl.java

@@ -0,0 +1,131 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.application.param.ApplicationImageStoreQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.application.result.ApplicationImageStoreResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.application.service.ApplicationImageStoreService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.biology.param.FeatureQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.biology.result.FeatureQueryResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.biology.service.BiologyToolService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceImageStoreQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.result.DeviceImageStoreResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.result.DeviceResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceImageStoreService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceService
+ *  cn.cloudwalk.client.ninca.attendance.capture.param.CaptureFeatureQueryParam
+ *  cn.cloudwalk.client.ninca.attendance.capture.service.BiologyFeatureService
+ *  cn.cloudwalk.client.ninca.attendance.common.AttendApplicationService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  cn.cloudwalk.intelligent.davinci.storage.manager.FileStorageManager
+ *  javax.annotation.Resource
+ *  org.apache.commons.codec.binary.Base64
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.capture;
+
+import cn.cloudwalk.client.cwoscomponent.intelligent.application.param.ApplicationImageStoreQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.application.result.ApplicationImageStoreResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.application.service.ApplicationImageStoreService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.biology.param.FeatureQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.biology.result.FeatureQueryResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.biology.service.BiologyToolService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceImageStoreQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.result.DeviceImageStoreResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.result.DeviceResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceImageStoreService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceService;
+import cn.cloudwalk.client.ninca.attendance.capture.param.CaptureFeatureQueryParam;
+import cn.cloudwalk.client.ninca.attendance.capture.service.BiologyFeatureService;
+import cn.cloudwalk.client.ninca.attendance.common.AttendApplicationService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.intelligent.davinci.storage.manager.FileStorageManager;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+import org.apache.commons.codec.binary.Base64;
+import org.springframework.stereotype.Service;
+
+@Service
+public class BiologyFeatureServiceImpl
+extends AbstractCloudwalkService
+implements BiologyFeatureService {
+    @Resource
+    private FileStorageManager fileStorageManager;
+    @Resource
+    private BiologyToolService biologyToolService;
+    @Resource
+    private DeviceImageStoreService deviceImageStoreService;
+    @Resource
+    private DeviceService deviceService;
+    @Resource
+    private ApplicationImageStoreService applicationImageStoreService;
+    @Resource
+    private AttendApplicationService attendApplicationService;
+
+    public FeatureQueryResult featureQuery(CaptureFeatureQueryParam param, CloudwalkCallContext context) throws ServiceException {
+        try {
+            List<String> imagestoreIds;
+            byte[] bytes = this.fileStorageManager.fileDownload(param.getImagePath());
+            if (bytes != null && CollectionUtils.isNotEmpty(imagestoreIds = this.queryImagestoreIds(param, context))) {
+                FeatureQueryParam featureQueryParam = new FeatureQueryParam();
+                featureQueryParam.setImageStoreIds(imagestoreIds);
+                featureQueryParam.setImageBase64(Base64.encodeBase64String((byte[])bytes));
+                featureQueryParam.setTopN(Integer.valueOf(1));
+                CloudwalkResult result = this.biologyToolService.query(featureQueryParam, context);
+                if (result.isSuccess() && CollectionUtils.isNotEmpty((Collection)((Collection)result.getData()))) {
+                    return (FeatureQueryResult)((List)result.getData()).get(0);
+                }
+            }
+        }
+        catch (Exception e) {
+            this.logger.error("1:N\u5f15\u64ce\u67e5\u8be2\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+        return null;
+    }
+
+    private List<String> queryImagestoreIds(CaptureFeatureQueryParam param, CloudwalkCallContext context) throws ServiceException {
+        DeviceQueryParam deviceQueryParam = new DeviceQueryParam();
+        deviceQueryParam.setDeviceCode(param.getDeviceCode());
+        CloudwalkResult deviceCloudwalkResult = this.deviceService.list(deviceQueryParam, context);
+        if (!deviceCloudwalkResult.isSuccess() || CollectionUtils.isEmpty((Collection)((Collection)deviceCloudwalkResult.getData()))) {
+            this.logger.error("\u67e5\u8be2\u8bbe\u5907\u5931\u8d25\uff0c\u6ca1\u6709\u627e\u5230\u8bbe\u5907\u4fe1\u606f\uff0c\u8bbe\u5907\u7f16\u7801\uff1a{}", (Object)param.getDeviceCode());
+            return null;
+        }
+        DeviceImageStoreQueryParam deviceImageStoreQueryParam = new DeviceImageStoreQueryParam();
+        String deviceId = ((DeviceResult)((List)deviceCloudwalkResult.getData()).get(0)).getId();
+        deviceImageStoreQueryParam.setDeviceId(deviceId);
+        CloudwalkResult deviceImagestoreResult = this.deviceImageStoreService.list(deviceImageStoreQueryParam, context);
+        if (!deviceImagestoreResult.isSuccess() || CollectionUtils.isEmpty((Collection)((Collection)deviceImagestoreResult.getData()))) {
+            this.logger.warn("\u8be5\u8bbe\u5907\u4e0b\u672a\u67e5\u8be2\u5230\u56fe\u5e93\u5217\u8868\uff0cdeviceId{}", (Object)deviceId);
+            return null;
+        }
+        String applicationId = this.attendApplicationService.getApplicationId(context.getCompany().getCompanyId());
+        ApplicationImageStoreQueryParam imageStoreQueryParam = new ApplicationImageStoreQueryParam();
+        imageStoreQueryParam.setApplicationId(applicationId);
+        CloudwalkResult appImageStoreResult = this.applicationImageStoreService.list(imageStoreQueryParam, context);
+        if (!appImageStoreResult.isSuccess() || CollectionUtils.isEmpty((Collection)((Collection)appImageStoreResult.getData()))) {
+            this.logger.warn("\u8be5\u5e94\u7528\u4e0b\u672a\u67e5\u8be2\u5230\u56fe\u5e93\u5217\u8868\uff0capplicationId{}", (Object)applicationId);
+            return null;
+        }
+        return this.merge((List)deviceImagestoreResult.getData(), (List)appImageStoreResult.getData());
+    }
+
+    private List<String> merge(List<DeviceImageStoreResult> data1, List<ApplicationImageStoreResult> data2) {
+        List list1 = data1.stream().map(DeviceImageStoreResult::getImageStoreId).collect(Collectors.toList());
+        List list2 = data2.stream().map(ApplicationImageStoreResult::getImageStoreId).collect(Collectors.toList());
+        return list1.stream().filter(list2::contains).collect(Collectors.toList());
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/common/AbstractAttendService.java

@@ -0,0 +1,581 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendClassDeviceManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendClassManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendClassOrgManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendBindImagestoreManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleDeviceManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleLabelManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleOrgManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.application.param.ApplicationImageStoreAddParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.application.param.ApplicationImageStoreDelParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.application.param.ApplicationImageStoreQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.application.service.ApplicationImageStoreService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceApplicationParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceApplicationQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceImageStoreParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceImageStoreQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceApplicationService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceImageStoreService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStoreAddParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStoreDelParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStoreEditParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.service.ImageStoreService
+ *  cn.cloudwalk.client.ninca.attendance.common.AttendApplicationService
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendOrgCheckParam
+ *  cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassDeviceQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassDeviceQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassGetsDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendBindImagestoreAddDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendBindImagestoreDeleteDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendBindImagestoreQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendBindImagestoreQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleGetsDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleLabelQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleLabelQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.RuleLabelTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.StringUtils
+ *  com.alibaba.fastjson.JSON
+ *  javax.annotation.Resource
+ */
+package cn.cloudwalk.service.ninca.attendance.common;
+
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendClassDeviceManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendClassManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendClassOrgManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendBindImagestoreManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleDeviceManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleLabelManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleOrgManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.application.param.ApplicationImageStoreAddParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.application.param.ApplicationImageStoreDelParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.application.param.ApplicationImageStoreQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.application.service.ApplicationImageStoreService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceApplicationParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceApplicationQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceImageStoreParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceImageStoreQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceApplicationService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceImageStoreService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStoreAddParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStoreDelParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStoreEditParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.service.ImageStoreService;
+import cn.cloudwalk.client.ninca.attendance.common.AttendApplicationService;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendOrgCheckParam;
+import cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassDeviceQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassDeviceQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassGetsDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendBindImagestoreAddDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendBindImagestoreDeleteDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendBindImagestoreQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendBindImagestoreQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleGetsDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleLabelQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleLabelQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.em.RuleLabelTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.attendance.util.StringUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import com.alibaba.fastjson.JSON;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+
+public class AbstractAttendService
+extends AbstractCloudwalkService {
+    @Resource
+    private DeviceApplicationService deviceApplicationService;
+    @Resource
+    private DeviceImageStoreService deviceImageStoreService;
+    @Resource
+    private AttendRuleManager attendRuleManager;
+    @Resource
+    private AttendClassManager attendClassManager;
+    @Resource
+    private AttendApplicationService applicationService;
+    @Resource
+    private AttendRuleDeviceManager attendRuleDeviceManager;
+    @Resource
+    private AttendClassDeviceManager attendClassDeviceManager;
+    @Resource
+    private AttendRuleOrgManager attendRuleOrgManager;
+    @Resource
+    private AttendClassOrgManager attendClassOrgManager;
+    @Resource
+    private ApplicationImageStoreService applicationImageStoreService;
+    @Resource
+    private ImageStoreService imageStoreService;
+    @Resource
+    private AttendBindImagestoreManager attendBindImagestoreManager;
+    @Resource
+    private AttendRuleLabelManager attendRuleLabelManager;
+
+    protected void saveCwosTransaction(String ruleId, String ruleName, List<String> deviceIds, List<String> orgIds, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        String applicationId = this.applicationService.getApplicationId(cloudwalkContext.getCompany().getCompanyId());
+        String imagestoreId = this.bindImagestore(ruleId, ruleName, applicationId, cloudwalkContext);
+        try {
+            this.addDeviceRef(deviceIds, imagestoreId, applicationId, cloudwalkContext);
+        }
+        catch (ServiceException e) {
+            this.deleteAppImageStoreRef(applicationId, imagestoreId, cloudwalkContext);
+            this.deleteDeviceImageStoreRef(deviceIds, imagestoreId, cloudwalkContext);
+            this.logger.error("\u521b\u5efa\u8bbe\u5907\u4e0e\u56fe\u5e93\u3001\u5e94\u7528\u5173\u7cfb\u5931\u8d25\uff0c\u5220\u9664\u56fe\u5e93,\u56fe\u5e93id\uff1a{}", (Object)imagestoreId);
+            ImageStoreDelParam imageStoreDelParam = new ImageStoreDelParam();
+            imageStoreDelParam.setId(imagestoreId);
+            CloudwalkResult deleteResult = this.imageStoreService.delete(imageStoreDelParam, cloudwalkContext);
+            this.logger.error("\u521b\u5efa\u8bbe\u5907\u4e0e\u56fe\u5e93\u3001\u5e94\u7528\u5173\u7cfb\u5931\u8d25\uff0c\u5220\u9664\u56fe\u5e93,\u5220\u9664\u7ed3\u679c\uff1a{}", (Object)JSON.toJSONString((Object)deleteResult));
+            throw e;
+        }
+    }
+
+    protected void saveCwos(String ruleId, String ruleName, List<String> deviceIds, List<String> orgIds, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        String applicationId = this.applicationService.getApplicationId(cloudwalkContext.getCompany().getCompanyId());
+        String imagestoreId = this.bindImagestore(ruleId, ruleName, applicationId, cloudwalkContext);
+        this.addDeviceRef(deviceIds, imagestoreId, applicationId, cloudwalkContext);
+    }
+
+    private void addDeviceRef(List<String> deviceIds, String imagestoreId, String applicationId, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        for (String deviceId : deviceIds) {
+            DeviceApplicationQueryParam applicationQueryParam = new DeviceApplicationQueryParam();
+            applicationQueryParam.setDeviceId(deviceId);
+            applicationQueryParam.setApplicationId(applicationId);
+            CloudwalkResult applicationQueryResult = this.deviceApplicationService.list(applicationQueryParam, cloudwalkContext);
+            if (CollectionUtils.isEmpty((Collection)((Collection)applicationQueryResult.getData()))) {
+                DeviceApplicationParam applicationParam = new DeviceApplicationParam();
+                applicationParam.setApplicationId(applicationId);
+                applicationParam.setDeviceId(deviceId);
+                CloudwalkResult addApplicationResult = this.deviceApplicationService.add(applicationParam, cloudwalkContext);
+                if (!addApplicationResult.isSuccess()) {
+                    this.logger.error("\u4fdd\u5b58\u5e94\u7528\u4e0e\u8bbe\u5907\u5173\u7cfb\u5931\u8d25\uff0c\u539f\u56e0\uff1a{}", (Object)addApplicationResult.getMessage());
+                    throw new ServiceException("\u4fdd\u5b58\u5e94\u7528\u4e0e\u8bbe\u5907\u5173\u7cfb\u5931\u8d25,\u539f\u56e0\uff1a" + addApplicationResult.getMessage());
+                }
+            } else {
+                this.logger.info("\u8bbe\u5907:{}\u4e0e\u5e94\u7528\uff1a{}\u5173\u7cfb\u5df2\u7ecf\u5b58\u5728\u65e0\u987b\u6dfb\u52a0", (Object)deviceId, (Object)applicationId);
+            }
+            DeviceImageStoreQueryParam storeQueryParam = new DeviceImageStoreQueryParam();
+            storeQueryParam.setDeviceId(deviceId);
+            storeQueryParam.setImageStoreId(imagestoreId);
+            CloudwalkResult deviceQueryResult = this.deviceImageStoreService.list(storeQueryParam, cloudwalkContext);
+            if (CollectionUtils.isEmpty((Collection)((Collection)deviceQueryResult.getData()))) {
+                DeviceImageStoreParam imageStoreSaveParam = new DeviceImageStoreParam();
+                imageStoreSaveParam.setDeviceId(deviceId);
+                imageStoreSaveParam.setImageStoreId(imagestoreId);
+                CloudwalkResult saveDeviceResult = this.deviceImageStoreService.add(imageStoreSaveParam, cloudwalkContext);
+                if (saveDeviceResult.isSuccess()) continue;
+                this.logger.error("\u4fdd\u5b58\u8bbe\u5907\u4e0e\u56fe\u5e93\u5173\u7cfb\u5931\u8d25\uff0c\u539f\u56e0\uff1a{}", (Object)saveDeviceResult.getMessage());
+                throw new ServiceException("\u4fdd\u5b58\u8bbe\u5907\u4e0e\u56fe\u5e93\u5173\u7cfb\u5931\u8d25,\u539f\u56e0\uff1a" + saveDeviceResult.getMessage());
+            }
+            this.logger.info("\u8bbe\u5907\uff1a{}\u4e0e\u56fe\u5e93\uff1a{}\u5173\u7cfb\u5df2\u7ecf\u5b58\u5728\u65e0\u987b\u6dfb\u52a0", (Object)deviceId, (Object)imagestoreId);
+        }
+    }
+
+    /*
+     * Enabled force condition propagation
+     * Lifted jumps to return sites
+     */
+    protected String bindImagestore(String ruleId, String ruleName, String applicationId, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            String imagestoreId = null;
+            if (applicationId == null) {
+                applicationId = this.applicationService.getApplicationId(cloudwalkContext.getCompany().getCompanyId());
+            }
+            List<String> orgIds = this.getRuleUsedOrgs(ruleId, cloudwalkContext);
+            AttendRuleLabelQueryDTO labelQueryDTO = new AttendRuleLabelQueryDTO();
+            labelQueryDTO.setRuleId(ruleId);
+            List labelList = this.attendRuleLabelManager.query(labelQueryDTO);
+            List includeLabelIds = labelList.stream().filter(item -> item.getType().equals(RuleLabelTypeEnum.include.getCode())).map(AttendRuleLabelQueryResultDTO::getLabelId).collect(Collectors.toList());
+            List excludeLabelIds = labelList.stream().filter(item -> item.getType().equals(RuleLabelTypeEnum.exclude.getCode())).map(AttendRuleLabelQueryResultDTO::getLabelId).collect(Collectors.toList());
+            AttendBindImagestoreQueryDTO imagestoreQueryDTO = new AttendBindImagestoreQueryDTO();
+            imagestoreQueryDTO.setRuleId(ruleId);
+            List bindList = this.attendBindImagestoreManager.query(imagestoreQueryDTO);
+            String imageStoreName = "\u8003\u52e4\u56fe\u5e93" + ruleName;
+            String string = imageStoreName = imageStoreName.length() > 50 ? imageStoreName.substring(0, 50) : imageStoreName;
+            if (CollectionUtils.isEmpty((Collection)bindList)) {
+                this.logger.info("\u521d\u59cb\u5316\u56fe\u5e93\u5e76\u7ed1\u5b9a\u89c4\u5219\u4e0e\u56fe\u5e93\u5173\u7cfb,businessId:{}\uff0c\u89c4\u5219ID\uff1a{}", (Object)cloudwalkContext.getCompany().getCompanyId(), (Object)ruleId);
+                ImageStoreAddParam storeAddParam = new ImageStoreAddParam();
+                storeAddParam.setIncludeOrganizations(orgIds);
+                storeAddParam.setIncludeLabels(includeLabelIds);
+                storeAddParam.setExcludeLabels(excludeLabelIds);
+                storeAddParam.setName(imageStoreName);
+                storeAddParam.setSourceApplicationId(applicationId);
+                storeAddParam.setType(Short.valueOf((short)1));
+                CloudwalkResult addResult = this.imageStoreService.add(storeAddParam, cloudwalkContext);
+                if (!addResult.isSuccess()) throw new ServiceException("\u89c4\u5219\u521b\u5efa\u65b0\u589e\u56fe\u5e93\u5931\u8d25");
+                imagestoreId = (String)addResult.getData();
+                ApplicationImageStoreAddParam appImageStoreAddParam = new ApplicationImageStoreAddParam();
+                appImageStoreAddParam.setApplicationId(applicationId);
+                appImageStoreAddParam.setImageStoreId(imagestoreId);
+                CloudwalkResult result = this.applicationImageStoreService.add(appImageStoreAddParam, cloudwalkContext);
+                if (!result.isSuccess()) {
+                    this.logger.error("\u521b\u5efa\u56fe\u5e93\u4e0e\u5e94\u7528\u5173\u7cfb\u5931\u8d25\uff0c\u5220\u9664\u56fe\u5e93");
+                    ImageStoreDelParam imageStoreDelParam = new ImageStoreDelParam();
+                    imageStoreDelParam.setId(imagestoreId);
+                    this.imageStoreService.delete(imageStoreDelParam, cloudwalkContext);
+                    throw new ServiceException("\u89c4\u5219\u521b\u5efa\u65b0\u589e\u5e94\u7528\u4e0e\u56fe\u5e93\u5173\u7cfb\u5931\u8d25");
+                }
+                AttendBindImagestoreAddDTO bindImagestoreAddDTO = new AttendBindImagestoreAddDTO();
+                bindImagestoreAddDTO.setId(this.genUUID());
+                bindImagestoreAddDTO.setRuleId(ruleId);
+                bindImagestoreAddDTO.setImageStoreId(imagestoreId);
+                this.attendBindImagestoreManager.add(bindImagestoreAddDTO);
+                return imagestoreId;
+            } else {
+                this.logger.info("\u8be5\u89c4\u5219\u5df2\u7ecf\u5b58\u5728\u8003\u52e4\u56fe\u5e93\uff0c\u76f4\u63a5\u4fee\u6539\u56fe\u5e93\u4e0b\u8ba2\u9605\u7684\u7ec4\u7ec7,businessId:{}\uff0c\u89c4\u5219ID\uff1a{}", (Object)cloudwalkContext.getCompany().getCompanyId(), (Object)ruleId);
+                imagestoreId = ((AttendBindImagestoreQueryResultDTO)bindList.get(0)).getImageStoreId();
+                ImageStoreEditParam storeEditParam = new ImageStoreEditParam();
+                storeEditParam.setImageStoreId(imagestoreId);
+                storeEditParam.setIncludeLabels(includeLabelIds);
+                storeEditParam.setExcludeLabels(excludeLabelIds);
+                storeEditParam.setIncludeOrganizations(orgIds);
+                storeEditParam.setName(imageStoreName);
+                this.imageStoreService.edit(storeEditParam, cloudwalkContext);
+            }
+            return imagestoreId;
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u4fdd\u5b58\u8003\u52e4\u56fe\u5e93\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private List<String> getRuleUsedOrgs(String ruleId, CloudwalkCallContext cloudwalkContext) throws DataAccessException {
+        AttendRuleGetsDTO ruleQueryDTO = new AttendRuleGetsDTO();
+        ruleQueryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+        ruleQueryDTO.setStatus(YesNoTypeEnum.Y.getCode());
+        ruleQueryDTO.setRuleIds(Collections.singletonList(ruleId));
+        List ruleList = this.attendRuleManager.gets(ruleQueryDTO);
+        ArrayList<String> returnOrgList = new ArrayList<String>();
+        if (CollectionUtils.isNotEmpty((Collection)ruleList)) {
+            AttendRuleOrgQueryDTO orgQueryDTO = new AttendRuleOrgQueryDTO();
+            orgQueryDTO.setRuleIds(ruleList.stream().map(AttendRuleQueryResultDTO::getId).collect(Collectors.toList()));
+            List orgList = this.attendRuleOrgManager.query(orgQueryDTO);
+            returnOrgList.addAll(orgList.stream().map(AttendRuleOrgQueryResultDTO::getOrgId).collect(Collectors.toList()));
+        }
+        AttendClassQueryDTO classQueryDTO = new AttendClassQueryDTO();
+        classQueryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+        classQueryDTO.setIsEnable(YesNoTypeEnum.Y.getCode());
+        classQueryDTO.setStatus(YesNoTypeEnum.Y.getCode());
+        classQueryDTO.setId(ruleId);
+        List classList = this.attendClassManager.query(classQueryDTO);
+        if (CollectionUtils.isNotEmpty((Collection)classList)) {
+            AttendClassOrgQueryDTO classOrgQueryDTO = new AttendClassOrgQueryDTO();
+            classOrgQueryDTO.setClassIds(classList.stream().map(AttendClassQueryResultDTO::getId).collect(Collectors.toList()));
+            List orgList = this.attendClassOrgManager.query(classOrgQueryDTO);
+            returnOrgList.addAll(orgList.stream().map(AttendClassOrgQueryResultDTO::getOrgId).collect(Collectors.toList()));
+        }
+        return returnOrgList;
+    }
+
+    @CloudwalkParamsValidate
+    public CloudwalkResult<List<String>> orgCheck(AttendOrgCheckParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        CloudwalkResult<List<String>> standList = this.standOrgCheck(param, cloudwalkContext);
+        CloudwalkResult<List<String>> schedulingList = this.schedulingOrgCheck(param, cloudwalkContext);
+        ArrayList resultList = new ArrayList();
+        if (CollectionUtils.isNotEmpty((Collection)((Collection)standList.getData()))) {
+            resultList.addAll((Collection)standList.getData());
+        }
+        if (CollectionUtils.isNotEmpty((Collection)((Collection)schedulingList.getData()))) {
+            resultList.addAll((Collection)schedulingList.getData());
+        }
+        return CloudwalkResult.success(resultList);
+    }
+
+    private CloudwalkResult<List<String>> standOrgCheck(AttendOrgCheckParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            ArrayList<String> resultList = new ArrayList<String>(param.getOrgIds().size());
+            for (String orgId : param.getOrgIds()) {
+                AttendRuleOrgQueryDTO orgQueryDTO = new AttendRuleOrgQueryDTO();
+                orgQueryDTO.setOrgId(orgId);
+                List queryOrgResultList = this.attendRuleOrgManager.query(orgQueryDTO);
+                if (CollectionUtils.isEmpty((Collection)queryOrgResultList)) continue;
+                List ruleIds = queryOrgResultList.stream().map(AttendRuleOrgQueryResultDTO::getRuleId).collect(Collectors.toList());
+                AttendRuleGetsDTO ruleGetsDTO = new AttendRuleGetsDTO();
+                ruleGetsDTO.setRuleIds(ruleIds);
+                ruleGetsDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+                ruleGetsDTO.setStatus(YesNoTypeEnum.Y.getCode());
+                List ruleResultList = this.attendRuleManager.gets(ruleGetsDTO);
+                if (CollectionUtils.isEmpty((Collection)ruleResultList)) continue;
+                String tmpRuleId = (String)ruleResultList.stream().map(AttendRuleQueryResultDTO::getId).collect(Collectors.toList()).get(0);
+                if (StringUtils.isEmpty((String)param.getRuleId()) && !StringUtils.isBlank((String)tmpRuleId)) {
+                    resultList.add(orgId);
+                    continue;
+                }
+                if (StringUtils.equals((String)tmpRuleId, (String)param.getRuleId())) continue;
+                resultList.add(orgId);
+            }
+            return CloudwalkResult.success(resultList);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u6807\u51c6\u8003\u52e4\u89c4\u5219\u7ec4\u7ec7\u6821\u9a8c\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private CloudwalkResult<List<String>> schedulingOrgCheck(AttendOrgCheckParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            ArrayList<String> resultList = new ArrayList<String>(param.getOrgIds().size());
+            for (String orgId : param.getOrgIds()) {
+                AttendClassOrgQueryDTO orgQueryDTO = new AttendClassOrgQueryDTO();
+                orgQueryDTO.setOrgIds(Collections.singletonList(orgId));
+                List orgQueryResultList = this.attendClassOrgManager.query(orgQueryDTO);
+                if (CollectionUtils.isEmpty((Collection)orgQueryResultList)) continue;
+                List classIds = orgQueryResultList.stream().map(AttendClassOrgQueryResultDTO::getClassId).collect(Collectors.toList());
+                AttendClassQueryDTO queryDTO = new AttendClassQueryDTO();
+                queryDTO.setIds(classIds);
+                queryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+                queryDTO.setStatus(YesNoTypeEnum.Y.getCode());
+                List classResultList = this.attendClassManager.query(queryDTO);
+                if (CollectionUtils.isEmpty((Collection)classResultList)) continue;
+                String tmpClassId = ((AttendClassQueryResultDTO)classResultList.get(0)).getId();
+                if (StringUtils.isEmpty((String)param.getRuleId()) && !StringUtils.isBlank((String)tmpClassId)) {
+                    resultList.add(orgId);
+                    continue;
+                }
+                if (StringUtils.equals((String)tmpClassId, (String)param.getRuleId())) continue;
+                resultList.add(orgId);
+            }
+            return CloudwalkResult.success(resultList);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u5f39\u6027\u8003\u52e4\u89c4\u5219\u7ec4\u7ec7\u6821\u9a8c\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    protected void ruleDeleteCwos(String id, CloudwalkCallContext cloudwalkContext) throws DataAccessException, ServiceException {
+        List<String> deviceIds = this.getDeviceIdsByRuleId(id, cloudwalkContext);
+        List<String> imagestoreIds = this.getImagestoreidsByRuleId(id, cloudwalkContext);
+        if (CollectionUtils.isNotEmpty(deviceIds) && CollectionUtils.isNotEmpty(imagestoreIds)) {
+            this.deleteDeviceImagestoreRel(deviceIds, imagestoreIds, cloudwalkContext);
+            String applicationId = this.applicationService.getApplicationId(cloudwalkContext.getCompany().getCompanyId());
+            this.deleteDeviceApplicationRel(applicationId, deviceIds, cloudwalkContext);
+            this.deleteAppImagestoreRel(applicationId, imagestoreIds, cloudwalkContext);
+        }
+    }
+
+    protected void classDeleteCwos(String id, CloudwalkCallContext cloudwalkContext) throws ServiceException, DataAccessException {
+        List<String> deviceIds = this.getDeviceIdsByClassId(id, cloudwalkContext);
+        List<String> imagestoreIds = this.getImagestoreidsByClassId(id, cloudwalkContext);
+        if (CollectionUtils.isNotEmpty(deviceIds) && CollectionUtils.isNotEmpty(imagestoreIds)) {
+            this.deleteDeviceImagestoreRel(deviceIds, imagestoreIds, cloudwalkContext);
+            String applicationId = this.applicationService.getApplicationId(cloudwalkContext.getCompany().getCompanyId());
+            this.deleteDeviceApplicationRel(applicationId, deviceIds, cloudwalkContext);
+            this.deleteAppImagestoreRel(applicationId, imagestoreIds, cloudwalkContext);
+        }
+    }
+
+    protected void ruleEditCwos(String id, List<String> deviceIds, CloudwalkCallContext cloudwalkContext) throws ServiceException, DataAccessException {
+        List<String> imagestoreIds = this.getImagestoreidsByRuleId(id, cloudwalkContext);
+        if (CollectionUtils.isNotEmpty(deviceIds) && CollectionUtils.isNotEmpty(imagestoreIds)) {
+            this.deleteDeviceImagestoreRel(deviceIds, imagestoreIds, cloudwalkContext);
+            String applicationId = this.applicationService.getApplicationId(cloudwalkContext.getCompany().getCompanyId());
+            this.deleteDeviceApplicationRel(applicationId, deviceIds, cloudwalkContext);
+        }
+    }
+
+    protected void classEditCwos(String id, List<String> deviceIds, CloudwalkCallContext cloudwalkContext) throws ServiceException, DataAccessException {
+        List<String> imagestoreIds = this.getImagestoreidsByClassId(id, cloudwalkContext);
+        if (CollectionUtils.isNotEmpty(deviceIds) && CollectionUtils.isNotEmpty(imagestoreIds)) {
+            this.deleteDeviceImagestoreRel(deviceIds, imagestoreIds, cloudwalkContext);
+            String applicationId = this.applicationService.getApplicationId(cloudwalkContext.getCompany().getCompanyId());
+            this.deleteDeviceApplicationRel(applicationId, deviceIds, cloudwalkContext);
+        }
+    }
+
+    private List<String> getImagestoreidsByRuleId(String id, CloudwalkCallContext cloudwalkContext) throws DataAccessException {
+        AttendBindImagestoreQueryDTO imagestoreQueryDTO = new AttendBindImagestoreQueryDTO();
+        imagestoreQueryDTO.setRuleId(id);
+        List queryImagestoreList = this.attendBindImagestoreManager.query(imagestoreQueryDTO);
+        if (CollectionUtils.isEmpty((Collection)queryImagestoreList)) {
+            return null;
+        }
+        return queryImagestoreList.stream().map(AttendBindImagestoreQueryResultDTO::getImageStoreId).collect(Collectors.toList());
+    }
+
+    private List<String> getDeviceIdsByRuleId(String id, CloudwalkCallContext cloudwalkContext) throws DataAccessException {
+        AttendRuleDeviceQueryDTO deviceQueryDTO = new AttendRuleDeviceQueryDTO();
+        deviceQueryDTO.setRuleId(id);
+        List queryDeviceList = this.attendRuleDeviceManager.query(deviceQueryDTO);
+        if (CollectionUtils.isEmpty((Collection)queryDeviceList)) {
+            return null;
+        }
+        return queryDeviceList.stream().map(AttendRuleDeviceQueryResultDTO::getDeviceId).collect(Collectors.toList());
+    }
+
+    private List<String> getImagestoreidsByClassId(String id, CloudwalkCallContext cloudwalkContext) throws DataAccessException {
+        AttendBindImagestoreQueryDTO imagestoreQueryDTO = new AttendBindImagestoreQueryDTO();
+        imagestoreQueryDTO.setRuleId(id);
+        List queryImagestoreList = this.attendBindImagestoreManager.query(imagestoreQueryDTO);
+        if (CollectionUtils.isEmpty((Collection)queryImagestoreList)) {
+            return null;
+        }
+        return queryImagestoreList.stream().map(AttendBindImagestoreQueryResultDTO::getImageStoreId).collect(Collectors.toList());
+    }
+
+    private List<String> getDeviceIdsByClassId(String id, CloudwalkCallContext cloudwalkContext) throws DataAccessException {
+        AttendClassDeviceQueryDTO deviceQueryDTO = new AttendClassDeviceQueryDTO();
+        deviceQueryDTO.setClassId(id);
+        List queryDeviceList = this.attendClassDeviceManager.query(deviceQueryDTO);
+        if (CollectionUtils.isEmpty((Collection)queryDeviceList)) {
+            return null;
+        }
+        return queryDeviceList.stream().map(AttendClassDeviceQueryResultDTO::getDeviceId).collect(Collectors.toList());
+    }
+
+    private void deleteDeviceImagestoreRel(List<String> deviceIds, List<String> imagestoreIds, CloudwalkCallContext context) throws ServiceException {
+        if (CollectionUtils.isNotEmpty(deviceIds) && CollectionUtils.isNotEmpty(imagestoreIds)) {
+            for (String deviceId : deviceIds) {
+                for (String imagestoreId : imagestoreIds) {
+                    DeviceImageStoreParam deleteParam = new DeviceImageStoreParam();
+                    deleteParam.setDeviceId(deviceId);
+                    deleteParam.setImageStoreId(imagestoreId);
+                    CloudwalkResult deleteResult = this.deviceImageStoreService.delete(deleteParam, context);
+                    if (deleteResult.isSuccess()) continue;
+                    this.logger.error("\u5220\u9664\u8bbe\u5907\u4e0e\u56fe\u5e93\u5173\u7cfb\u5931\u8d25\uff0c\u539f\u56e0\uff1a{}", (Object)deleteResult.getMessage());
+                    throw new ServiceException("\u5220\u9664\u8bbe\u5907\u4e0e\u56fe\u5e93\u5173\u7cfb\u5931\u8d25");
+                }
+            }
+        }
+    }
+
+    private void deleteAppImagestoreRel(String applicationId, List<String> imagestoreIds, CloudwalkCallContext cloudwalkContext) throws DataAccessException, ServiceException {
+        for (String imagestoreId : imagestoreIds) {
+            ApplicationImageStoreDelParam applicationImageStoreDelParam = new ApplicationImageStoreDelParam();
+            applicationImageStoreDelParam.setApplicationId(applicationId);
+            applicationImageStoreDelParam.setImageStoreId(imagestoreId);
+            CloudwalkResult appImagestoreDeleteResult = this.applicationImageStoreService.delete(applicationImageStoreDelParam, cloudwalkContext);
+            if (!appImagestoreDeleteResult.isSuccess()) {
+                this.logger.error("\u5220\u9664\u5e94\u7528\u4e0e\u56fe\u5e93\u5173\u7cfb\u5931\u8d25\uff0c\u539f\u56e0\uff1a{}", (Object)appImagestoreDeleteResult.getMessage());
+                throw new ServiceException("\u5220\u9664\u5e94\u7528\u4e0e\u56fe\u5e93\u5173\u7cfb\u5931\u8d25");
+            }
+            ImageStoreDelParam imageStoreDelParam = new ImageStoreDelParam();
+            imageStoreDelParam.setId(imagestoreId);
+            CloudwalkResult imagestoreDeleteResult = this.imageStoreService.delete(imageStoreDelParam, cloudwalkContext);
+            if (!imagestoreDeleteResult.isSuccess()) {
+                this.logger.error("\u5220\u9664\u56fe\u5e93\u5931\u8d25\uff0c\u539f\u56e0\uff1a{}", (Object)imagestoreDeleteResult.getMessage());
+                throw new ServiceException("\u5220\u9664\u56fe\u5e93\u5931\u8d25");
+            }
+            AttendBindImagestoreDeleteDTO bindImagestoreDeleteDTO = new AttendBindImagestoreDeleteDTO();
+            bindImagestoreDeleteDTO.setImageStoreId(imagestoreId);
+            this.attendBindImagestoreManager.delete(bindImagestoreDeleteDTO);
+        }
+    }
+
+    private void deleteDeviceApplicationRel(String applicationId, List<String> deviceIds, CloudwalkCallContext cloudwalkContext) throws DataAccessException, ServiceException {
+        for (String deviceId : deviceIds) {
+            if (!this.deviceCanDelete(deviceId)) continue;
+            DeviceApplicationParam deviceApplicationParam = new DeviceApplicationParam();
+            deviceApplicationParam.setApplicationId(applicationId);
+            deviceApplicationParam.setDeviceId(deviceId);
+            CloudwalkResult deleteResult = this.deviceApplicationService.delete(deviceApplicationParam, cloudwalkContext);
+            if (deleteResult.isSuccess()) continue;
+            this.logger.error("\u5220\u9664\u8bbe\u5907\u4e0e\u5e94\u7528\u5173\u7cfb\u5931\u8d25\uff0c\u539f\u56e0\uff1a{}", (Object)deleteResult.getMessage());
+            throw new ServiceException("\u5220\u9664\u8bbe\u5907\u4e0e\u5e94\u7528\u5173\u7cfb\u5931\u8d25");
+        }
+    }
+
+    private boolean deviceCanDelete(String deviceId) throws DataAccessException {
+        AttendRuleDeviceQueryDTO deviceQueryDTO = new AttendRuleDeviceQueryDTO();
+        deviceQueryDTO.setDeviceId(deviceId);
+        List deviceQueryResultList = this.attendRuleDeviceManager.query(deviceQueryDTO);
+        if (CollectionUtils.isNotEmpty((Collection)deviceQueryResultList)) {
+            List ruleIds = deviceQueryResultList.stream().map(AttendRuleDeviceQueryResultDTO::getRuleId).collect(Collectors.toList());
+            AttendRuleGetsDTO ruleGetsDTO = new AttendRuleGetsDTO();
+            ruleGetsDTO.setRuleIds(ruleIds);
+            List getsRuleList = this.attendRuleManager.gets(ruleGetsDTO);
+            List filterResultList = getsRuleList.stream().filter(item -> item.getStatus().equals(YesNoTypeEnum.Y.getCode())).collect(Collectors.toList());
+            if (CollectionUtils.isNotEmpty(filterResultList)) {
+                return false;
+            }
+        }
+        AttendClassDeviceQueryDTO classDeviceQueryDTO = new AttendClassDeviceQueryDTO();
+        classDeviceQueryDTO.setDeviceId(deviceId);
+        List classDeviceList = this.attendClassDeviceManager.query(classDeviceQueryDTO);
+        if (CollectionUtils.isNotEmpty((Collection)classDeviceList)) {
+            List classIds = classDeviceList.stream().map(AttendClassDeviceQueryResultDTO::getClassId).collect(Collectors.toList());
+            AttendClassGetsDTO classGetsDTO = new AttendClassGetsDTO();
+            classGetsDTO.setIds(classIds);
+            List getsClassList = this.attendClassManager.gets(classGetsDTO);
+            List filterResultList = getsClassList.stream().filter(item -> item.getStatus().equals(YesNoTypeEnum.Y.getCode())).collect(Collectors.toList());
+            return !CollectionUtils.isNotEmpty(filterResultList);
+        }
+        return true;
+    }
+
+    private void deleteDeviceImageStoreRef(List<String> deviceIds, String imagestoreId, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        for (String deviceId : deviceIds) {
+            DeviceImageStoreQueryParam storeQueryParam = new DeviceImageStoreQueryParam();
+            storeQueryParam.setDeviceId(deviceId);
+            storeQueryParam.setImageStoreId(imagestoreId);
+            CloudwalkResult deviceQueryResult = this.deviceImageStoreService.list(storeQueryParam, cloudwalkContext);
+            if (CollectionUtils.isNotEmpty((Collection)((Collection)deviceQueryResult.getData()))) {
+                DeviceImageStoreParam imageStoreSaveParam = new DeviceImageStoreParam();
+                imageStoreSaveParam.setDeviceId(deviceId);
+                imageStoreSaveParam.setImageStoreId(imagestoreId);
+                CloudwalkResult saveDeviceResult = this.deviceImageStoreService.delete(imageStoreSaveParam, cloudwalkContext);
+                if (saveDeviceResult.isSuccess()) continue;
+                this.logger.error("\u5220\u9664\u8bbe\u5907\u4e0e\u56fe\u5e93\u5173\u7cfb\u5931\u8d25\uff0c\u539f\u56e0\uff1a{}", (Object)saveDeviceResult.getMessage());
+                continue;
+            }
+            this.logger.info("\u8bbe\u5907\uff1a{}\u4e0e\u56fe\u5e93\uff1a{}\u5173\u7cfb\u4e0d\u5b58\u5728\u65e0\u987b\u5220\u9664", (Object)deviceId, (Object)imagestoreId);
+        }
+    }
+
+    private void deleteAppImageStoreRef(String applicationId, String imagestoreId, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        ApplicationImageStoreQueryParam applicationQueryParam = new ApplicationImageStoreQueryParam();
+        applicationQueryParam.setImageStoreId(imagestoreId);
+        applicationQueryParam.setApplicationId(applicationId);
+        CloudwalkResult applicationQueryResult = this.applicationImageStoreService.list(applicationQueryParam, cloudwalkContext);
+        if (CollectionUtils.isNotEmpty((Collection)((Collection)applicationQueryResult.getData()))) {
+            ApplicationImageStoreDelParam applicationParam = new ApplicationImageStoreDelParam();
+            applicationParam.setApplicationId(applicationId);
+            applicationParam.setImageStoreId(imagestoreId);
+            CloudwalkResult addApplicationResult = this.applicationImageStoreService.delete(applicationParam, cloudwalkContext);
+            if (!addApplicationResult.isSuccess()) {
+                this.logger.error("\u5220\u9664\u5e94\u7528\u4e0e\u56fe\u5e93\u5173\u7cfb\u5931\u8d25\uff0c\u539f\u56e0\uff1a{}", (Object)addApplicationResult.getMessage());
+            }
+        } else {
+            this.logger.info("\u56fe\u5e93:{}\u4e0e\u5e94\u7528\uff1a{}\u5173\u7cfb\u4e0d\u5b58\u5728\u65e0\u987b\u5220\u9664", (Object)imagestoreId, (Object)applicationId);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/common/AbstractCloudwalkService.java

@@ -0,0 +1,50 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.cloud.serial.UUIDSerial
+ *  cn.cloudwalk.cloud.utils.CloudwalkDateUtils
+ *  cn.cloudwalk.serial.code.AbstractGeneralCode
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.context.MessageSource
+ *  org.springframework.context.i18n.LocaleContextHolder
+ */
+package cn.cloudwalk.service.ninca.attendance.common;
+
+import cn.cloudwalk.cloud.serial.UUIDSerial;
+import cn.cloudwalk.cloud.utils.CloudwalkDateUtils;
+import cn.cloudwalk.serial.code.AbstractGeneralCode;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.MessageSource;
+import org.springframework.context.i18n.LocaleContextHolder;
+
+public class AbstractCloudwalkService {
+    protected final Logger logger = LoggerFactory.getLogger(this.getClass());
+    private static final int GENGRAL_CODE_LENGTH = 8;
+    @Autowired
+    private MessageSource messageSource;
+    @Autowired
+    protected AbstractGeneralCode generalCode;
+    @Autowired(required=false)
+    private UUIDSerial uuidSerial;
+
+    public String getMessage(String code) {
+        return this.messageSource.getMessage(code, null, "", LocaleContextHolder.getLocale());
+    }
+
+    public String createGeneralCode() {
+        return this.generalCode.generalCode(CloudwalkDateUtils.getDate8YMD(), Integer.valueOf(8));
+    }
+
+    public String genUUID() {
+        if (null != this.uuidSerial) {
+            return this.uuidSerial.uuid();
+        }
+        return CloudwalkDateUtils.getUUID();
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/common/AttendApplicationServiceImpl.java

@@ -0,0 +1,59 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.common.AttendApplicationService
+ *  cn.cloudwalk.client.resource.application.param.ApplicationQueryParam
+ *  cn.cloudwalk.client.resource.application.result.ApplicationResult
+ *  cn.cloudwalk.client.resource.application.service.ApplicationService
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  javax.annotation.Resource
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.cache.annotation.Cacheable
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.common;
+
+import cn.cloudwalk.client.ninca.attendance.common.AttendApplicationService;
+import cn.cloudwalk.client.resource.application.param.ApplicationQueryParam;
+import cn.cloudwalk.client.resource.application.result.ApplicationResult;
+import cn.cloudwalk.client.resource.application.service.ApplicationService;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import java.util.Collection;
+import java.util.List;
+import javax.annotation.Resource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendApplicationServiceImpl
+implements AttendApplicationService {
+    private static final Logger logger = LoggerFactory.getLogger(AttendApplicationServiceImpl.class);
+    @Resource
+    private ApplicationService applicationService;
+
+    @Cacheable(cacheNames={"ApplicationIdsCache"}, key="T(cn.cloudwalk.biz.intelligent.ninca.common.AttendCacheOverrideConfig).CACHE_KEY_APPLICATION_IDS_PREFIX + #businessId")
+    public String getApplicationId(String businessId) throws ServiceException {
+        ApplicationQueryParam param = new ApplicationQueryParam();
+        param.setBusinessId(businessId);
+        param.setServiceCode("smart-attendance");
+        CloudwalkResult cloudwalkResult = this.applicationService.query(param);
+        if (cloudwalkResult.isSuccess()) {
+            if (CollectionUtils.isNotEmpty((Collection)((Collection)cloudwalkResult.getData()))) {
+                return ((ApplicationResult)((List)cloudwalkResult.getData()).get(0)).getId();
+            }
+            logger.info("\u672a\u67e5\u5230applicationId");
+            throw new ServiceException("76240005", "\u672a\u67e5\u5230applicationId");
+        }
+        logger.info("\u67e5\u8be2applicationId\u5931\u8d25,\u539f\u56e0\uff1a{}", (Object)cloudwalkResult.getMessage());
+        throw new ServiceException("76240006", "\u67e5\u8be2applicationId\u5931\u8d25");
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/common/AttendCommonCommonDeviceServiceImpl.java

@@ -0,0 +1,86 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.accesscontrol.setting.param.AcsDeviceAttrQueryParam
+ *  cn.cloudwalk.client.ninca.accesscontrol.setting.result.AcsDeviceSettingResult
+ *  cn.cloudwalk.client.ninca.accesscontrol.setting.result.AcsSettingAttr
+ *  cn.cloudwalk.client.ninca.accesscontrol.setting.service.AcsDeviceAttrService
+ *  cn.cloudwalk.client.ninca.attendance.common.AttendCommonDeviceService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.common.ninca.accesscontrol.em.AcsDeviceSettingEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean
+ *  org.springframework.cache.annotation.Cacheable
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.common;
+
+import cn.cloudwalk.client.ninca.accesscontrol.setting.param.AcsDeviceAttrQueryParam;
+import cn.cloudwalk.client.ninca.accesscontrol.setting.result.AcsDeviceSettingResult;
+import cn.cloudwalk.client.ninca.accesscontrol.setting.result.AcsSettingAttr;
+import cn.cloudwalk.client.ninca.accesscontrol.setting.service.AcsDeviceAttrService;
+import cn.cloudwalk.client.ninca.attendance.common.AttendCommonDeviceService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.common.ninca.accesscontrol.em.AcsDeviceSettingEnum;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.math.BigDecimal;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendCommonCommonDeviceServiceImpl
+extends AbstractCloudwalkService
+implements AttendCommonDeviceService {
+    @Autowired
+    private AcsDeviceAttrService acsDeviceAttrService;
+
+    @Cacheable(cacheNames={"DeviceThresholdCache"}, key="T(cn.cloudwalk.biz.intelligent.ninca.common.AttendCacheOverrideConfig).CACHE_KEY_DEVICE_THRESHOLD_IDS_PREFIX + #deviceId", unless="#result == null")
+    public BigDecimal getDeviceThreshold(String deviceId, CloudwalkCallContext context) throws ServiceException {
+        try {
+            AcsDeviceAttrQueryParam queryParam = new AcsDeviceAttrQueryParam();
+            queryParam.setDeviceId(deviceId);
+            CloudwalkResult result = this.acsDeviceAttrService.query(queryParam, context);
+            if (result.isSuccess() && result.getData() != null) {
+                return this.getResult((AcsDeviceSettingResult)result.getData());
+            }
+            return null;
+        }
+        catch (Exception e) {
+            this.logger.error("\u67e5\u8be2\u8bbe\u5907\u9608\u503c\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private BigDecimal getResult(AcsDeviceSettingResult deviceSettingResult) {
+        if (CollectionUtils.isNotEmpty((Collection)deviceSettingResult.getAttrs())) {
+            List settingsList = deviceSettingResult.getAttrs().stream().filter(s -> AcsDeviceSettingEnum.ACS_FACE_REG_THRESHOLD.getCode().equals(s.getCode())).collect(Collectors.toList());
+            String threshold = null;
+            if (CollectionUtils.isNotEmpty(settingsList) && (threshold = ((AcsSettingAttr)settingsList.get(0)).getValue()) != null) {
+                return new BigDecimal(threshold);
+            }
+        }
+        return null;
+    }
+
+    @Service
+    @ConditionalOnMissingBean(value={AcsDeviceAttrService.class})
+    public static class AcsDeviceAttrServiceImpl
+    implements AcsDeviceAttrService {
+        public CloudwalkResult<AcsDeviceSettingResult> query(AcsDeviceAttrQueryParam acsDeviceAttrQueryParam, CloudwalkCallContext cloudwalkCallContext) {
+            return CloudwalkResult.success(null);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/common/AttendanceProperties.java

@@ -0,0 +1,62 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  org.springframework.boot.context.properties.ConfigurationProperties
+ *  org.springframework.stereotype.Component
+ */
+package cn.cloudwalk.service.ninca.attendance.common;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+@ConfigurationProperties(prefix="cloudwalk.smart-attendance")
+@Component
+public class AttendanceProperties {
+    private String cwosPicUrl;
+    private double captureDeviceThreshold = 80.0;
+    private boolean recordPush = false;
+    private String recordPushServiceCode;
+    private int schedulingPublishExecuteCap = 500;
+
+    public String getCwosPicUrl() {
+        return this.cwosPicUrl;
+    }
+
+    public void setCwosPicUrl(String cwosPicUrl) {
+        this.cwosPicUrl = cwosPicUrl;
+    }
+
+    public double getCaptureDeviceThreshold() {
+        return this.captureDeviceThreshold;
+    }
+
+    public void setCaptureDeviceThreshold(double captureDeviceThreshold) {
+        this.captureDeviceThreshold = captureDeviceThreshold;
+    }
+
+    public boolean isRecordPush() {
+        return this.recordPush;
+    }
+
+    public void setRecordPush(boolean recordPush) {
+        this.recordPush = recordPush;
+    }
+
+    public String getRecordPushServiceCode() {
+        return this.recordPushServiceCode;
+    }
+
+    public void setRecordPushServiceCode(String recordPushServiceCode) {
+        this.recordPushServiceCode = recordPushServiceCode;
+    }
+
+    public int getSchedulingPublishExecuteCap() {
+        return this.schedulingPublishExecuteCap;
+    }
+
+    public void setSchedulingPublishExecuteCap(int schedulingPublishExecuteCap) {
+        this.schedulingPublishExecuteCap = schedulingPublishExecuteCap;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/common/job/AbstractJobService.java

@@ -0,0 +1,60 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.session.company.CompanyContext
+ *  cn.cloudwalk.cloud.session.user.UserContext
+ */
+package cn.cloudwalk.service.ninca.attendance.common.job;
+
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.session.company.CompanyContext;
+import cn.cloudwalk.cloud.session.user.UserContext;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class AbstractJobService
+extends AbstractCloudwalkService {
+    private static final Integer GROUP_COUNT = 3;
+    private static final Integer MIN_GROUP_COUNT = 9;
+
+    protected Map<Integer, List<String>> groupBy(List<String> businessIdList) {
+        HashMap<Integer, List<String>> resMap = new HashMap<Integer, List<String>>(GROUP_COUNT);
+        if (businessIdList.size() <= MIN_GROUP_COUNT) {
+            resMap.put(0, businessIdList);
+            return resMap;
+        }
+        int page = GROUP_COUNT;
+        int pageSize = businessIdList.size() / GROUP_COUNT;
+        if (businessIdList.size() % GROUP_COUNT != 0) {
+            ++page;
+        }
+        for (int i = 0; i < page; ++i) {
+            if ((i + 1) * pageSize > businessIdList.size()) {
+                resMap.put(i, businessIdList.subList(i * pageSize, businessIdList.size()));
+                continue;
+            }
+            resMap.put(i, businessIdList.subList(i * pageSize, (i + 1) * pageSize));
+        }
+        return resMap;
+    }
+
+    protected CloudwalkCallContext getCloudwalkCallContext(String businessId) {
+        UserContext userContext = new UserContext();
+        userContext.setCaller("default");
+        userContext.setCallerName("default");
+        CompanyContext companyContext = new CompanyContext();
+        companyContext.setCompanyId(businessId);
+        CloudwalkCallContext context = new CloudwalkCallContext();
+        context.setCompany(companyContext);
+        context.setUser(userContext);
+        context.setCallTime(new Date());
+        context.setApplicationId(null);
+        return context;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/common/job/AttendJobInit.java

@@ -0,0 +1,91 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  cn.cloudwalk.task.listener.CommonJobListener
+ *  cn.cloudwalk.task.sdk.client.TaskExecClient
+ *  cn.cloudwalk.task.sdk.dto.JobDetailParam
+ *  cn.cloudwalk.task.sdk.dto.JobDetailResult
+ *  org.quartz.JobListener
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.boot.CommandLineRunner
+ *  org.springframework.stereotype.Component
+ */
+package cn.cloudwalk.service.ninca.attendance.common.job;
+
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.attendance.common.job.config.AttendJobProperties;
+import cn.cloudwalk.service.ninca.attendance.common.job.config.JobSetting;
+import cn.cloudwalk.task.listener.CommonJobListener;
+import cn.cloudwalk.task.sdk.client.TaskExecClient;
+import cn.cloudwalk.task.sdk.dto.JobDetailParam;
+import cn.cloudwalk.task.sdk.dto.JobDetailResult;
+import java.util.Map;
+import org.quartz.JobListener;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.stereotype.Component;
+
+@Component
+public class AttendJobInit
+implements CommandLineRunner {
+    private final Logger logger = LoggerFactory.getLogger(this.getClass());
+    private static final String ERROR_STATE = "ERROR";
+    @Autowired
+    private TaskExecClient client;
+    @Autowired
+    private AttendJobProperties jobProperties;
+    @Autowired
+    private CommonJobListener jobListener;
+
+    public void run(String ... strings) throws Exception {
+        Map<String, JobSetting> jobs = this.jobProperties.getJobs();
+        if (CollectionUtils.isNotEmpty(jobs)) {
+            this.logger.info("\u5f00\u59cb\u521d\u59cb\u5316\u5b9a\u65f6\u4efb\u52a1...");
+            for (Map.Entry<String, JobSetting> entry : jobs.entrySet()) {
+                JobDetailResult job;
+                JobSetting setting = entry.getValue();
+                JobDetailParam param = new JobDetailParam();
+                param.setJobName(setting.getName());
+                param.setJobGroup(setting.getGroup());
+                if (setting.isDelete()) {
+                    try {
+                        this.client.removeJob(param);
+                    }
+                    catch (Exception e) {
+                        this.logger.warn("delete job error.", (Throwable)e);
+                    }
+                    continue;
+                }
+                param.setClazz(Class.forName(setting.getExecutableClass()));
+                param.setJobListener((JobListener)this.jobListener);
+                param.setStartTime(Long.valueOf(System.currentTimeMillis()));
+                param.setJobDescription(setting.getDescription());
+                param.setRetry(Boolean.valueOf(true));
+                param.setPriority(setting.getPriority());
+                param.setExpression(setting.getCronExpression());
+                if (setting.getDataMap() != null && setting.getDataMap().size() > 0) {
+                    param.setDataMap(setting.getDataMap());
+                }
+                if ((job = this.client.getJob(param)) == null) {
+                    this.client.addJob(param, true);
+                    this.logger.info("\u4efb\u52a1[{}] \u6dfb\u52a0\u6210\u529f.", (Object)param.getJobName());
+                    continue;
+                }
+                if (ERROR_STATE.equals(job.getState())) {
+                    this.logger.warn("\u4efb\u52a1[{}] \u72b6\u6001\u4e0d\u6b63\u786e\uff0c\u91cd\u65b0\u6dfb\u52a0...", (Object)param.getJobName());
+                    this.client.addJob(param, true);
+                    continue;
+                }
+                this.client.modifyJobTime(param);
+                this.client.addListener(param);
+            }
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/common/job/config/AttendJobProperties.java

@@ -0,0 +1,28 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  org.springframework.boot.context.properties.ConfigurationProperties
+ *  org.springframework.stereotype.Component
+ */
+package cn.cloudwalk.service.ninca.attendance.common.job.config;
+
+import cn.cloudwalk.service.ninca.attendance.common.job.config.JobSetting;
+import java.util.Map;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+@Component
+@ConfigurationProperties(prefix="cloudwalk.smart-attendance.schedual")
+public class AttendJobProperties {
+    private Map<String, JobSetting> jobs;
+
+    public Map<String, JobSetting> getJobs() {
+        return this.jobs;
+    }
+
+    public void setJobs(Map<String, JobSetting> jobs) {
+        this.jobs = jobs;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/common/job/config/JobSetting.java

@@ -0,0 +1,82 @@
+/*
+ * Decompiled with CFR 0.152.
+ */
+package cn.cloudwalk.service.ninca.attendance.common.job.config;
+
+import java.util.HashMap;
+
+public class JobSetting {
+    private String name;
+    private String group;
+    private String executableClass;
+    private String description;
+    private String cronExpression;
+    private Integer priority;
+    private HashMap<String, Object> dataMap;
+    private boolean delete;
+
+    public String getName() {
+        return this.name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getGroup() {
+        return this.group;
+    }
+
+    public void setGroup(String group) {
+        this.group = group;
+    }
+
+    public String getExecutableClass() {
+        return this.executableClass;
+    }
+
+    public void setExecutableClass(String executableClass) {
+        this.executableClass = executableClass;
+    }
+
+    public String getDescription() {
+        return this.description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public String getCronExpression() {
+        return this.cronExpression;
+    }
+
+    public void setCronExpression(String cronExpression) {
+        this.cronExpression = cronExpression;
+    }
+
+    public HashMap<String, Object> getDataMap() {
+        return this.dataMap;
+    }
+
+    public void setDataMap(HashMap<String, Object> dataMap) {
+        this.dataMap = dataMap;
+    }
+
+    public Integer getPriority() {
+        return this.priority;
+    }
+
+    public void setPriority(Integer priority) {
+        this.priority = priority;
+    }
+
+    public boolean isDelete() {
+        return this.delete;
+    }
+
+    public void setDelete(boolean delete) {
+        this.delete = delete;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/common/job/executable/AttendDayReportJob.java

@@ -0,0 +1,32 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.report.service.AttendDayReportTaskService
+ *  cn.cloudwalk.task.sdk.starter.job.AbstractJob
+ *  javax.annotation.Resource
+ *  org.quartz.JobExecutionContext
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ */
+package cn.cloudwalk.service.ninca.attendance.common.job.executable;
+
+import cn.cloudwalk.client.ninca.attendance.report.service.AttendDayReportTaskService;
+import cn.cloudwalk.task.sdk.starter.job.AbstractJob;
+import javax.annotation.Resource;
+import org.quartz.JobExecutionContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class AttendDayReportJob
+extends AbstractJob {
+    private Logger logger = LoggerFactory.getLogger(((Object)((Object)this)).getClass());
+    @Resource
+    private AttendDayReportTaskService attendDayReportTaskService;
+
+    public void execute(JobExecutionContext jobExecutionContext) {
+        this.logger.info("\u5f00\u59cb\u6267\u884c\u8003\u52e4\u65e5\u62a5\u8868\u7ed3\u679c\u5b9a\u65f6\u4efb\u52a1");
+        this.attendDayReportTaskService.execute();
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/common/job/executable/AttendMonthReportJob.java

@@ -0,0 +1,32 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.report.service.AttendMonthReportTaskService
+ *  cn.cloudwalk.task.sdk.starter.job.AbstractJob
+ *  javax.annotation.Resource
+ *  org.quartz.JobExecutionContext
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ */
+package cn.cloudwalk.service.ninca.attendance.common.job.executable;
+
+import cn.cloudwalk.client.ninca.attendance.report.service.AttendMonthReportTaskService;
+import cn.cloudwalk.task.sdk.starter.job.AbstractJob;
+import javax.annotation.Resource;
+import org.quartz.JobExecutionContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class AttendMonthReportJob
+extends AbstractJob {
+    private Logger logger = LoggerFactory.getLogger(((Object)((Object)this)).getClass());
+    @Resource
+    private AttendMonthReportTaskService attendReportMonthTaskService;
+
+    public void execute(JobExecutionContext jobExecutionContext) {
+        this.logger.info("\u5f00\u59cb\u6267\u884c\u8003\u52e4\u6708\u62a5\u8868\u7ed3\u679c\u5b9a\u65f6\u4efb\u52a1");
+        this.attendReportMonthTaskService.execute();
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/common/job/executable/AttendResultJob.java

@@ -0,0 +1,32 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultInitTaskService
+ *  cn.cloudwalk.task.sdk.starter.job.AbstractJob
+ *  javax.annotation.Resource
+ *  org.quartz.JobExecutionContext
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ */
+package cn.cloudwalk.service.ninca.attendance.common.job.executable;
+
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultInitTaskService;
+import cn.cloudwalk.task.sdk.starter.job.AbstractJob;
+import javax.annotation.Resource;
+import org.quartz.JobExecutionContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class AttendResultJob
+extends AbstractJob {
+    private Logger logger = LoggerFactory.getLogger(((Object)((Object)this)).getClass());
+    @Resource
+    private AttendResultInitTaskService attendResultInitTaskService;
+
+    public void execute(JobExecutionContext jobExecutionContext) {
+        this.logger.info("\u5f00\u59cb\u6267\u884c\u8003\u52e4\u7ed3\u679c\u8bb0\u5f55\u521d\u59cb\u5316\u5b9a\u65f6\u4efb\u52a1");
+        this.attendResultInitTaskService.resultInit();
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/config/AttendCheckServiceImpl.java

@@ -0,0 +1,80 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendSchedulingManager
+ *  cn.cloudwalk.client.ninca.attendance.config.service.AttendCheckService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtil
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.config;
+
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendSchedulingManager;
+import cn.cloudwalk.client.ninca.attendance.config.service.AttendCheckService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtil;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendCheckServiceImpl
+extends AbstractCloudwalkService
+implements AttendCheckService {
+    @Resource
+    private AttendSchedulingManager attendSchedulingManager;
+
+    public CloudwalkResult<Boolean> checkShift(String shiftId, CloudwalkCallContext context) throws ServiceException {
+        try {
+            AttendSchedulingQueryDTO queryDTO = new AttendSchedulingQueryDTO();
+            queryDTO.setBusinessId(context.getCompany().getCompanyId());
+            queryDTO.setShiftId(shiftId);
+            queryDTO.setSchedulingDateStart(DateUtils.todayStart((Date)DateUtil.addDays((Date)new Date(), (int)1)));
+            List resultList = this.attendSchedulingManager.queryList(queryDTO);
+            if (CollectionUtils.isNotEmpty((Collection)resultList)) {
+                return CloudwalkResult.fail((String)"76240316", (String)this.getMessage("76240316"));
+            }
+            return CloudwalkResult.success((Object)true);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u4f7f\u7528\u4e2d\u7684\u73ed\u79cd\u4e0d\u80fd\u7981\u7528\u3001\u5220\u9664\u6821\u9a8c\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<Boolean> checkClass(String classId, CloudwalkCallContext context) throws ServiceException {
+        try {
+            AttendSchedulingQueryDTO queryDTO = new AttendSchedulingQueryDTO();
+            queryDTO.setBusinessId(context.getCompany().getCompanyId());
+            queryDTO.setClassId(classId);
+            queryDTO.setSchedulingDateStart(DateUtils.todayStart((Date)DateUtil.addDays((Date)new Date(), (int)1)));
+            List resultList = this.attendSchedulingManager.queryList(queryDTO);
+            if (CollectionUtils.isNotEmpty((Collection)resultList)) {
+                return CloudwalkResult.fail((String)"76240317", (String)this.getMessage("76240317"));
+            }
+            return CloudwalkResult.success((Object)true);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u4f7f\u7528\u4e2d\u7684\u73ed\u7ec4\u4e0d\u80fd\u7981\u7528\u3001\u5220\u9664\u6821\u9a8c\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/config/AttendClassDeviceServiceImpl.java

@@ -0,0 +1,94 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendClassDeviceManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.result.DeviceResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceService
+ *  cn.cloudwalk.client.ninca.attendance.config.param.AttendClassSubDetailQueryParam
+ *  cn.cloudwalk.client.ninca.attendance.config.result.AttendClassDeviceQueryResult
+ *  cn.cloudwalk.client.ninca.attendance.config.service.AttendClassDeviceService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassDeviceQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassDeviceQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.config;
+
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendClassDeviceManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.result.DeviceResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceService;
+import cn.cloudwalk.client.ninca.attendance.config.param.AttendClassSubDetailQueryParam;
+import cn.cloudwalk.client.ninca.attendance.config.result.AttendClassDeviceQueryResult;
+import cn.cloudwalk.client.ninca.attendance.config.service.AttendClassDeviceService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassDeviceQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassDeviceQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendClassDeviceServiceImpl
+extends AbstractCloudwalkService
+implements AttendClassDeviceService {
+    @Resource
+    private AttendClassDeviceManager attendClassDeviceManager;
+    @Resource
+    private DeviceService deviceService;
+
+    public CloudwalkResult<List<AttendClassDeviceQueryResult>> query(AttendClassSubDetailQueryParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            AttendClassDeviceQueryDTO queryDTO = new AttendClassDeviceQueryDTO();
+            queryDTO.setClassId(param.getClassId());
+            List queryResultList = this.attendClassDeviceManager.query(queryDTO);
+            if (CollectionUtils.isEmpty((Collection)queryResultList)) {
+                return CloudwalkResult.success(new ArrayList());
+            }
+            return CloudwalkResult.success(this.getQueryReturnList(queryResultList, cloudwalkContext));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u73ed\u7ec4\u8bbe\u5907\u67e5\u8be2\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private List<AttendClassDeviceQueryResult> getQueryReturnList(List<AttendClassDeviceQueryResultDTO> queryResultList, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        List deviceIds = queryResultList.stream().map(AttendClassDeviceQueryResultDTO::getDeviceId).collect(Collectors.toList());
+        DeviceQueryParam deviceQueryParam = new DeviceQueryParam();
+        deviceQueryParam.setIds(deviceIds);
+        CloudwalkResult deviceResult = this.deviceService.list(deviceQueryParam, cloudwalkContext);
+        Map<String, List<DeviceResult>> tmpDeviceMap = null;
+        if (deviceResult.isSuccess() && CollectionUtils.isNotEmpty((Collection)((Collection)deviceResult.getData()))) {
+            tmpDeviceMap = ((List)deviceResult.getData()).stream().collect(Collectors.groupingBy(DeviceResult::getId));
+        }
+        ArrayList<AttendClassDeviceQueryResult> returnList = new ArrayList<AttendClassDeviceQueryResult>(queryResultList.size());
+        for (AttendClassDeviceQueryResultDTO dto : queryResultList) {
+            AttendClassDeviceQueryResult result = (AttendClassDeviceQueryResult)BeanCopyUtils.copyProperties((Object)dto, AttendClassDeviceQueryResult.class);
+            if (tmpDeviceMap != null && CollectionUtils.isNotEmpty((Collection)tmpDeviceMap.get(dto.getDeviceId()))) {
+                result.setDeviceName(tmpDeviceMap.get(dto.getDeviceId()).get(0).getDeviceName());
+            }
+            returnList.add(result);
+        }
+        return returnList;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/config/AttendClassImagestoreServiceImpl.java

@@ -0,0 +1,94 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendClassImagestoreManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStoreQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.result.ImageStoreListResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.service.ImageStoreService
+ *  cn.cloudwalk.client.ninca.attendance.config.param.AttendClassSubDetailQueryParam
+ *  cn.cloudwalk.client.ninca.attendance.config.result.AttendClassImagestoreQueryResult
+ *  cn.cloudwalk.client.ninca.attendance.config.service.AttendClassImagestoreService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassImagestoreQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassImagestoreQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.config;
+
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendClassImagestoreManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStoreQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.result.ImageStoreListResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.service.ImageStoreService;
+import cn.cloudwalk.client.ninca.attendance.config.param.AttendClassSubDetailQueryParam;
+import cn.cloudwalk.client.ninca.attendance.config.result.AttendClassImagestoreQueryResult;
+import cn.cloudwalk.client.ninca.attendance.config.service.AttendClassImagestoreService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassImagestoreQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassImagestoreQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendClassImagestoreServiceImpl
+extends AbstractCloudwalkService
+implements AttendClassImagestoreService {
+    @Resource
+    private AttendClassImagestoreManager attendClassImagestoreManager;
+    @Resource
+    private ImageStoreService imageStoreService;
+
+    public CloudwalkResult<List<AttendClassImagestoreQueryResult>> query(AttendClassSubDetailQueryParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            AttendClassImagestoreQueryDTO queryDTO = new AttendClassImagestoreQueryDTO();
+            queryDTO.setClassId(param.getClassId());
+            List queryResultList = this.attendClassImagestoreManager.query(queryDTO);
+            if (CollectionUtils.isEmpty((Collection)queryResultList)) {
+                return CloudwalkResult.success(new ArrayList());
+            }
+            return CloudwalkResult.success(this.getQueryReturnList(queryResultList, cloudwalkContext));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u73ed\u7ec4\u56fe\u5e93\u67e5\u8be2\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private List<AttendClassImagestoreQueryResult> getQueryReturnList(List<AttendClassImagestoreQueryResultDTO> queryResultList, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        List imagestoreIds = queryResultList.stream().map(AttendClassImagestoreQueryResultDTO::getImageStoreId).collect(Collectors.toList());
+        ImageStoreQueryParam queryParam = new ImageStoreQueryParam();
+        queryParam.setIds(imagestoreIds);
+        CloudwalkResult imagestoreResult = this.imageStoreService.list(queryParam, cloudwalkContext);
+        Map<String, List<ImageStoreListResult>> tmpImagestoreMap = null;
+        if (imagestoreResult.isSuccess() && CollectionUtils.isNotEmpty((Collection)((Collection)imagestoreResult.getData()))) {
+            tmpImagestoreMap = ((List)imagestoreResult.getData()).stream().collect(Collectors.groupingBy(ImageStoreListResult::getId));
+        }
+        ArrayList<AttendClassImagestoreQueryResult> returnList = new ArrayList<AttendClassImagestoreQueryResult>(queryResultList.size());
+        for (AttendClassImagestoreQueryResultDTO dto : queryResultList) {
+            AttendClassImagestoreQueryResult result = (AttendClassImagestoreQueryResult)BeanCopyUtils.copyProperties((Object)dto, AttendClassImagestoreQueryResult.class);
+            if (tmpImagestoreMap != null && CollectionUtils.isNotEmpty((Collection)tmpImagestoreMap.get(dto.getImageStoreId()))) {
+                result.setImageStoreName(tmpImagestoreMap.get(dto.getImageStoreId()).get(0).getName());
+            }
+            returnList.add(result);
+        }
+        return returnList;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/config/AttendClassOrgServiceImpl.java

@@ -0,0 +1,95 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendClassOrgManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.organization.param.OrganizationListParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.organization.result.OrganizationResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.organization.service.OrganizationService
+ *  cn.cloudwalk.client.ninca.attendance.config.param.AttendClassSubDetailQueryParam
+ *  cn.cloudwalk.client.ninca.attendance.config.result.AttendClassOrgQueryResult
+ *  cn.cloudwalk.client.ninca.attendance.config.service.AttendClassOrgService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.config;
+
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendClassOrgManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.organization.param.OrganizationListParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.organization.result.OrganizationResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.organization.service.OrganizationService;
+import cn.cloudwalk.client.ninca.attendance.config.param.AttendClassSubDetailQueryParam;
+import cn.cloudwalk.client.ninca.attendance.config.result.AttendClassOrgQueryResult;
+import cn.cloudwalk.client.ninca.attendance.config.service.AttendClassOrgService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendClassOrgServiceImpl
+extends AbstractCloudwalkService
+implements AttendClassOrgService {
+    @Resource
+    private AttendClassOrgManager attendClassOrgManager;
+    @Resource
+    private OrganizationService organizationService;
+
+    public CloudwalkResult<List<AttendClassOrgQueryResult>> query(AttendClassSubDetailQueryParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            AttendClassOrgQueryDTO orgQueryDTO = new AttendClassOrgQueryDTO();
+            orgQueryDTO.setClassIds(Collections.singletonList(param.getClassId()));
+            List queryResultList = this.attendClassOrgManager.query(orgQueryDTO);
+            if (CollectionUtils.isEmpty((Collection)queryResultList)) {
+                return CloudwalkResult.success(new ArrayList());
+            }
+            return CloudwalkResult.success(this.convertQueryResult(queryResultList, cloudwalkContext));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u73ed\u7ec4\u7ec4\u7ec7\u67e5\u8be2\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private List<AttendClassOrgQueryResult> convertQueryResult(List<AttendClassOrgQueryResultDTO> queryResultList, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        List orgIds = queryResultList.stream().map(AttendClassOrgQueryResultDTO::getOrgId).collect(Collectors.toList());
+        OrganizationListParam organizationListParam = new OrganizationListParam();
+        organizationListParam.setIds(orgIds);
+        CloudwalkResult list = this.organizationService.list(organizationListParam, cloudwalkContext);
+        Map<String, List<OrganizationResult>> map = null;
+        if (list.isSuccess() && CollectionUtils.isNotEmpty((Collection)((Collection)list.getData()))) {
+            map = ((List)list.getData()).stream().collect(Collectors.groupingBy(OrganizationResult::getId));
+        }
+        ArrayList<AttendClassOrgQueryResult> resultList = new ArrayList<AttendClassOrgQueryResult>(queryResultList.size());
+        for (AttendClassOrgQueryResultDTO resultDTO : queryResultList) {
+            AttendClassOrgQueryResult attendRuleOrgQueryResult = (AttendClassOrgQueryResult)BeanCopyUtils.copyProperties((Object)resultDTO, AttendClassOrgQueryResult.class);
+            if (map != null && CollectionUtils.isNotEmpty((Collection)map.get(resultDTO.getOrgId()))) {
+                attendRuleOrgQueryResult.setOrgName(map.get(resultDTO.getOrgId()).get(0).getName());
+            }
+            resultList.add(attendRuleOrgQueryResult);
+        }
+        return resultList;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/config/AttendClassServiceImpl.java

@@ -0,0 +1,459 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendClassDeviceManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendClassDeviceShotManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendClassManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendClassOrgManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendClassOrgShotManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendClassShotManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.result.PersonResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.service.PersonService
+ *  cn.cloudwalk.client.ninca.attendance.config.param.AttendClassAddParam
+ *  cn.cloudwalk.client.ninca.attendance.config.param.AttendClassDeleteParam
+ *  cn.cloudwalk.client.ninca.attendance.config.param.AttendClassEdParam
+ *  cn.cloudwalk.client.ninca.attendance.config.param.AttendClassEditParam
+ *  cn.cloudwalk.client.ninca.attendance.config.param.AttendClassPageParam
+ *  cn.cloudwalk.client.ninca.attendance.config.param.AttendClassQueryParam
+ *  cn.cloudwalk.client.ninca.attendance.config.result.AttendClassPagePersonResult
+ *  cn.cloudwalk.client.ninca.attendance.config.result.AttendClassPageResult
+ *  cn.cloudwalk.client.ninca.attendance.config.result.AttendClassQueryResult
+ *  cn.cloudwalk.client.ninca.attendance.config.service.AttendCheckService
+ *  cn.cloudwalk.client.ninca.attendance.config.service.AttendClassService
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendOrgCheckParam
+ *  cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.entity.CloudwalkBaseTimes
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.page.CloudwalkPageAble
+ *  cn.cloudwalk.cloud.page.CloudwalkPageInfo
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassAddDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassDeviceAddDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassDeviceDeleteDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassDeviceQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassDeviceQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassDeviceShotAddDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassEditDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassGetsDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgAddDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgDeleteDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgShotAddDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassPageDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassPageResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassShotAddDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.StringUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ *  org.springframework.transaction.annotation.Transactional
+ */
+package cn.cloudwalk.service.ninca.attendance.config;
+
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendClassDeviceManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendClassDeviceShotManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendClassManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendClassOrgManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendClassOrgShotManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendClassShotManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.result.PersonResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.service.PersonService;
+import cn.cloudwalk.client.ninca.attendance.config.param.AttendClassAddParam;
+import cn.cloudwalk.client.ninca.attendance.config.param.AttendClassDeleteParam;
+import cn.cloudwalk.client.ninca.attendance.config.param.AttendClassEdParam;
+import cn.cloudwalk.client.ninca.attendance.config.param.AttendClassEditParam;
+import cn.cloudwalk.client.ninca.attendance.config.param.AttendClassPageParam;
+import cn.cloudwalk.client.ninca.attendance.config.param.AttendClassQueryParam;
+import cn.cloudwalk.client.ninca.attendance.config.result.AttendClassPagePersonResult;
+import cn.cloudwalk.client.ninca.attendance.config.result.AttendClassPageResult;
+import cn.cloudwalk.client.ninca.attendance.config.result.AttendClassQueryResult;
+import cn.cloudwalk.client.ninca.attendance.config.service.AttendCheckService;
+import cn.cloudwalk.client.ninca.attendance.config.service.AttendClassService;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendOrgCheckParam;
+import cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.entity.CloudwalkBaseTimes;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.page.CloudwalkPageAble;
+import cn.cloudwalk.cloud.page.CloudwalkPageInfo;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassAddDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassDeviceAddDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassDeviceDeleteDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassDeviceQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassDeviceQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassDeviceShotAddDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassEditDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassGetsDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgAddDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgDeleteDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgShotAddDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassPageDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassPageResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassShotAddDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.attendance.util.StringUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractAttendService;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class AttendClassServiceImpl
+extends AbstractAttendService
+implements AttendClassService {
+    @Resource
+    private AttendClassManager attendClassManager;
+    @Resource
+    private AttendClassDeviceManager attendClassDeviceManager;
+    @Resource
+    private AttendClassDeviceShotManager attendClassDeviceShotManager;
+    @Resource
+    private AttendClassShotManager attendClassShotManager;
+    @Resource
+    private PersonService personService;
+    @Resource
+    private AttendClassOrgManager attendClassOrgManager;
+    @Resource
+    private AttendClassOrgShotManager attendClassOrgShotManager;
+    @Resource
+    private AttendCheckService attendCheckService;
+
+    public CloudwalkResult<CloudwalkPageAble<AttendClassPageResult>> page(AttendClassPageParam param, CloudwalkPageInfo pageInfo, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            AttendClassPageDTO pageDTO = (AttendClassPageDTO)BeanCopyUtils.copyProperties((Object)param, AttendClassPageDTO.class);
+            pageDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            if (StringUtils.isNotBlank((String)param.getName())) {
+                PersonQueryParam personQueryParam = new PersonQueryParam();
+                personQueryParam.setName(param.getName());
+                CloudwalkResult personListResult = this.personService.list(personQueryParam, cloudwalkContext);
+                if (!personListResult.isSuccess() || CollectionUtils.isEmpty((Collection)((Collection)personListResult.getData()))) {
+                    return CloudwalkResult.success((Object)new CloudwalkPageAble(new ArrayList(), pageInfo, 0L));
+                }
+                ArrayList orgIds = new ArrayList();
+                for (PersonResult personResult : (List)personListResult.getData()) {
+                    if (!CollectionUtils.isNotEmpty((Collection)personResult.getOrganizationIds())) continue;
+                    orgIds.addAll(personResult.getOrganizationIds());
+                }
+                if (CollectionUtils.isEmpty(orgIds)) {
+                    return CloudwalkResult.success((Object)new CloudwalkPageAble(new ArrayList(), pageInfo, 0L));
+                }
+                AttendClassOrgQueryDTO orgQueryDTO = new AttendClassOrgQueryDTO();
+                orgQueryDTO.setOrgIds(orgIds);
+                List orgList = this.attendClassOrgManager.query(orgQueryDTO);
+                if (CollectionUtils.isEmpty((Collection)orgList)) {
+                    return CloudwalkResult.success((Object)new CloudwalkPageAble(new ArrayList(), pageInfo, 0L));
+                }
+                pageDTO.setClassIds(orgList.stream().map(AttendClassOrgQueryResultDTO::getClassId).collect(Collectors.toList()));
+            }
+            pageDTO.setStatus(YesNoTypeEnum.Y.getCode());
+            CloudwalkPageAble pageAble = this.attendClassManager.page(pageDTO, pageInfo);
+            if (CollectionUtils.isEmpty((Collection)pageAble.getDatas())) {
+                return CloudwalkResult.success((Object)new CloudwalkPageAble(new ArrayList(), pageInfo, 0L));
+            }
+            List<AttendClassPageResult> resultList = this.convertPageResult(pageAble.getDatas(), cloudwalkContext);
+            return CloudwalkResult.success((Object)new CloudwalkPageAble(resultList, pageInfo, pageAble.getTotalRows()));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u5206\u9875\u67e5\u8be2\u73ed\u7ec4\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0:", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private List<AttendClassPageResult> convertPageResult(Collection<AttendClassPageResultDTO> datas, CloudwalkCallContext context) throws DataAccessException, ServiceException {
+        ArrayList<AttendClassPageResult> resultList = new ArrayList<AttendClassPageResult>(10);
+        for (AttendClassPageResultDTO data : datas) {
+            boolean hasUsed;
+            AttendClassPageResult result = (AttendClassPageResult)BeanCopyUtils.copyProperties((Object)data, AttendClassPageResult.class);
+            this.setPersonList(result, data.getId(), context);
+            try {
+                CloudwalkResult checkResult = this.attendCheckService.checkClass(data.getId(), context);
+                hasUsed = !checkResult.isSuccess();
+            }
+            catch (ServiceException e) {
+                hasUsed = true;
+            }
+            result.setHasUsed(Boolean.valueOf(hasUsed));
+            resultList.add(result);
+        }
+        return resultList;
+    }
+
+    private void setPersonList(AttendClassPageResult result, String id, CloudwalkCallContext context) throws DataAccessException, ServiceException {
+        AttendClassOrgQueryDTO queryDTO = new AttendClassOrgQueryDTO();
+        queryDTO.setClassIds(Collections.singletonList(id));
+        List orgList = this.attendClassOrgManager.query(queryDTO);
+        int total = 0;
+        ArrayList<AttendClassPagePersonResult> personList = new ArrayList<AttendClassPagePersonResult>();
+        if (CollectionUtils.isNotEmpty((Collection)orgList)) {
+            List orgIds = orgList.stream().map(AttendClassOrgQueryResultDTO::getOrgId).collect(Collectors.toList());
+            PersonQueryParam personQueryParam = new PersonQueryParam();
+            personQueryParam.setOrganizationIds(orgIds);
+            personQueryParam.setCurrentPage(1);
+            personQueryParam.setRowsOfPage(5);
+            CloudwalkResult personCloudwalkResult = this.personService.page(personQueryParam, context);
+            if (personCloudwalkResult.isSuccess() && personCloudwalkResult.getData() != null && CollectionUtils.isNotEmpty((Collection)((CloudwalkPageAble)personCloudwalkResult.getData()).getDatas())) {
+                total = (int)((long)total + ((CloudwalkPageAble)personCloudwalkResult.getData()).getTotalRows());
+                Collection datas = ((CloudwalkPageAble)personCloudwalkResult.getData()).getDatas();
+                for (PersonResult data : datas) {
+                    AttendClassPagePersonResult personResult = new AttendClassPagePersonResult();
+                    personResult.setPersonId(data.getId());
+                    personResult.setPersonName(data.getName());
+                    personList.add(personResult);
+                }
+            }
+        }
+        result.setPersonList(personList);
+        result.setPersonCount(Integer.valueOf(total));
+    }
+
+    @Transactional(rollbackFor={Exception.class})
+    @CloudwalkParamsValidate
+    public CloudwalkResult<Boolean> add(AttendClassAddParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            AttendOrgCheckParam orgCheckParam = new AttendOrgCheckParam();
+            orgCheckParam.setOrgIds(param.getOrgIds());
+            CloudwalkResult<List<String>> imagestoreCheckResult = this.orgCheck(orgCheckParam, cloudwalkContext);
+            if (CollectionUtils.isNotEmpty((Collection)((Collection)imagestoreCheckResult.getData()))) {
+                this.logger.error("\u73ed\u6b21\u65b0\u589e\uff0c\u7ec4\u7ec7\u6821\u9a8c\u5931\u8d25\uff0c\u539f\u56e0\uff1a\u5b58\u5728\u4e0d\u53ef\u7528\u7684\u7ec4\u7ec7");
+                return CloudwalkResult.fail((String)"76240242", (String)this.getMessage("76240242"));
+            }
+            List<AttendClassQueryResultDTO> classQueryResultList = this.queryClassList(param.getName(), cloudwalkContext);
+            if (CollectionUtils.isNotEmpty(classQueryResultList)) {
+                return CloudwalkResult.fail((String)"76240318", (String)this.getMessage("76240318"));
+            }
+            String shotId = this.genUUID();
+            AttendClassAddDTO classAddDTO = new AttendClassAddDTO();
+            BeanCopyUtils.copyProperties((CloudwalkBaseTimes)classAddDTO, (CloudwalkCallContext)cloudwalkContext);
+            BeanCopyUtils.copyProperties((Object)param, (Object)classAddDTO);
+            classAddDTO.setId(this.genUUID());
+            classAddDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            classAddDTO.setType(AttendTypeEnum.SCHEDULING.getCode());
+            classAddDTO.setStatus(YesNoTypeEnum.Y.getCode());
+            classAddDTO.setIsEnable(YesNoTypeEnum.Y.getCode());
+            classAddDTO.setShotId(shotId);
+            this.attendClassManager.add(classAddDTO);
+            AttendClassShotAddDTO classShotAddDTO = (AttendClassShotAddDTO)BeanCopyUtils.copyProperties((Object)classAddDTO, AttendClassShotAddDTO.class);
+            classShotAddDTO.setId(shotId);
+            this.attendClassShotManager.add(classShotAddDTO);
+            this.saveDeviceOrg(classAddDTO.getId(), shotId, param.getDeviceIds(), param.getOrgIds(), cloudwalkContext);
+            super.saveCwosTransaction(classAddDTO.getId(), classAddDTO.getName(), param.getDeviceIds(), param.getOrgIds(), cloudwalkContext);
+            return CloudwalkResult.success((Object)true);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u65b0\u589e\u73ed\u7ec4\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0:", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private List<AttendClassQueryResultDTO> queryClassList(String name, CloudwalkCallContext cloudwalkContext) throws DataAccessException {
+        AttendClassQueryDTO classQueryDTO = new AttendClassQueryDTO();
+        classQueryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+        classQueryDTO.setName(name);
+        classQueryDTO.setStatus(YesNoTypeEnum.Y.getCode());
+        return this.attendClassManager.query(classQueryDTO);
+    }
+
+    private void saveDeviceOrg(String classId, String shotId, List<String> deviceIds, List<String> orgIds, CloudwalkCallContext cloudwalkContext) throws DataAccessException {
+        for (String deviceId : deviceIds) {
+            AttendClassDeviceAddDTO deviceAddDTO = new AttendClassDeviceAddDTO();
+            BeanCopyUtils.copyProperties((CloudwalkBaseTimes)deviceAddDTO, (CloudwalkCallContext)cloudwalkContext);
+            deviceAddDTO.setId(this.genUUID());
+            deviceAddDTO.setDeviceId(deviceId);
+            deviceAddDTO.setClassId(classId);
+            this.attendClassDeviceManager.add(deviceAddDTO);
+            AttendClassDeviceShotAddDTO deviceShotAddDTO = (AttendClassDeviceShotAddDTO)BeanCopyUtils.copyProperties((Object)deviceAddDTO, AttendClassDeviceShotAddDTO.class);
+            deviceShotAddDTO.setId(this.genUUID());
+            deviceShotAddDTO.setShotId(shotId);
+            this.attendClassDeviceShotManager.add(deviceShotAddDTO);
+        }
+        for (String orgId : orgIds) {
+            AttendClassOrgAddDTO orgAddDTO = new AttendClassOrgAddDTO();
+            BeanCopyUtils.copyProperties((Object)orgAddDTO, (Object)cloudwalkContext);
+            orgAddDTO.setId(this.genUUID());
+            orgAddDTO.setClassId(classId);
+            orgAddDTO.setOrgId(orgId);
+            this.attendClassOrgManager.add(orgAddDTO);
+            AttendClassOrgShotAddDTO orgShotAddDTO = (AttendClassOrgShotAddDTO)BeanCopyUtils.copyProperties((Object)orgAddDTO, AttendClassOrgShotAddDTO.class);
+            orgShotAddDTO.setId(this.genUUID());
+            orgShotAddDTO.setShotId(shotId);
+            this.attendClassOrgShotManager.add(orgShotAddDTO);
+        }
+    }
+
+    @Transactional(rollbackFor={Exception.class})
+    @CloudwalkParamsValidate
+    public CloudwalkResult<Boolean> edit(AttendClassEditParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            List existIds;
+            AttendOrgCheckParam orgCheckParam = new AttendOrgCheckParam();
+            orgCheckParam.setOrgIds(param.getOrgIds());
+            orgCheckParam.setRuleId(param.getId());
+            CloudwalkResult<List<String>> imagestoreCheckResult = this.orgCheck(orgCheckParam, cloudwalkContext);
+            if (CollectionUtils.isNotEmpty((Collection)((Collection)imagestoreCheckResult.getData()))) {
+                this.logger.error("\u73ed\u6b21\u7f16\u8f91\uff0c\u7ec4\u7ec7\u6821\u9a8c\u5931\u8d25\uff0c\u539f\u56e0\uff1a\u5b58\u5728\u4e0d\u53ef\u7528\u7684\u7ec4\u7ec7");
+                return CloudwalkResult.fail((String)"76240242", (String)this.getMessage("76240242"));
+            }
+            List<AttendClassQueryResultDTO> classQueryResultList = this.queryClassList(param.getName(), cloudwalkContext);
+            if (CollectionUtils.isNotEmpty(classQueryResultList) && CollectionUtils.isNotEmpty(existIds = classQueryResultList.stream().map(AttendClassQueryResultDTO::getId).filter(item -> !item.equals(param.getId())).collect(Collectors.toList()))) {
+                return CloudwalkResult.fail((String)"76240318", (String)this.getMessage("76240318"));
+            }
+            String shotId = this.genUUID();
+            AttendClassQueryDTO classQueryDTO = new AttendClassQueryDTO();
+            classQueryDTO.setId(param.getId());
+            classQueryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            List resultList = this.attendClassManager.query(classQueryDTO);
+            if (CollectionUtils.isEmpty((Collection)resultList)) {
+                return CloudwalkResult.fail((String)"76240310", (String)this.getMessage("76240310"));
+            }
+            AttendClassQueryResultDTO resultDTO = (AttendClassQueryResultDTO)resultList.get(0);
+            AttendClassEditDTO editDTO = (AttendClassEditDTO)BeanCopyUtils.copyProperties((Object)param, AttendClassEditDTO.class);
+            editDTO.setId(resultDTO.getId());
+            editDTO.setShotId(shotId);
+            editDTO.setLastUpdateTime(Long.valueOf(System.currentTimeMillis()));
+            editDTO.setLastUpdateUserId(cloudwalkContext.getUser().getCaller());
+            this.attendClassManager.edit(editDTO);
+            AttendClassShotAddDTO classShotAddDTO = (AttendClassShotAddDTO)BeanCopyUtils.copyProperties((Object)resultDTO, AttendClassShotAddDTO.class);
+            classShotAddDTO.setId(shotId);
+            this.attendClassShotManager.add(classShotAddDTO);
+            AttendClassDeviceQueryDTO deviceQueryDTO = new AttendClassDeviceQueryDTO();
+            deviceQueryDTO.setClassId(resultDTO.getId());
+            List deviceQueryResultList = this.attendClassDeviceManager.query(deviceQueryDTO);
+            if (CollectionUtils.isNotEmpty((Collection)deviceQueryResultList)) {
+                List ids = deviceQueryResultList.stream().map(AttendClassDeviceQueryResultDTO::getId).collect(Collectors.toList());
+                AttendClassDeviceDeleteDTO deviceDeleteDTO = new AttendClassDeviceDeleteDTO();
+                deviceDeleteDTO.setIds(ids);
+                this.attendClassDeviceManager.delete(deviceDeleteDTO);
+            }
+            AttendClassOrgQueryDTO orgQueryDTO = new AttendClassOrgQueryDTO();
+            orgQueryDTO.setClassIds(Collections.singletonList(resultDTO.getId()));
+            List orgQueryResultList = this.attendClassOrgManager.query(orgQueryDTO);
+            if (CollectionUtils.isNotEmpty((Collection)orgQueryResultList)) {
+                List ids = orgQueryResultList.stream().map(AttendClassOrgQueryResultDTO::getId).collect(Collectors.toList());
+                AttendClassOrgDeleteDTO orgDeleteDTO = new AttendClassOrgDeleteDTO();
+                orgDeleteDTO.setIds(ids);
+                this.attendClassOrgManager.delete(orgDeleteDTO);
+            }
+            this.saveDeviceOrg(resultDTO.getId(), shotId, param.getDeviceIds(), param.getOrgIds(), cloudwalkContext);
+            List classDeviceIds = deviceQueryResultList.stream().map(AttendClassDeviceQueryResultDTO::getDeviceId).collect(Collectors.toList());
+            ArrayList<String> unBindDeviceList = new ArrayList<String>();
+            for (String oldDeviceId : classDeviceIds) {
+                if (param.getDeviceIds().contains(oldDeviceId)) continue;
+                unBindDeviceList.add(oldDeviceId);
+            }
+            ArrayList<String> newDeviceList = new ArrayList<String>();
+            for (String deviceId : param.getDeviceIds()) {
+                if (classDeviceIds.contains(deviceId)) continue;
+                newDeviceList.add(deviceId);
+            }
+            super.classEditCwos(param.getId(), unBindDeviceList, cloudwalkContext);
+            super.saveCwos(param.getId(), param.getName(), newDeviceList, param.getOrgIds(), cloudwalkContext);
+            return CloudwalkResult.success((Object)true);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u7f16\u8f91\u73ed\u7ec4\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0:", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @CloudwalkParamsValidate
+    @Transactional(rollbackFor={Exception.class})
+    public CloudwalkResult<Boolean> ed(AttendClassEdParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            AttendClassQueryDTO queryDTO = new AttendClassQueryDTO();
+            queryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            queryDTO.setId(param.getId());
+            List queryList = this.attendClassManager.query(queryDTO);
+            if (CollectionUtils.isNotEmpty((Collection)queryList)) {
+                for (AttendClassQueryResultDTO resultDTO : queryList) {
+                    CloudwalkResult checkResult;
+                    if (YesNoTypeEnum.N.getCode().equals(param.getIsEnable()) && !(checkResult = this.attendCheckService.checkClass(resultDTO.getId(), cloudwalkContext)).isSuccess()) {
+                        return checkResult;
+                    }
+                    AttendClassEditDTO editDTO = new AttendClassEditDTO();
+                    editDTO.setId(resultDTO.getId());
+                    editDTO.setIsEnable(param.getIsEnable());
+                    editDTO.setLastUpdateTime(Long.valueOf(System.currentTimeMillis()));
+                    editDTO.setLastUpdateUserId(cloudwalkContext.getUser().getCaller());
+                    this.attendClassManager.edit(editDTO);
+                    super.bindImagestore(resultDTO.getId(), resultDTO.getName(), null, cloudwalkContext);
+                }
+            }
+            return CloudwalkResult.success((Object)true);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u542f\u7528\u3001\u7981\u7528\u73ed\u7ec4\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0:", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @CloudwalkParamsValidate
+    @Transactional(rollbackFor={Exception.class})
+    public CloudwalkResult<Boolean> delete(AttendClassDeleteParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            AttendClassGetsDTO getsDTO = new AttendClassGetsDTO();
+            getsDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            getsDTO.setIds(param.getIds());
+            List getsList = this.attendClassManager.gets(getsDTO);
+            if (CollectionUtils.isNotEmpty((Collection)getsList)) {
+                for (AttendClassQueryResultDTO queryResultDTO : getsList) {
+                    CloudwalkResult checkResult = this.attendCheckService.checkClass(queryResultDTO.getId(), cloudwalkContext);
+                    if (!checkResult.isSuccess()) {
+                        return checkResult;
+                    }
+                    AttendClassEditDTO editDTO = new AttendClassEditDTO();
+                    editDTO.setId(queryResultDTO.getId());
+                    editDTO.setStatus(YesNoTypeEnum.N.getCode());
+                    editDTO.setLastUpdateTime(Long.valueOf(System.currentTimeMillis()));
+                    editDTO.setLastUpdateUserId(cloudwalkContext.getUser().getCaller());
+                    this.attendClassManager.edit(editDTO);
+                    super.classDeleteCwos(queryResultDTO.getId(), cloudwalkContext);
+                }
+            }
+            return CloudwalkResult.success((Object)true);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u5220\u9664\u73ed\u7ec4\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0:", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<List<AttendClassQueryResult>> query(AttendClassQueryParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            AttendClassQueryDTO queryDTO = (AttendClassQueryDTO)BeanCopyUtils.copyProperties((Object)param, AttendClassQueryDTO.class);
+            queryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            queryDTO.setStatus(YesNoTypeEnum.Y.getCode());
+            List queryResultList = this.attendClassManager.query(queryDTO);
+            return CloudwalkResult.success((Object)BeanCopyUtils.copy((Collection)queryResultList, AttendClassQueryResult.class));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u67e5\u8be2\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/config/AttendSchedulingServiceImpl.java

@@ -0,0 +1,575 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendClassOrgManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendSchedulingManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendShiftManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.result.PersonResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.service.PersonService
+ *  cn.cloudwalk.client.ninca.attendance.config.param.AttendClassSchedulingDetailParam
+ *  cn.cloudwalk.client.ninca.attendance.config.param.AttendClassSchedulingExecuteParam
+ *  cn.cloudwalk.client.ninca.attendance.config.param.AttendClassSchedulingSelfParam
+ *  cn.cloudwalk.client.ninca.attendance.config.param.AttendClassSchedulingWorkDaySetParam
+ *  cn.cloudwalk.client.ninca.attendance.config.result.AttendClassSchedulingDetailResult
+ *  cn.cloudwalk.client.ninca.attendance.config.result.AttendClassSchedulingPublishResult
+ *  cn.cloudwalk.client.ninca.attendance.config.result.AttendClassSchedulingResult
+ *  cn.cloudwalk.client.ninca.attendance.config.result.AttendClassSchedulingSelfResult
+ *  cn.cloudwalk.client.ninca.attendance.config.result.AttendClassSchedulingWorkDayResult
+ *  cn.cloudwalk.client.ninca.attendance.config.service.AttendClassSchedulingService
+ *  cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.entity.CloudwalkBaseIdentify
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.page.CloudwalkPageAble
+ *  cn.cloudwalk.cloud.page.CloudwalkPageInfo
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingDetailQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingDetailResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingExecuteInsertDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingPublishResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingPublishUpdateDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingSelfQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingSelfResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingSetDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingVerifyQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingVerifyResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.SchedulingDateTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtil
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.StringUtils
+ *  com.google.common.collect.Lists
+ *  javax.annotation.Resource
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.config;
+
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendClassOrgManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendSchedulingManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendShiftManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.result.PersonResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.service.PersonService;
+import cn.cloudwalk.client.ninca.attendance.config.param.AttendClassSchedulingDetailParam;
+import cn.cloudwalk.client.ninca.attendance.config.param.AttendClassSchedulingExecuteParam;
+import cn.cloudwalk.client.ninca.attendance.config.param.AttendClassSchedulingSelfParam;
+import cn.cloudwalk.client.ninca.attendance.config.param.AttendClassSchedulingWorkDaySetParam;
+import cn.cloudwalk.client.ninca.attendance.config.result.AttendClassSchedulingDetailResult;
+import cn.cloudwalk.client.ninca.attendance.config.result.AttendClassSchedulingPublishResult;
+import cn.cloudwalk.client.ninca.attendance.config.result.AttendClassSchedulingResult;
+import cn.cloudwalk.client.ninca.attendance.config.result.AttendClassSchedulingSelfResult;
+import cn.cloudwalk.client.ninca.attendance.config.result.AttendClassSchedulingWorkDayResult;
+import cn.cloudwalk.client.ninca.attendance.config.service.AttendClassSchedulingService;
+import cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.entity.CloudwalkBaseIdentify;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.page.CloudwalkPageAble;
+import cn.cloudwalk.cloud.page.CloudwalkPageInfo;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassOrgQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingDetailQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingDetailResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingExecuteInsertDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingPublishResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingPublishUpdateDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingSelfQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingSelfResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingSetDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingVerifyQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingVerifyResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.em.SchedulingDateTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtil;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtils;
+import cn.cloudwalk.common.ninca.attendance.util.StringUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import cn.cloudwalk.service.ninca.attendance.common.AttendanceProperties;
+import com.google.common.collect.Lists;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendSchedulingServiceImpl
+extends AbstractCloudwalkService
+implements AttendClassSchedulingService {
+    @Autowired
+    private AttendanceProperties attendanceProperties;
+    @Resource
+    private AttendSchedulingManager attendSchedulingManager;
+    @Resource
+    private AttendShiftManager attendShiftManager;
+    @Resource
+    private PersonService personService;
+    @Resource
+    private AttendClassOrgManager attendClassOrgManager;
+    private static final Long ONE_YEAR_MILLISECONDS = 31536000000L;
+    public static final String YYYYMMDD = "yyyyMMdd";
+
+    @CloudwalkParamsValidate(argsIndexs={0, 1})
+    public CloudwalkResult<List<AttendClassSchedulingPublishResult>> schedulingPublish(AttendClassSchedulingDetailParam param, CloudwalkPageInfo pageInfo, CloudwalkCallContext cloudwalkContext, boolean isExport, String userId) throws ServiceException {
+        if (param.getSchedulingEndDate() - param.getSchedulingStartDate() > ONE_YEAR_MILLISECONDS) {
+            return CloudwalkResult.fail((String)"76240304", (String)this.getMessage("76240304"));
+        }
+        AttendShiftDTO shiftDTO = new AttendShiftDTO();
+        shiftDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+        shiftDTO.setShiftType(SchedulingDateTypeEnum.REST_DAY.getCode());
+        try {
+            param.setPersonName(null);
+            Date tomorrowDate = DateUtil.addDays((Date)new Date(System.currentTimeMillis()), (int)1);
+            param.setSchedulingStartDate(DateUtils.todayStart((Date)tomorrowDate));
+            AttendSchedulingDetailResultDTO lastOneResult = this.attendSchedulingManager.queryLastOne(param.getClassId());
+            if (lastOneResult != null) {
+                param.setSchedulingEndDate(Long.valueOf(lastOneResult.getDate()));
+            }
+            AttendSchedulingDetailQueryDTO queryDTO = (AttendSchedulingDetailQueryDTO)BeanCopyUtils.copyProperties((Object)param, AttendSchedulingDetailQueryDTO.class);
+            AttendShiftQueryResultDTO rest = this.attendShiftManager.queryShift(shiftDTO);
+            List<String> personIds = this.getPersonIds(param, cloudwalkContext);
+            queryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            queryDTO.setPersonIds(personIds);
+            List pageResult = this.attendSchedulingManager.query(queryDTO);
+            long start = System.currentTimeMillis();
+            this.addRestShift(pageResult, personIds, rest, param, cloudwalkContext.getCompany().getCompanyId(), userId);
+            this.logger.info("first \u8017\u65f6={}\uff0caddRestShift", (Object)(System.currentTimeMillis() - start));
+            ArrayList<String> idList = new ArrayList<String>();
+            ArrayList<AttendClassSchedulingPublishResult> returnList = new ArrayList<AttendClassSchedulingPublishResult>();
+            for (AttendSchedulingDetailResultDTO result : pageResult) {
+                if (result.getIsPublish() != YesNoTypeEnum.N.getCode().intValue() || result.getDate() <= DateUtils.todayStart()) continue;
+                idList.add(result.getId());
+            }
+            if (!CollectionUtils.isNotEmpty(idList)) {
+                return CloudwalkResult.success(returnList);
+            }
+            AttendSchedulingPublishUpdateDTO updateDTO = new AttendSchedulingPublishUpdateDTO();
+            updateDTO.setIds(idList);
+            updateDTO.setIsPublish(YesNoTypeEnum.Y.getCode().intValue());
+            updateDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            updateDTO.setLastUpdateUserId(userId);
+            updateDTO.setLastUpdateTime(DateUtils.getCurrentTime());
+            CloudwalkPageAble updateResult = this.attendSchedulingManager.publish(updateDTO);
+            AttendClassSchedulingPublishResult resultPublish = new AttendClassSchedulingPublishResult();
+            for (AttendSchedulingPublishResultDTO result : updateResult.getDatas()) {
+                resultPublish.setPublishResult(result.isResult());
+                returnList.add(resultPublish);
+            }
+            return CloudwalkResult.success(returnList);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u6392\u73ed\u53d1\u5e03\u5931\u8d25,\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @CloudwalkParamsValidate(argsIndexs={0, 1})
+    public CloudwalkResult<List<AttendClassSchedulingSelfResult>> querySelfDetail(AttendClassSchedulingSelfParam param, CloudwalkCallContext cloudwalkContext, boolean isExport) throws ServiceException {
+        ArrayList<AttendClassSchedulingSelfResult> returnList = new ArrayList<AttendClassSchedulingSelfResult>();
+        if (!StringUtils.isNotEmpty((String)param.getPersonId())) {
+            return CloudwalkResult.success(returnList);
+        }
+        if (param.getSchedulingEndDate() - param.getSchedulingStartDate() > ONE_YEAR_MILLISECONDS) {
+            return CloudwalkResult.fail((String)"76240304", (String)this.getMessage("76240304"));
+        }
+        AttendSchedulingSelfQueryDTO queryDTO = (AttendSchedulingSelfQueryDTO)BeanCopyUtils.copyProperties((Object)param, AttendSchedulingSelfQueryDTO.class);
+        queryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+        try {
+            List pageResult = this.attendSchedulingManager.querySelf(queryDTO);
+            for (AttendSchedulingSelfResultDTO resultDTO : pageResult) {
+                AttendClassSchedulingSelfResult result = (AttendClassSchedulingSelfResult)BeanCopyUtils.copyProperties((Object)resultDTO, AttendClassSchedulingSelfResult.class);
+                if (!resultDTO.getIsPublish().equals(YesNoTypeEnum.Y.getCode())) continue;
+                returnList.add(result);
+            }
+            return CloudwalkResult.success(returnList);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u4e2a\u4eba\u6392\u73ed\u67e5\u8be2\u5931\u8d25,\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @CloudwalkParamsValidate(argsIndexs={0, 1})
+    public CloudwalkResult<Boolean> schedulingExecute(AttendClassSchedulingExecuteParam param, CloudwalkPageInfo pageInfo, CloudwalkCallContext cloudwalkContext, String userId) throws ServiceException {
+        AttendShiftDTO shiftDTO = new AttendShiftDTO();
+        shiftDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+        shiftDTO.setId(param.getShiftId());
+        AttendSchedulingVerifyQueryDTO verifyDTO = new AttendSchedulingVerifyQueryDTO();
+        ArrayList<Long> days = new ArrayList<Long>();
+        days.add(param.getSchedulingDate() + 86400000L);
+        days.add(param.getSchedulingDate() - 86400000L);
+        verifyDTO.setDays(days);
+        verifyDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+        verifyDTO.setPersonId(param.getPersonId());
+        try {
+            List verifyList;
+            AttendShiftQueryResultDTO shiftResult = this.attendShiftManager.queryShift(shiftDTO);
+            if (shiftResult.getShiftType() != SchedulingDateTypeEnum.REST_DAY.getCode().intValue() && CollectionUtils.isNotEmpty((Collection)(verifyList = this.attendSchedulingManager.verify(verifyDTO)))) {
+                for (AttendSchedulingVerifyResultDTO verfiy : verifyList) {
+                    if (verfiy.getShiftType().equals(SchedulingDateTypeEnum.REST_DAY.getCode())) continue;
+                    if (verfiy.getSchedulingDate() == param.getSchedulingDate() + 86400000L) {
+                        if (shiftResult.getEndAdaptTime().indexOf("+1") <= 0 && shiftResult.getEndWorkTime().indexOf("+1") <= 0 || DateUtils.compareTo((String)shiftResult.getEndAdaptTime(), (String)verfiy.getStartAdaptTime()) != 1 && DateUtils.compareTo((String)shiftResult.getEndAdaptTime(), (String)verfiy.getStartAdaptTime()) != 0 && DateUtils.compareTo((String)shiftResult.getEndWorkTime(), (String)verfiy.getStartWorkTime()) != 1 && DateUtils.compareTo((String)shiftResult.getEndWorkTime(), (String)verfiy.getStartWorkTime()) != 0) continue;
+                        return CloudwalkResult.fail((String)"76240000", (String)"\u4e0e\u7b2c\u4e8c\u65e5\u6392\u73ed\u51b2\u7a81");
+                    }
+                    if (verfiy.getSchedulingDate() != param.getSchedulingDate() - 86400000L || verfiy.getEndAdaptTime().indexOf("+1") <= 0 && verfiy.getEndWorkTime().indexOf("+1") <= 0 || DateUtils.compareTo((String)verfiy.getEndAdaptTime(), (String)shiftResult.getStartAdaptTime()) != 1 && DateUtils.compareTo((String)verfiy.getEndAdaptTime(), (String)shiftResult.getStartAdaptTime()) != 0 && DateUtils.compareTo((String)verfiy.getEndWorkTime(), (String)shiftResult.getStartWorkTime()) != 1 && DateUtils.compareTo((String)verfiy.getEndWorkTime(), (String)shiftResult.getStartWorkTime()) != 0) continue;
+                    return CloudwalkResult.fail((String)"76240000", (String)"\u4e0e\u524d\u65e5\u6392\u73ed\u51b2\u7a81");
+                }
+            }
+            AttendSchedulingExecuteInsertDTO executeDTO = (AttendSchedulingExecuteInsertDTO)BeanCopyUtils.copyProperties((Object)param, AttendSchedulingExecuteInsertDTO.class);
+            executeDTO.setID(this.genUUID());
+            executeDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            executeDTO.setCreateUserId(userId);
+            executeDTO.setLastUpdateTime(DateUtils.getCurrentTime());
+            executeDTO.setCreateTime(DateUtils.getCurrentTime());
+            executeDTO.setLastUpdateUserId(userId);
+            executeDTO.setIsPublish(YesNoTypeEnum.N.getCode().intValue());
+            executeDTO.setSchedulingType(Integer.valueOf(shiftResult.getShiftType()));
+            int result = 0;
+            result = this.attendSchedulingManager.queryExist(executeDTO) == 1 ? this.attendSchedulingManager.update(executeDTO) : this.attendSchedulingManager.execute(executeDTO);
+            return CloudwalkResult.success((Object)(result == 1 ? 1 : 0));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u6392\u73ed\u5931\u8d25,\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<Long> getPublishTime(AttendClassSchedulingDetailParam param, CloudwalkPageInfo pageInfo, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        if (param.getSchedulingEndDate() - param.getSchedulingStartDate() > ONE_YEAR_MILLISECONDS) {
+            return CloudwalkResult.fail((String)"76240304", (String)this.getMessage("76240304"));
+        }
+        AttendSchedulingDetailQueryDTO queryDTO = (AttendSchedulingDetailQueryDTO)BeanCopyUtils.copyProperties((Object)param, AttendSchedulingDetailQueryDTO.class);
+        try {
+            List<String> personIds = this.getPersonIds(param, cloudwalkContext);
+            queryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            queryDTO.setPersonIds(personIds);
+            List listResult = this.attendSchedulingManager.query(queryDTO);
+            ArrayList<Long> timeList = new ArrayList<Long>();
+            for (AttendSchedulingDetailResultDTO result : listResult) {
+                if (result.getIsPublish() != YesNoTypeEnum.Y.getCode().intValue()) continue;
+                timeList.add(result.getLastUpdateTime());
+            }
+            if (CollectionUtils.isEmpty(timeList)) {
+                return CloudwalkResult.success(null);
+            }
+            return CloudwalkResult.success(Collections.max(timeList));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u6392\u73ed\u8be6\u60c5\u67e5\u8be2\u5931\u8d25,\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<Boolean> getPublish(AttendClassSchedulingDetailParam param, CloudwalkPageInfo pageInfo, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        if (param.getSchedulingEndDate() - param.getSchedulingStartDate() > ONE_YEAR_MILLISECONDS) {
+            return CloudwalkResult.fail((String)"76240304", (String)this.getMessage("76240304"));
+        }
+        AttendSchedulingDetailQueryDTO queryDTO = (AttendSchedulingDetailQueryDTO)BeanCopyUtils.copyProperties((Object)param, AttendSchedulingDetailQueryDTO.class);
+        try {
+            List<String> personIds = this.getPersonIds(param, cloudwalkContext);
+            queryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            queryDTO.setPersonIds(personIds);
+            List listResult = this.attendSchedulingManager.query(queryDTO);
+            for (AttendSchedulingDetailResultDTO result : listResult) {
+                if (result.getIsPublish() != YesNoTypeEnum.N.getCode().intValue()) continue;
+                return CloudwalkResult.success((Object)false);
+            }
+            return CloudwalkResult.success((Object)true);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u6392\u73ed\u8be6\u60c5\u67e5\u8be2\u5931\u8d25,\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @CloudwalkParamsValidate(argsIndexs={0, 1})
+    public CloudwalkResult<List<AttendClassSchedulingDetailResult>> queryDetail(AttendClassSchedulingDetailParam param, CloudwalkPageInfo pageInfo, CloudwalkCallContext cloudwalkContext, boolean isExport) throws ServiceException {
+        if (param.getSchedulingEndDate() - param.getSchedulingStartDate() > ONE_YEAR_MILLISECONDS) {
+            return CloudwalkResult.fail((String)"76240304", (String)this.getMessage("76240304"));
+        }
+        AttendSchedulingDetailQueryDTO queryDTO = (AttendSchedulingDetailQueryDTO)BeanCopyUtils.copyProperties((Object)param, AttendSchedulingDetailQueryDTO.class);
+        List<Object> attendClassList = new ArrayList();
+        try {
+            List<String> personIds = this.getPersonIds(param, cloudwalkContext);
+            if (!CollectionUtils.isNotEmpty(personIds)) {
+                return CloudwalkResult.success(attendClassList);
+            }
+            queryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            queryDTO.setPersonIds(personIds);
+            List listResult = this.attendSchedulingManager.query(queryDTO);
+            PersonQueryParam personQueryParam = new PersonQueryParam();
+            personQueryParam.setIds(personIds);
+            CloudwalkResult personListResult = this.personService.list(personQueryParam, cloudwalkContext);
+            attendClassList = this.convertResult(listResult, (List)personListResult.getData(), cloudwalkContext, param, isExport);
+            return CloudwalkResult.success(attendClassList);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u6392\u73ed\u8be6\u60c5\u67e5\u8be2\u5931\u8d25,\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private List<AttendClassSchedulingDetailResult> convertResult(List<AttendSchedulingDetailResultDTO> datas, List<PersonResult> personResultList, CloudwalkCallContext cloudwalkContext, AttendClassSchedulingDetailParam param, Boolean isExport) {
+        List days = DateUtils.getDays((long)param.getSchedulingStartDate(), (long)param.getSchedulingEndDate());
+        ArrayList<AttendClassSchedulingDetailResult> list = new ArrayList<AttendClassSchedulingDetailResult>();
+        Map<String, List<AttendSchedulingDetailResultDTO>> schedulingTmpMap = datas.stream().collect(Collectors.groupingBy(AttendSchedulingDetailResultDTO::getPersonId));
+        for (PersonResult result : personResultList) {
+            AttendClassSchedulingDetailResult detailResult = new AttendClassSchedulingDetailResult();
+            detailResult.setPersonId(result.getId());
+            detailResult.setPersonName(result.getName());
+            detailResult.setFaceImagePath(result.getComparePicture());
+            detailResult.setClassId(param.getClassId());
+            if (CollectionUtils.isNotEmpty((Collection)schedulingTmpMap.get(result.getId()))) {
+                List<AttendClassSchedulingResult> attendClassResult = this.getAttendClassResultList(schedulingTmpMap.get(result.getId()), days);
+                detailResult.setSchedulingList(attendClassResult);
+            } else {
+                ArrayList<AttendClassSchedulingResult> schedulingList = new ArrayList<AttendClassSchedulingResult>();
+                for (String day : days) {
+                    AttendClassSchedulingResult schedulingResult = new AttendClassSchedulingResult();
+                    schedulingResult.setDate(DateUtils.dateToStampFormat((String)day, (String)YYYYMMDD).longValue());
+                    if (DateUtils.dateToStampFormat((String)day, (String)YYYYMMDD) > DateUtils.todayStart()) {
+                        schedulingResult.setIsEdit(1);
+                    } else {
+                        schedulingResult.setIsEdit(0);
+                    }
+                    schedulingList.add(schedulingResult);
+                }
+                detailResult.setSchedulingList(schedulingList);
+            }
+            list.add(detailResult);
+        }
+        return list;
+    }
+
+    private List<AttendClassSchedulingResult> getAttendClassResultList(List<AttendSchedulingDetailResultDTO> dtoList, List<String> days) {
+        ArrayList<AttendClassSchedulingResult> returnResultList = new ArrayList<AttendClassSchedulingResult>(days.size());
+        for (String day : days) {
+            AttendClassSchedulingResult result = new AttendClassSchedulingResult();
+            for (AttendSchedulingDetailResultDTO dto : dtoList) {
+                if (dto.getDate() != DateUtils.dateToStampFormat((String)day, (String)YYYYMMDD).longValue()) continue;
+                result = (AttendClassSchedulingResult)BeanCopyUtils.copyProperties((Object)dto, AttendClassSchedulingResult.class);
+                if (dto.getDate() > DateUtils.todayStart()) {
+                    result.setIsEdit(YesNoTypeEnum.Y.getCode().intValue());
+                } else {
+                    result.setIsEdit(YesNoTypeEnum.N.getCode().intValue());
+                }
+                if (dto.getShiftType() == SchedulingDateTypeEnum.WORK_DAY.getCode().intValue()) {
+                    result.setIsRest(YesNoTypeEnum.N.getCode().intValue());
+                } else {
+                    result.setIsRest(YesNoTypeEnum.Y.getCode().intValue());
+                }
+                result.setIsRest(dto.getShiftType());
+                returnResultList.add(result);
+                break;
+            }
+            if (!StringUtils.isEmpty((String)result.getShiftId())) continue;
+            result.setDate(DateUtils.dateToStampFormat((String)day, (String)YYYYMMDD).longValue());
+            if (DateUtils.dateToStampFormat((String)day, (String)YYYYMMDD) > DateUtils.todayStart()) {
+                result.setIsEdit(YesNoTypeEnum.Y.getCode().intValue());
+            } else {
+                result.setIsEdit(YesNoTypeEnum.N.getCode().intValue());
+            }
+            returnResultList.add(result);
+        }
+        return returnResultList;
+    }
+
+    private void addRestShift(List<AttendSchedulingDetailResultDTO> pageResult, List<String> personIds, AttendShiftQueryResultDTO rest, AttendClassSchedulingDetailParam param, String businessId, String userId) {
+        ArrayList<Long> dayList = new ArrayList<Long>();
+        List days = DateUtils.getDays((long)param.getSchedulingStartDate(), (long)param.getSchedulingEndDate());
+        for (String day : days) {
+            dayList.add(DateUtils.dateToStampFormat((String)day, (String)YYYYMMDD));
+        }
+        Map<String, List<AttendSchedulingDetailResultDTO>> schedulingTmpMap = pageResult.stream().collect(Collectors.groupingBy(AttendSchedulingDetailResultDTO::getPersonId));
+        ArrayList executedList = Lists.newArrayList();
+        for (String personId : personIds) {
+            List<AttendSchedulingDetailResultDTO> schedulingList = schedulingTmpMap.get(personId);
+            if (!CollectionUtils.isEmpty(schedulingList)) {
+                ArrayList alreadyDays = new ArrayList();
+                for (AttendSchedulingDetailResultDTO scheduling : schedulingList) {
+                    alreadyDays.add(scheduling.getDate());
+                }
+                for (Long schedulingDate : dayList) {
+                    if (alreadyDays.contains(schedulingDate) || schedulingDate <= DateUtils.todayStart()) continue;
+                    AttendSchedulingExecuteInsertDTO executeDTO = new AttendSchedulingExecuteInsertDTO();
+                    executeDTO.setIsPublish(YesNoTypeEnum.Y.getCode().intValue());
+                    executeDTO.setSchedulingDate(schedulingDate.longValue());
+                    executeDTO.setClassId(param.getClassId());
+                    executeDTO.setID(this.genUUID());
+                    executeDTO.setShiftId(rest.getShiftId());
+                    executeDTO.setShiftName(rest.getShiftName());
+                    executeDTO.setLastUpdateTime(DateUtils.getCurrentTime());
+                    executeDTO.setCreateTime(DateUtils.getCurrentTime());
+                    executeDTO.setCreateUserId(userId);
+                    executeDTO.setLastUpdateUserId(userId);
+                    executeDTO.setSchedulingType(SchedulingDateTypeEnum.REST_DAY.getCode());
+                    executeDTO.setBusinessId(businessId);
+                    executeDTO.setPersonId(personId);
+                    executedList.add(executeDTO);
+                }
+                continue;
+            }
+            for (Long schedulingDate : dayList) {
+                if (schedulingDate <= DateUtils.todayStart()) continue;
+                AttendSchedulingExecuteInsertDTO executeDTO = new AttendSchedulingExecuteInsertDTO();
+                executeDTO.setIsPublish(YesNoTypeEnum.Y.getCode().intValue());
+                executeDTO.setSchedulingDate(schedulingDate.longValue());
+                executeDTO.setClassId(param.getClassId());
+                executeDTO.setID(this.genUUID());
+                executeDTO.setShiftId(rest.getShiftId());
+                executeDTO.setShiftName(rest.getShiftName());
+                executeDTO.setLastUpdateTime(DateUtils.getCurrentTime());
+                executeDTO.setCreateTime(DateUtils.getCurrentTime());
+                executeDTO.setCreateUserId(userId);
+                executeDTO.setLastUpdateUserId(userId);
+                executeDTO.setSchedulingType(SchedulingDateTypeEnum.REST_DAY.getCode());
+                executeDTO.setBusinessId(businessId);
+                executeDTO.setPersonId(personId);
+                executedList.add(executeDTO);
+            }
+        }
+        if (CollectionUtils.isNotEmpty((Collection)executedList)) {
+            int cap = this.attendanceProperties.getSchedulingPublishExecuteCap();
+            if (cap <= 0) {
+                cap = 500;
+            }
+            this.logger.info("seven executeSiz={},cap={}", (Object)executedList.size(), (Object)cap);
+            int count = executedList.size() / cap + (executedList.size() % cap > 0 ? 1 : 0);
+            for (int index = 0; index < count; ++index) {
+                int start = index * cap;
+                int end = start + cap;
+                if (end >= executedList.size()) {
+                    end = executedList.size();
+                }
+                List subList = executedList.subList(start, end);
+                try {
+                    this.attendSchedulingManager.execute(subList);
+                    continue;
+                }
+                catch (DataAccessException e) {
+                    this.logger.error("\u6392\u73ed\u5931\u8d25,\u539f\u56e0\uff1a", (Throwable)e);
+                }
+            }
+        }
+    }
+
+    private List<String> getPersonIds(AttendClassSchedulingDetailParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException, DataAccessException {
+        CloudwalkResult personListResult;
+        AttendSchedulingDetailQueryDTO queryDTO = (AttendSchedulingDetailQueryDTO)BeanCopyUtils.copyProperties((Object)param, AttendSchedulingDetailQueryDTO.class);
+        queryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+        PersonQueryParam personQueryParam = new PersonQueryParam();
+        if (StringUtils.isNotBlank((String)param.getPersonName())) {
+            personQueryParam.setName(param.getPersonName());
+        }
+        if (StringUtils.isNotBlank((String)param.getClassId())) {
+            AttendClassOrgQueryDTO orgQueryDTO = new AttendClassOrgQueryDTO();
+            orgQueryDTO.setClassIds(Collections.singletonList(param.getClassId()));
+            List orgQueryResultList = this.attendClassOrgManager.query(orgQueryDTO);
+            if (CollectionUtils.isNotEmpty((Collection)orgQueryResultList)) {
+                List orgIds = orgQueryResultList.stream().map(AttendClassOrgQueryResultDTO::getOrgId).collect(Collectors.toList());
+                personQueryParam.setOrganizationIds(orgIds);
+            }
+        }
+        if ((personListResult = this.personService.list(personQueryParam, cloudwalkContext)).isSuccess() && CollectionUtils.isNotEmpty((Collection)((Collection)personListResult.getData()))) {
+            return ((List)personListResult.getData()).stream().map(CloudwalkBaseIdentify::getId).collect(Collectors.toList());
+        }
+        return new ArrayList<String>();
+    }
+
+    public CloudwalkResult<Boolean> workDaySet(AttendClassSchedulingWorkDaySetParam param, CloudwalkCallContext cloudwalkContext, String userId) throws ServiceException {
+        AttendSchedulingSetDTO setDto = (AttendSchedulingSetDTO)BeanCopyUtils.copyProperties((Object)param, AttendSchedulingSetDTO.class);
+        setDto.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+        setDto.setLastUpdateTime(Long.valueOf(DateUtils.getCurrentTime()));
+        setDto.setCreateUserId(userId);
+        setDto.setCreateTime(Long.valueOf(DateUtils.getCurrentTime()));
+        setDto.setPeriodDays("7");
+        setDto.setId(this.genUUID());
+        try {
+            if (this.attendSchedulingManager.setDays(setDto) == 1) {
+                return CloudwalkResult.success((Object)true);
+            }
+            this.attendSchedulingManager.addDays(setDto);
+            return CloudwalkResult.success((Object)true);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u6392\u73ed\u5929\u6570\u8bbe\u7f6e\u5931\u8d25,\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<AttendClassSchedulingWorkDayResult> workDayQuery(CloudwalkCallContext cloudwalkContext, String userId) throws ServiceException {
+        AttendSchedulingSetDTO queryDto = new AttendSchedulingSetDTO();
+        queryDto.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+        try {
+            AttendSchedulingSetDTO queryResult = this.attendSchedulingManager.queryDays(queryDto);
+            if (queryResult == null) {
+                AttendSchedulingSetDTO setDto = new AttendSchedulingSetDTO();
+                setDto.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+                setDto.setLastUpdateTime(Long.valueOf(DateUtils.getCurrentTime()));
+                setDto.setCreateUserId(userId);
+                setDto.setCreateTime(Long.valueOf(DateUtils.getCurrentTime()));
+                setDto.setPeriodDays("7");
+                setDto.setWorkDays("5");
+                setDto.setId(this.genUUID());
+                this.attendSchedulingManager.addDays(setDto);
+                AttendClassSchedulingWorkDayResult returnResult = new AttendClassSchedulingWorkDayResult();
+                returnResult.setWorkDays("5");
+                return CloudwalkResult.success((Object)returnResult);
+            }
+            AttendClassSchedulingWorkDayResult result = (AttendClassSchedulingWorkDayResult)BeanCopyUtils.copyProperties((Object)queryResult, AttendClassSchedulingWorkDayResult.class);
+            return CloudwalkResult.success((Object)result);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u6392\u73ed\u5929\u6570\u8bbe\u7f6e\u5931\u8d25,\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<Boolean> cancel(AttendClassSchedulingDetailParam param, CloudwalkPageInfo pageInfo, CloudwalkCallContext cloudwalkContext, String currentUserPersonId) throws ServiceException {
+        try {
+            if (param.getSchedulingEndDate() - param.getSchedulingStartDate() > ONE_YEAR_MILLISECONDS) {
+                return CloudwalkResult.fail((String)"76240304", (String)this.getMessage("76240304"));
+            }
+            param.setPersonName(null);
+            List<String> personIds = this.getPersonIds(param, cloudwalkContext);
+            AttendSchedulingDetailQueryDTO queryDTO = new AttendSchedulingDetailQueryDTO();
+            queryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            queryDTO.setPersonIds(personIds);
+            Date tomorrowDate = DateUtil.addDays((Date)new Date(System.currentTimeMillis()), (int)1);
+            queryDTO.setSchedulingStartDate(DateUtils.todayStart((Date)tomorrowDate));
+            queryDTO.setSchedulingEndDate(null);
+            List detailResultDTOList = this.attendSchedulingManager.query(queryDTO);
+            if (CollectionUtils.isNotEmpty((Collection)detailResultDTOList)) {
+                List ids = detailResultDTOList.stream().map(AttendSchedulingDetailResultDTO::getId).collect(Collectors.toList());
+                this.attendSchedulingManager.delete(ids);
+            }
+            return CloudwalkResult.success((Object)true);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u53d6\u6d88\u6392\u73ed\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/config/AttendShiftServiceImpl.java

@@ -0,0 +1,287 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendPeriodShotManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendShiftManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendShiftPeriodManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendShiftShotManager
+ *  cn.cloudwalk.client.ninca.attendance.config.param.AttendShiftAddParam
+ *  cn.cloudwalk.client.ninca.attendance.config.param.AttendShiftDeleteParam
+ *  cn.cloudwalk.client.ninca.attendance.config.param.AttendShiftEditParam
+ *  cn.cloudwalk.client.ninca.attendance.config.result.AttendShiftDetailResult
+ *  cn.cloudwalk.client.ninca.attendance.config.service.AttendCheckService
+ *  cn.cloudwalk.client.ninca.attendance.config.service.AttendShiftService
+ *  cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.page.CloudwalkPageAble
+ *  cn.cloudwalk.cloud.page.CloudwalkPageInfo
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftAddDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftDeleteDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftEditDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.StringUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.config;
+
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendPeriodShotManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendShiftManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendShiftPeriodManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendShiftShotManager;
+import cn.cloudwalk.client.ninca.attendance.config.param.AttendShiftAddParam;
+import cn.cloudwalk.client.ninca.attendance.config.param.AttendShiftDeleteParam;
+import cn.cloudwalk.client.ninca.attendance.config.param.AttendShiftEditParam;
+import cn.cloudwalk.client.ninca.attendance.config.result.AttendShiftDetailResult;
+import cn.cloudwalk.client.ninca.attendance.config.service.AttendCheckService;
+import cn.cloudwalk.client.ninca.attendance.config.service.AttendShiftService;
+import cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.page.CloudwalkPageAble;
+import cn.cloudwalk.cloud.page.CloudwalkPageInfo;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftAddDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftDeleteDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftEditDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtils;
+import cn.cloudwalk.common.ninca.attendance.util.StringUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendShiftServiceImpl
+extends AbstractCloudwalkService
+implements AttendShiftService {
+    @Resource
+    private AttendShiftManager attendShiftManager;
+    @Resource
+    private AttendShiftShotManager attendShiftShotManager;
+    @Resource
+    private AttendShiftPeriodManager attendShiftPeriodManager;
+    @Resource
+    private AttendPeriodShotManager attendPeriodShotManager;
+    public static final String TIME_FORMAT = "HH:mm";
+    @Resource
+    private AttendCheckService attendCheckService;
+
+    @CloudwalkParamsValidate(argsIndexs={0, 1})
+    public CloudwalkResult<CloudwalkPageAble<AttendShiftDetailResult>> queryShiftPage(CloudwalkPageInfo pageInfo, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        AttendShiftQueryDTO shiftDto = new AttendShiftQueryDTO();
+        shiftDto.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+        try {
+            CloudwalkPageAble pageResult = this.attendShiftManager.query(shiftDto, pageInfo);
+            ArrayList<AttendShiftDetailResult> shiftList = new ArrayList<AttendShiftDetailResult>();
+            for (AttendShiftQueryResultDTO result : (List)pageResult.getDatas()) {
+                AttendShiftDetailResult returnResult = (AttendShiftDetailResult)BeanCopyUtils.copyProperties((Object)result, AttendShiftDetailResult.class);
+                if (!StringUtils.isEmpty((String)result.getEndAdaptTime()) && !StringUtils.isEmpty((String)result.getEndWorkTime())) {
+                    if (result.getEndAdaptTime().indexOf("+1") > 0 && result.getEndWorkTime().indexOf("+1") > 0) {
+                        returnResult.setEndAdaptTime(result.getEndAdaptTime().substring(0, result.getEndAdaptTime().indexOf("+1")));
+                        returnResult.setEndWorkTime(result.getEndWorkTime().substring(0, result.getEndWorkTime().indexOf("+1")));
+                        returnResult.setStartAdaptTime(result.getStartAdaptTime().substring(0, result.getStartAdaptTime().indexOf("+0")));
+                        returnResult.setStartWorkTime(result.getStartWorkTime().substring(0, result.getStartWorkTime().indexOf("+0")));
+                        returnResult.setIsNextDay(1);
+                    } else {
+                        returnResult.setEndAdaptTime(result.getEndAdaptTime().substring(0, result.getEndAdaptTime().indexOf("+0")));
+                        returnResult.setEndWorkTime(result.getEndWorkTime().substring(0, result.getEndWorkTime().indexOf("+0")));
+                        returnResult.setStartAdaptTime(result.getStartAdaptTime().substring(0, result.getStartAdaptTime().indexOf("+0")));
+                        returnResult.setStartWorkTime(result.getStartWorkTime().substring(0, result.getStartWorkTime().indexOf("+0")));
+                        returnResult.setIsNextDay(0);
+                    }
+                }
+                shiftList.add(returnResult);
+            }
+            return CloudwalkResult.success((Object)new CloudwalkPageAble(shiftList, pageInfo, pageResult.getTotalRows()));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u73ed\u79cd\u67e5\u8be2\u5931\u8d25,\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public List<AttendShiftDetailResult> queryShift(CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        AttendShiftQueryDTO shiftDto = new AttendShiftQueryDTO();
+        shiftDto.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+        AttendShiftAddDTO addDto = new AttendShiftAddDTO();
+        addDto.setId(this.genUUID());
+        addDto.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+        addDto.setBuiltin(Integer.valueOf(1));
+        addDto.setShiftName("\u4f11\u606f");
+        addDto.setShiftType(Integer.valueOf(2));
+        addDto.setIsEnable(Integer.valueOf(1));
+        addDto.setCreateUserId(cloudwalkContext.getUser().getCaller());
+        addDto.setCreatTime(DateUtils.getCurrentTime());
+        addDto.setShotId(this.genUUID());
+        boolean builtin = false;
+        try {
+            List listResult = this.attendShiftManager.query(shiftDto);
+            if (CollectionUtils.isEmpty((Collection)listResult)) {
+                this.attendShiftManager.add(addDto);
+                this.attendShiftShotManager.add(addDto);
+            } else {
+                for (AttendShiftQueryResultDTO result : listResult) {
+                    if (result.getBuiltin() != 1 || result.getShiftType() != 2) continue;
+                    builtin = true;
+                    break;
+                }
+                if (!builtin) {
+                    this.attendShiftManager.add(addDto);
+                    this.attendShiftShotManager.add(addDto);
+                }
+            }
+            ArrayList<AttendShiftDetailResult> shiftList = new ArrayList<AttendShiftDetailResult>();
+            for (AttendShiftQueryResultDTO result : listResult) {
+                if (result.getIsEnable() != 1) continue;
+                AttendShiftDetailResult returnResult = (AttendShiftDetailResult)BeanCopyUtils.copyProperties((Object)result, AttendShiftDetailResult.class);
+                shiftList.add(returnResult);
+            }
+            return shiftList;
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u73ed\u79cd\u67e5\u8be2\u5931\u8d25,\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<Boolean> addShift(AttendShiftAddParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            AttendShiftQueryDTO shiftQueryDTO = new AttendShiftQueryDTO();
+            shiftQueryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            shiftQueryDTO.setShiftName(param.getShiftName());
+            List resultList = this.attendShiftManager.query(shiftQueryDTO);
+            if (CollectionUtils.isNotEmpty((Collection)resultList)) {
+                return CloudwalkResult.fail((String)"76240319", (String)this.getMessage("76240319"));
+            }
+            AttendShiftAddDTO addDto = (AttendShiftAddDTO)BeanCopyUtils.copyProperties((Object)param, AttendShiftAddDTO.class);
+            addDto.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            addDto.setShiftType(Integer.valueOf(1));
+            addDto.setStatus(Integer.valueOf(1));
+            addDto.setBuiltin(Integer.valueOf(0));
+            addDto.setIsEnable(Integer.valueOf(1));
+            addDto.setCreateUserId(cloudwalkContext.getUser().getCaller());
+            addDto.setCreatTime(DateUtils.getCurrentTime());
+            addDto.setPeriodDesc("");
+            if (param.getIsNextDay().equals("1")) {
+                addDto.setStartWorkTime(param.getStartWorkTime() + "+0");
+                addDto.setStartAdaptTime(param.getStartAdaptTime() + "+0");
+                addDto.setEndWorkTime(param.getEndWorkTime() + "+1");
+                addDto.setEndAdaptTime(param.getEndAdaptTime() + "+1");
+            } else {
+                addDto.setStartWorkTime(param.getStartWorkTime() + "+0");
+                addDto.setStartAdaptTime(param.getStartAdaptTime() + "+0");
+                addDto.setEndWorkTime(param.getEndWorkTime() + "+0");
+                addDto.setEndAdaptTime(param.getEndAdaptTime() + "+0");
+            }
+            addDto.setId(this.genUUID());
+            addDto.setShotId(this.genUUID());
+            this.attendShiftShotManager.add(addDto);
+            this.attendShiftPeriodManager.add(addDto);
+            this.attendPeriodShotManager.add(addDto);
+            return CloudwalkResult.success((Object)(this.attendShiftManager.add(addDto) == 1 ? 1 : 0));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u73ed\u79cd\u6dfb\u52a0\u5931\u8d25,\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<Boolean> deleteShift(AttendShiftDeleteParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        AttendShiftDeleteDTO deleteDto = (AttendShiftDeleteDTO)BeanCopyUtils.copyProperties((Object)param, AttendShiftDeleteDTO.class);
+        deleteDto.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+        deleteDto.setStatus(Integer.valueOf(0));
+        try {
+            CloudwalkResult checkResult = this.attendCheckService.checkShift(param.getShiftId(), cloudwalkContext);
+            if (!checkResult.isSuccess()) {
+                return checkResult;
+            }
+            return CloudwalkResult.success((Object)(this.attendShiftManager.delete(deleteDto) == 1 ? 1 : 0));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u73ed\u79cd\u6dfb\u52a0\u5931\u8d25,\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<Boolean> editShift(AttendShiftEditParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            List existIds;
+            AttendShiftQueryDTO shiftQueryDTO = new AttendShiftQueryDTO();
+            shiftQueryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            shiftQueryDTO.setShiftName(param.getShiftName());
+            List resultList = this.attendShiftManager.query(shiftQueryDTO);
+            if (CollectionUtils.isNotEmpty((Collection)resultList) && CollectionUtils.isNotEmpty(existIds = resultList.stream().map(AttendShiftQueryResultDTO::getShiftId).filter(item -> !item.equals(param.getShiftId())).collect(Collectors.toList()))) {
+                return CloudwalkResult.fail((String)"76240319", (String)this.getMessage("76240319"));
+            }
+            AttendShiftEditDTO editDto = (AttendShiftEditDTO)BeanCopyUtils.copyProperties((Object)param, AttendShiftEditDTO.class);
+            editDto.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            editDto.setLastUpdateTime(DateUtils.getCurrentTime());
+            editDto.setLastUpdateUserId(cloudwalkContext.getUser().getCaller());
+            if (StringUtils.isNotEmpty((String)param.getIsNextDay())) {
+                if (param.getIsNextDay().equals("1")) {
+                    editDto.setEndAdaptTime(param.getEndAdaptTime() + "+1");
+                    editDto.setEndWorkTime(param.getEndWorkTime() + "+1");
+                    editDto.setStartAdaptTime(param.getStartAdaptTime() + "+0");
+                    editDto.setStartWorkTime(param.getStartWorkTime() + "+0");
+                } else {
+                    editDto.setEndAdaptTime(param.getEndAdaptTime() + "+0");
+                    editDto.setEndWorkTime(param.getEndWorkTime() + "+0");
+                    editDto.setStartAdaptTime(param.getStartAdaptTime() + "+0");
+                    editDto.setStartWorkTime(param.getStartWorkTime() + "+0");
+                }
+            }
+            AttendShiftDTO queryDto = new AttendShiftDTO();
+            queryDto.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            queryDto.setId(param.getShiftId());
+            AttendShiftQueryResultDTO result = this.attendShiftManager.queryShift(queryDto);
+            editDto.setShotId(result.getShotId());
+            this.attendShiftPeriodManager.edit(editDto);
+            this.attendShiftShotManager.edit(editDto);
+            this.attendPeriodShotManager.edit(editDto);
+            return CloudwalkResult.success((Object)(this.attendShiftManager.edit(editDto) == 1 ? 1 : 0));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u73ed\u79cd\u6dfb\u52a0\u5931\u8d25,\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<Boolean> enableShift(AttendShiftEditParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        AttendShiftEditDTO editDto = (AttendShiftEditDTO)BeanCopyUtils.copyProperties((Object)param, AttendShiftEditDTO.class);
+        editDto.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+        try {
+            CloudwalkResult checkResult;
+            if (YesNoTypeEnum.N.getCode().equals(param.getIsEnable()) && !(checkResult = this.attendCheckService.checkShift(param.getShiftId(), cloudwalkContext)).isSuccess()) {
+                return checkResult;
+            }
+            this.attendShiftShotManager.enable(editDto);
+            return CloudwalkResult.success((Object)(this.attendShiftManager.enable(editDto) == 1 ? 1 : 0));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u73ed\u79cd\u542f\u505c\u5931\u8d25,\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/device/AttendDeviceServiceImpl.java

@@ -0,0 +1,79 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceService
+ *  cn.cloudwalk.client.ninca.attendance.device.param.AttendDeviceNewPageParam
+ *  cn.cloudwalk.client.ninca.attendance.device.result.AttendDeviceResult
+ *  cn.cloudwalk.client.ninca.attendance.device.service.AttendDeviceService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.page.CloudwalkPageAble
+ *  cn.cloudwalk.cloud.page.CloudwalkPageInfo
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.accesscontrol.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.StringUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.device;
+
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceService;
+import cn.cloudwalk.client.ninca.attendance.device.param.AttendDeviceNewPageParam;
+import cn.cloudwalk.client.ninca.attendance.device.result.AttendDeviceResult;
+import cn.cloudwalk.client.ninca.attendance.device.service.AttendDeviceService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.page.CloudwalkPageAble;
+import cn.cloudwalk.cloud.page.CloudwalkPageInfo;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.accesscontrol.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.attendance.util.StringUtils;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendDeviceServiceImpl
+implements AttendDeviceService {
+    @Resource
+    private DeviceService deviceService;
+
+    public CloudwalkResult<CloudwalkPageAble<AttendDeviceResult>> page(AttendDeviceNewPageParam param, CloudwalkPageInfo pageInfo, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        ArrayList<AttendDeviceResult> result = new ArrayList();
+        DeviceQueryParam deviceQueryParam = new DeviceQueryParam();
+        deviceQueryParam.setDistrictId(param.getDistrictId());
+        deviceQueryParam.setDistrictIds(param.getDistrictIds());
+        if (StringUtils.isNotEmpty((String)param.getAreaId())) {
+            deviceQueryParam.setAreaIds(Collections.singletonList(param.getAreaId()));
+        }
+        deviceQueryParam.setDeviceName(param.getDeviceName());
+        CloudwalkResult deviceResult = this.deviceService.filterList(Integer.valueOf(1), deviceQueryParam, cloudwalkContext);
+        if (!deviceResult.isSuccess() || CollectionUtils.isEmpty((Collection)((Collection)deviceResult.getData()))) {
+            return CloudwalkResult.success((Object)new CloudwalkPageAble(result, pageInfo, 0L));
+        }
+        result = ((List)deviceResult.getData()).stream().map(s -> (AttendDeviceResult)BeanCopyUtils.copyProperties((Object)s, AttendDeviceResult.class)).collect(Collectors.toList());
+        return CloudwalkResult.success((Object)new CloudwalkPageAble(this.page(result, pageInfo.getPageSize(), pageInfo.getCurrentPage()), pageInfo, (long)result.size()));
+    }
+
+    private List<AttendDeviceResult> page(List<AttendDeviceResult> dataList, int pageSize, int currentPage) {
+        ArrayList<AttendDeviceResult> currentPageList = new ArrayList<AttendDeviceResult>();
+        if (dataList != null && dataList.size() > 0) {
+            int currIdx = currentPage > 1 ? (currentPage - 1) * pageSize : 0;
+            for (int i = 0; i < pageSize && i < dataList.size() - currIdx; ++i) {
+                AttendDeviceResult data = dataList.get(currIdx + i);
+                currentPageList.add(data);
+            }
+        }
+        return currentPageList;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/downloadcenter/AttendDownloadCenterServiceImpl.java

@@ -0,0 +1,118 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.file.param.FileFinishParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.file.param.FileGetParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.file.param.FileInitParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.file.result.FileDetail
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.file.service.FileService
+ *  cn.cloudwalk.client.ninca.attendance.common.AttendApplicationService
+ *  cn.cloudwalk.client.ninca.attendance.downloadcenter.param.AttendFileFinishParam
+ *  cn.cloudwalk.client.ninca.attendance.downloadcenter.service.AttendDownloadCenterService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.config.FeignRequestUtil
+ *  cn.cloudwalk.common.ninca.attendance.config.FeignThreadLocalUtil
+ *  cn.cloudwalk.common.ninca.attendance.em.FileStatusEnum
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.downloadcenter;
+
+import cn.cloudwalk.client.cwoscomponent.intelligent.file.param.FileFinishParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.file.param.FileGetParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.file.param.FileInitParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.file.result.FileDetail;
+import cn.cloudwalk.client.cwoscomponent.intelligent.file.service.FileService;
+import cn.cloudwalk.client.ninca.attendance.common.AttendApplicationService;
+import cn.cloudwalk.client.ninca.attendance.downloadcenter.param.AttendFileFinishParam;
+import cn.cloudwalk.client.ninca.attendance.downloadcenter.service.AttendDownloadCenterService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.config.FeignRequestUtil;
+import cn.cloudwalk.common.ninca.attendance.config.FeignThreadLocalUtil;
+import cn.cloudwalk.common.ninca.attendance.em.FileStatusEnum;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendDownloadCenterServiceImpl
+extends AbstractCloudwalkService
+implements AttendDownloadCenterService {
+    @Autowired
+    private FileService fileService;
+    @Autowired
+    private AttendApplicationService applicationService;
+
+    public String createDownload(String fileName, CloudwalkCallContext context) {
+        try {
+            FileInitParam fileInitParam = new FileInitParam();
+            fileInitParam.setFileName(fileName);
+            context.setApplicationId(this.applicationService.getApplicationId(context.getCompany().getCompanyId()));
+            fileInitParam.setApplicationId(context.getApplicationId());
+            FeignRequestUtil.setRequestHeader((CloudwalkCallContext)context);
+            CloudwalkResult result = this.fileService.init(fileInitParam, context);
+            if ("00000000".equals(result.getCode())) {
+                String string = (String)result.getData();
+                return string;
+            }
+            try {
+                this.logger.error("\u4e0b\u8f7d\u4efb\u52a1\u521d\u59cb\u5316\u5931\u8d25\uff1acode={},message={}", (Object)result.getCode(), (Object)result.getMessage());
+                throw new RuntimeException("\u4e0b\u8f7d\u4efb\u52a1\u521b\u5efa\u5931\u8d25\uff01");
+            }
+            catch (ServiceException e) {
+                this.logger.error("\u4e0b\u8f7d\u4efb\u52a1\u521d\u59cb\u5316\u63a5\u53e3\u9519\u8bef", (Throwable)e);
+                throw new RuntimeException("\u4e0b\u8f7d\u4efb\u52a1\u521b\u5efa\u5931\u8d25\uff01");
+            }
+        }
+        finally {
+            FeignThreadLocalUtil.remove();
+        }
+    }
+
+    /*
+     * WARNING - Removed try catching itself - possible behaviour change.
+     */
+    public boolean finishDownload(AttendFileFinishParam param, CloudwalkCallContext context) {
+        try {
+            FeignRequestUtil.setRequestHeader((CloudwalkCallContext)context);
+            FileFinishParam fileFinishParam = (FileFinishParam)BeanCopyUtils.copyProperties((Object)param, FileFinishParam.class);
+            CloudwalkResult result = this.fileService.finish(fileFinishParam, context);
+            if ("00000000".equals(result.getCode())) {
+                boolean bl = true;
+                return bl;
+            }
+            this.logger.error("\u4e0b\u8f7d\u4efb\u52a1\u5b8c\u6210\u5931\u8d25\uff1acode={},message={}", (Object)result.getCode(), (Object)result.getMessage());
+        }
+        catch (ServiceException e) {
+            this.logger.error("\u4e0b\u8f7d\u4efb\u52a1\u5b8c\u6210\u63a5\u53e3\u9519\u8bef", (Throwable)e);
+        }
+        finally {
+            FeignThreadLocalUtil.remove();
+        }
+        return false;
+    }
+
+    public int queryDownloadStatus(String fileId, CloudwalkCallContext context) {
+        try {
+            FileGetParam fileGetParam = new FileGetParam();
+            fileGetParam.setFileId(fileId);
+            CloudwalkResult result = this.fileService.get(fileGetParam, context);
+            if ("00000000".equals(result.getCode())) {
+                return ((FileDetail)result.getData()).getStatus();
+            }
+            this.logger.error("\u4e0b\u8f7d\u4efb\u52a1\u521d\u59cb\u5316\u5931\u8d25\uff1acode={},message={}", (Object)result.getCode(), (Object)result.getMessage());
+        }
+        catch (ServiceException e) {
+            this.logger.error("\u4e0b\u8f7d\u4efb\u52a1\u5b8c\u6210\u63a5\u53e3\u9519\u8bef", (Throwable)e);
+        }
+        return FileStatusEnum.PRODUCING.getCode();
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/export/AttendAbstractExportAsyncService.java

@@ -0,0 +1,375 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.export.AttendParallelismDownloadManager
+ *  cn.cloudwalk.client.davinci.portal.file.param.part.FilePartAppendParam
+ *  cn.cloudwalk.client.davinci.portal.file.param.part.FilePartFinishParam
+ *  cn.cloudwalk.client.davinci.portal.file.param.part.FilePartInitParam
+ *  cn.cloudwalk.client.davinci.portal.file.result.FilePartResult
+ *  cn.cloudwalk.client.ninca.attendance.downloadcenter.param.AttendFileFinishParam
+ *  cn.cloudwalk.client.ninca.attendance.downloadcenter.service.AttendDownloadCenterService
+ *  cn.cloudwalk.client.ninca.attendance.storage.service.AttendFileStorageService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.page.CloudwalkPageAble
+ *  cn.cloudwalk.cloud.page.CloudwalkPageInfo
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.common.ninca.attendance.common.ExcelCallback
+ *  cn.cloudwalk.common.ninca.attendance.config.FeignRequestUtil
+ *  cn.cloudwalk.common.ninca.attendance.config.FeignThreadLocalUtil
+ *  cn.cloudwalk.common.ninca.attendance.em.FileStatusEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.ExcelUtil
+ *  cn.cloudwalk.common.ninca.attendance.util.StringUtils
+ *  cn.cloudwalk.intelligent.lock.annotation.RequiredLock
+ *  com.google.common.collect.Lists
+ *  javax.annotation.Resource
+ *  org.apache.commons.io.IOUtils
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.beans.factory.annotation.Value
+ *  org.springframework.data.redis.core.RedisTemplate
+ *  org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor
+ */
+package cn.cloudwalk.service.ninca.attendance.export;
+
+import cn.cloudwalk.biz.intelligent.ninca.export.AttendParallelismDownloadManager;
+import cn.cloudwalk.client.davinci.portal.file.param.part.FilePartAppendParam;
+import cn.cloudwalk.client.davinci.portal.file.param.part.FilePartFinishParam;
+import cn.cloudwalk.client.davinci.portal.file.param.part.FilePartInitParam;
+import cn.cloudwalk.client.davinci.portal.file.result.FilePartResult;
+import cn.cloudwalk.client.ninca.attendance.downloadcenter.param.AttendFileFinishParam;
+import cn.cloudwalk.client.ninca.attendance.downloadcenter.service.AttendDownloadCenterService;
+import cn.cloudwalk.client.ninca.attendance.storage.service.AttendFileStorageService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.page.CloudwalkPageAble;
+import cn.cloudwalk.cloud.page.CloudwalkPageInfo;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.common.ninca.attendance.common.ExcelCallback;
+import cn.cloudwalk.common.ninca.attendance.config.FeignRequestUtil;
+import cn.cloudwalk.common.ninca.attendance.config.FeignThreadLocalUtil;
+import cn.cloudwalk.common.ninca.attendance.em.FileStatusEnum;
+import cn.cloudwalk.common.ninca.attendance.util.ExcelUtil;
+import cn.cloudwalk.common.ninca.attendance.util.StringUtils;
+import cn.cloudwalk.intelligent.lock.annotation.RequiredLock;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import com.google.common.collect.Lists;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.RejectedExecutionHandler;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Resource;
+import org.apache.commons.io.IOUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
+
+public abstract class AttendAbstractExportAsyncService<T, R>
+extends AbstractCloudwalkService {
+    protected static final Logger LOGGER = LoggerFactory.getLogger(AttendAbstractExportAsyncService.class);
+    private static final Integer FILE_PART_BATCH_SIZE = 0x500001;
+    @Value(value="${cloudwalk.smart-attendance.export-max-record:1000}")
+    private int EXPORT_MAX_RECORD;
+    @Autowired
+    private AttendParallelismDownloadManager attendParallelismDownloadManager;
+    @Autowired
+    private AttendFileStorageService attendFileStorageService;
+    @Autowired
+    private AttendDownloadCenterService attendDownloadCenterService;
+    @Resource
+    private RedisTemplate<String, Object> redisTemplate;
+
+    @RequiredLock(name="T(cn.cloudwalk.common.ninca.attendance.config.AttendLockConstants).LOCK_EXPORT_BUSINESSID_PREFIX.concat(#context.company.companyId)", lockWaitTime=5000L)
+    public CloudwalkResult<Boolean> startExportTask(T param, Class<R> clazz, String fileName, CloudwalkCallContext context) throws ServiceException {
+        String cacheKey = "attend_export_prefix:#" + context.getCompany().getCompanyId();
+        try {
+            String taskId = (String)this.redisTemplate.opsForValue().get((Object)cacheKey);
+            if (StringUtils.isNotBlank((String)taskId)) {
+                return CloudwalkResult.fail((String)"76240406", (String)this.getMessage("76240406"));
+            }
+            String exportFileName = StringUtils.isNotBlank((String)fileName) ? fileName : this.getDefaultFileName();
+            ExportRecordContext.Builder builder = new ExportRecordContext.Builder();
+            ExportRecordContext exportRecordContext = builder.withFileName(exportFileName).withTaskStatus(FileStatusEnum.PRODUCING.getCode()).build();
+            ((CompletableFuture)CompletableFuture.runAsync(() -> {
+                try {
+                    String fileId = this.attendDownloadCenterService.createDownload(exportFileName, context);
+                    this.redisTemplate.opsForValue().set((Object)cacheKey, (Object)fileId, 5L, TimeUnit.MINUTES);
+                    exportRecordContext.setFileId(fileId);
+                }
+                catch (Exception e) {
+                    LOGGER.info("\u5bfc\u51fa\u65f6\uff0c\u521d\u59cb\u5316\u5bfc\u51fa\u4efb\u52a1\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+                    this.redisTemplate.delete((Object)cacheKey);
+                    throw new CompletionException(e);
+                }
+            }).thenAccept(n -> {
+                try {
+                    this.export(param, clazz, context, exportRecordContext);
+                }
+                catch (Exception e) {
+                    ServiceException serviceException = (ServiceException)e.getCause();
+                    LOGGER.info("\u5bfc\u51fa\u65f6\u5f02\u5e38\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+                    AttendFileFinishParam fileFinishParam = new AttendFileFinishParam();
+                    fileFinishParam.setFileId(exportRecordContext.getFileId());
+                    fileFinishParam.setErrorCode("76240405");
+                    fileFinishParam.setFileStatus(FileStatusEnum.FAIL.getCode());
+                    fileFinishParam.setErrorMessage(serviceException.getMessage());
+                    this.attendDownloadCenterService.finishDownload(fileFinishParam, context);
+                    throw new CompletionException(e);
+                }
+                finally {
+                    FeignThreadLocalUtil.remove();
+                    this.redisTemplate.delete((Object)cacheKey);
+                }
+            })).whenComplete((n, e) -> {
+                if (null != e) {
+                    ServiceException serviceException = (ServiceException)e.getCause();
+                    LOGGER.error("\u5f02\u6b65\u5bfc\u51fa\u4efb\u52a1\u8fd0\u884c\u5931\u8d25\uff0c\u539f\u56e0\uff1a", e);
+                    AttendFileFinishParam fileFinishParam = new AttendFileFinishParam();
+                    fileFinishParam.setFileId(exportRecordContext.getFileId());
+                    fileFinishParam.setErrorCode(serviceException.getCode());
+                    fileFinishParam.setErrorMessage(serviceException.getMessage());
+                    fileFinishParam.setFileStatus(FileStatusEnum.FAIL.getCode());
+                    this.attendDownloadCenterService.finishDownload(fileFinishParam, context);
+                } else if (FileStatusEnum.CANCELED.getCode().intValue() != exportRecordContext.getTaskStatus()) {
+                    LOGGER.info("\u5f02\u6b65\u5bfc\u51fa\u6210\u529f\u3002[{}]", (Object)exportRecordContext.toString());
+                    AttendFileFinishParam fileFinishParam = new AttendFileFinishParam();
+                    fileFinishParam.setFileId(exportRecordContext.getFileId());
+                    fileFinishParam.setFilePath(exportRecordContext.getFilePath());
+                    fileFinishParam.setFileSize(exportRecordContext.getFileSize());
+                    fileFinishParam.setFileStatus(FileStatusEnum.FINISH.getCode());
+                    this.attendDownloadCenterService.finishDownload(fileFinishParam, context);
+                }
+            });
+            return CloudwalkResult.success((Object)true);
+        }
+        catch (Exception e2) {
+            this.logger.error("\u5f02\u6b65\u5bfc\u51fa\u4efb\u52a1\u5f02\u5e38\uff0c\u539f\u56e0\uff1a", (Throwable)e2);
+            throw new ServiceException((Throwable)e2);
+        }
+    }
+
+    private void export(T param, Class<R> clazz, CloudwalkCallContext context, ExportRecordContext exportRecordContext) throws Exception {
+        ByteArrayInputStream inputStream;
+        ByteArrayOutputStream outputStream;
+        block3: {
+            int taskStatus;
+            FeignRequestUtil.setRequestHeader((CloudwalkCallContext)context);
+            int startPage = 1;
+            int pageSize = 200;
+            int maxPageSize = this.EXPORT_MAX_RECORD / 200;
+            outputStream = new ByteArrayOutputStream();
+            inputStream = null;
+            do {
+                CloudwalkPageInfo pageInfo = new CloudwalkPageInfo(startPage, 200);
+                CloudwalkPageAble<R> dataPage = this.queryPage(param, pageInfo, context);
+                ArrayList dataList = Lists.newArrayList((Iterable)dataPage.getDatas());
+                this.attendParallelismDownloadManager.parallelResolve((List)dataList, clazz);
+                if (startPage == 1) {
+                    ExcelCallback callback = this.getExcelCallback(param);
+                    ExcelUtil.getListToExcel((List)dataList, (String)exportRecordContext.getFileName(), (OutputStream)outputStream, clazz, (Integer)this.getStartRow(), (ExcelCallback)callback);
+                } else {
+                    outputStream = new ByteArrayOutputStream();
+                    ExcelUtil.appendListToExcel((InputStream)inputStream, (List)dataList, (int)0, (OutputStream)outputStream, clazz, (Integer)((startPage - 1) * 200 + this.getStartRow() + 1));
+                }
+                inputStream = new ByteArrayInputStream(outputStream.toByteArray());
+                if ((long)(++startPage) > dataPage.getTotalPages() || startPage > maxPageSize) break block3;
+                taskStatus = this.attendDownloadCenterService.queryDownloadStatus(exportRecordContext.getFileId(), context);
+            } while (FileStatusEnum.PRODUCING.getCode() == taskStatus);
+            this.logger.info("\u5bfc\u51fa\u4efb\u52a1\u5df2\u53d6\u6d88");
+            exportRecordContext.setTaskStatus(taskStatus);
+            IOUtils.closeQuietly((InputStream)inputStream);
+            return;
+        }
+        IOUtils.closeQuietly((InputStream)inputStream);
+        byte[] fileByte = outputStream.toByteArray();
+        exportRecordContext.setFileSize(Long.valueOf(fileByte.length));
+        String filePath = this.fileStore(exportRecordContext.getFileName() + ".xls", fileByte);
+        exportRecordContext.setFilePath(filePath);
+    }
+
+    private String fileStore(String fileName, byte[] bytes) throws ServiceException {
+        int size = bytes.length;
+        LOGGER.info("\u6587\u4ef6\u5927\u5c0f\u4e3a: {}", (Object)size);
+        FilePartInitParam param = new FilePartInitParam();
+        param.setFileName(fileName);
+        LOGGER.info("\u6587\u4ef6\u5206\u7247\u521d\u59cb\u5316\u5f00\u59cb");
+        CloudwalkResult result = this.attendFileStorageService.filePartInit(param);
+        if (result.isSuccess()) {
+            CloudwalkResult finishResult;
+            LOGGER.info("\u6587\u4ef6\u5206\u7247\u521d\u59cb\u5316\u7ed3\u675f\uff0cuploadId = {}, filePath = {}", (Object)((FilePartResult)result.getData()).getUploadId(), (Object)((FilePartResult)result.getData()).getFilePath());
+            FilePartResult filePartResult = (FilePartResult)result.getData();
+            int times = 0;
+            while (true) {
+                int start;
+                int end = (start = times++ * FILE_PART_BATCH_SIZE) + FILE_PART_BATCH_SIZE > size ? size : start + FILE_PART_BATCH_SIZE;
+                byte[] trunk = Arrays.copyOfRange(bytes, start, end);
+                LOGGER.info("\u7b2c{}\u4e2a\u5206\u7247\u5f00\u59cb\u8ffd\u52a0\uff0cuploadId = {}, filePath = {}, size ; {}", new Object[]{times, filePartResult.getUploadId(), filePartResult.getFilePath(), trunk.length});
+                FilePartAppendParam appendParam = new FilePartAppendParam();
+                appendParam.setFilePath(filePartResult.getFilePath());
+                appendParam.setPartNumber(Integer.valueOf(times));
+                appendParam.setUploadId(filePartResult.getUploadId());
+                appendParam.setContent((Object)trunk);
+                this.attendFileStorageService.filePartAppend(appendParam);
+                LOGGER.info("\u7b2c{}\u4e2a\u5206\u7247\u5b8c\u6210\u8ffd\u52a0\uff0cuploadId = {}, filePath = {}", new Object[]{times, filePartResult.getUploadId(), filePartResult.getFilePath()});
+                if (end < size) continue;
+                LOGGER.info("\u8ffd\u52a0\u5b8c\u6210\uff0c\u51c6\u5907\u7ed3\u675f\uff0cuploadId = {}, filePath = {}", (Object)filePartResult.getUploadId(), (Object)filePartResult.getFilePath());
+                FilePartFinishParam finishParam = new FilePartFinishParam();
+                finishParam.setFilePath(filePartResult.getFilePath());
+                finishParam.setUploadId(filePartResult.getUploadId());
+                finishParam.setFileSize(Long.valueOf(size));
+                finishParam.setReturnType(Integer.valueOf(1));
+                finishResult = this.attendFileStorageService.filePartFinish(finishParam);
+                LOGGER.info("\u7ed3\u675f\u5b8c\u6210\uff0cuploadId = {}, filePath = {}, finishFilePath = {}", new Object[]{filePartResult.getUploadId(), filePartResult.getFilePath(), finishResult.getData()});
+                if (finishResult.isSuccess()) break;
+            }
+            return ((String)finishResult.getData()).split("=")[1];
+        }
+        throw new ServiceException(result.getCode(), result.getMessage());
+    }
+
+    protected abstract CloudwalkPageAble<R> queryPage(T var1, CloudwalkPageInfo var2, CloudwalkCallContext var3) throws ServiceException;
+
+    protected abstract String getDefaultFileName();
+
+    protected abstract String getDefaultFileTitleName();
+
+    protected abstract ExcelCallback getExcelCallback(Object var1);
+
+    protected abstract Integer getStartRow();
+
+    protected ThreadPoolTaskExecutor getExportExecutor() {
+        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
+        executor.setCorePoolSize(5);
+        executor.setMaxPoolSize(30);
+        executor.setThreadNamePrefix("Export-Pool-Executor");
+        executor.setQueueCapacity(25);
+        executor.initialize();
+        executor.setRejectedExecutionHandler((RejectedExecutionHandler)new ThreadPoolExecutor.AbortPolicy());
+        return executor;
+    }
+
+    public CloudwalkResult<Integer> exportCount() throws ServiceException {
+        try {
+            return CloudwalkResult.success((Object)this.EXPORT_MAX_RECORD);
+        }
+        catch (Exception e) {
+            LOGGER.error("\u83b7\u53d6\u6700\u5927\u5bfc\u51fa\u8bb0\u5f55\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            return CloudwalkResult.fail((String)"762508021", (String)this.getMessage("\u83b7\u53d6\u6700\u5927\u5bfc\u51fa\u8bb0\u5f55\u5931\u8d25"));
+        }
+    }
+
+    private static class ExportRecordContext {
+        private String fileId;
+        private String filePath;
+        private String fileName;
+        private Long fileSize;
+        private int taskStatus;
+
+        private ExportRecordContext() {
+        }
+
+        public int getTaskStatus() {
+            return this.taskStatus;
+        }
+
+        public void setTaskStatus(int taskStatus) {
+            this.taskStatus = taskStatus;
+        }
+
+        public String getFileId() {
+            return this.fileId;
+        }
+
+        public void setFileId(String fileId) {
+            this.fileId = fileId;
+        }
+
+        public String getFilePath() {
+            return this.filePath;
+        }
+
+        public void setFilePath(String filePath) {
+            this.filePath = filePath;
+        }
+
+        public String getFileName() {
+            return this.fileName;
+        }
+
+        public void setFileName(String fileName) {
+            this.fileName = fileName;
+        }
+
+        public Long getFileSize() {
+            return this.fileSize;
+        }
+
+        public void setFileSize(Long fileSize) {
+            this.fileSize = fileSize;
+        }
+
+        public String toString() {
+            return "ExportRecordContext{fileId='" + this.fileId + '\'' + ", filePath='" + this.filePath + '\'' + ", fileName='" + this.fileName + '\'' + ", fileSize=" + this.fileSize + ", taskStatus=" + this.taskStatus + '}';
+        }
+
+        private static class Builder {
+            private String fileId;
+            private String filePath;
+            private String fileName;
+            private Long fileSize;
+            private int taskStatus;
+
+            private Builder() {
+            }
+
+            public Builder withTaskStatus(int taskStatus) {
+                this.taskStatus = taskStatus;
+                return this;
+            }
+
+            public Builder withFileId(String fileId) {
+                this.fileId = fileId;
+                return this;
+            }
+
+            public Builder withFilePath(String filePath) {
+                this.filePath = filePath;
+                return this;
+            }
+
+            public Builder withFileName(String fileName) {
+                this.fileName = fileName;
+                return this;
+            }
+
+            public Builder withFileSize(Long fileSize) {
+                this.fileSize = fileSize;
+                return this;
+            }
+
+            public ExportRecordContext build() {
+                ExportRecordContext context = new ExportRecordContext();
+                context.setFileId(this.fileId);
+                context.setFileSize(this.fileSize);
+                context.setFilePath(this.filePath);
+                context.setFileName(this.fileName);
+                context.setTaskStatus(this.taskStatus);
+                return context;
+            }
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/export/AttendResultDetailExportAsyncService.java

@@ -0,0 +1,126 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.report.param.AttendReportDetailParam
+ *  cn.cloudwalk.client.ninca.attendance.report.result.AttendReportDetailExcelResult
+ *  cn.cloudwalk.client.ninca.attendance.report.result.AttendReportDetailResult
+ *  cn.cloudwalk.client.ninca.attendance.report.service.AttendReportService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.page.CloudwalkPageAble
+ *  cn.cloudwalk.cloud.page.CloudwalkPageInfo
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.common.ExcelCallback
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendReportResultStatusEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendResultReasonEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.AttendUtil
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtils
+ *  org.apache.poi.hssf.usermodel.HSSFRow
+ *  org.apache.poi.ss.util.CellRangeAddress
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.export;
+
+import cn.cloudwalk.client.ninca.attendance.report.param.AttendReportDetailParam;
+import cn.cloudwalk.client.ninca.attendance.report.result.AttendReportDetailExcelResult;
+import cn.cloudwalk.client.ninca.attendance.report.result.AttendReportDetailResult;
+import cn.cloudwalk.client.ninca.attendance.report.service.AttendReportService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.page.CloudwalkPageAble;
+import cn.cloudwalk.cloud.page.CloudwalkPageInfo;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.common.ExcelCallback;
+import cn.cloudwalk.common.ninca.attendance.em.AttendReportResultStatusEnum;
+import cn.cloudwalk.common.ninca.attendance.em.AttendResultReasonEnum;
+import cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.AttendUtil;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtils;
+import cn.cloudwalk.service.ninca.attendance.export.AttendAbstractExportAsyncService;
+import cn.cloudwalk.service.ninca.attendance.export.ExcelExportUtil;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import org.apache.poi.hssf.usermodel.HSSFRow;
+import org.apache.poi.ss.util.CellRangeAddress;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendResultDetailExportAsyncService
+extends AttendAbstractExportAsyncService<AttendReportDetailParam, AttendReportDetailExcelResult> {
+    private static final String DEFAULT_EXPORT_FILE_NAME = "\u8003\u52e4\u660e\u7ec6\u5bfc\u51fa";
+    private static final String DEFAULT_EXPORT_FILE_TITLE_NAME = "\u8003\u52e4\u660e\u7ec6_\u65e5\u62a5";
+    private static final int DEFAULT_EXPORT_START_ROW = 2;
+    @Autowired
+    private AttendReportService attendReportService;
+
+    @Override
+    protected CloudwalkPageAble<AttendReportDetailExcelResult> queryPage(AttendReportDetailParam param, CloudwalkPageInfo pageInfo, CloudwalkCallContext context) throws ServiceException {
+        CloudwalkResult result = this.attendReportService.detail(param, pageInfo, context);
+        if (result.isSuccess()) {
+            ArrayList<AttendReportDetailExcelResult> excelResults = new ArrayList<AttendReportDetailExcelResult>();
+            List results = (List)((CloudwalkPageAble)result.getData()).getDatas();
+            for (AttendReportDetailResult detailResult : results) {
+                AttendReportDetailExcelResult excelResult = (AttendReportDetailExcelResult)BeanCopyUtils.copyProperties((Object)detailResult, AttendReportDetailExcelResult.class);
+                excelResult.setAttDay(detailResult.getAttDay() == null ? null : DateUtils.formatDate((Date)new Date(detailResult.getAttDay()), (String)"yyyy-MM-dd"));
+                excelResult.setRuleType(detailResult.getRuleType() == null ? null : AttendTypeEnum.getMessageByCode((Integer)detailResult.getRuleType()));
+                excelResult.setStartWorkTime(detailResult.getStartWorkTime() == null ? "-" : AttendUtil.setTimeDesc((Long)detailResult.getAttDay(), (Long)detailResult.getStartWorkTime()));
+                excelResult.setEndWorkTime(detailResult.getEndWorkTime() == null ? "-" : AttendUtil.setTimeDesc((Long)detailResult.getAttDay(), (Long)detailResult.getEndWorkTime()));
+                excelResult.setInitStatus(detailResult.getInitStatus() == null ? "-" : AttendReportResultStatusEnum.getMessageByCode((Integer)detailResult.getInitStatus()));
+                excelResult.setEndStatus(detailResult.getEndStatus() == null ? "-" : AttendReportResultStatusEnum.getMessageByCode((Integer)detailResult.getEndStatus()));
+                excelResult.setReason(detailResult.getReason() == null ? "-" : AttendResultReasonEnum.getMessageByCode((Integer)detailResult.getReason()));
+                if (detailResult.getRuleStartWorkTime() != null && detailResult.getRuleEndWorkTime() != null) {
+                    excelResult.setRuleAttendTime(AttendUtil.setTimeDesc((Long)detailResult.getAttDay(), (Long)detailResult.getRuleStartWorkTime()) + "-" + AttendUtil.setTimeDesc((Long)detailResult.getAttDay(), (Long)detailResult.getRuleEndWorkTime()));
+                }
+                excelResult.setIsOverTime(YesNoTypeEnum.getMessageByCode((Integer)detailResult.getIsOverTime()));
+                excelResult.setLabelNames(detailResult.getLabelNames() == null ? null : detailResult.getLabelNames().toString());
+                excelResults.add(excelResult);
+            }
+            return new CloudwalkPageAble(excelResults, pageInfo, ((CloudwalkPageAble)result.getData()).getTotalRows());
+        }
+        throw new ServiceException(result.getCode(), result.getMessage());
+    }
+
+    @Override
+    protected String getDefaultFileName() {
+        return DEFAULT_EXPORT_FILE_NAME + DateUtils.formatDate((Date)new Date(), (String)"yyyyMMddHHmmss") + ".xls";
+    }
+
+    @Override
+    protected String getDefaultFileTitleName() {
+        return DEFAULT_EXPORT_FILE_TITLE_NAME;
+    }
+
+    @Override
+    protected ExcelCallback getExcelCallback(Object object) {
+        AttendReportDetailParam param = (AttendReportDetailParam)object;
+        return (workBook, sheet) -> {
+            HSSFRow row1 = sheet.createRow(0);
+            HSSFRow row2 = sheet.createRow(1);
+            int columnSize = ExcelExportUtil.getColumnSize(AttendReportDetailExcelResult.class);
+            for (int i = 0; i < columnSize; ++i) {
+                row1.createCell(i);
+                row1.setHeight((short)700);
+                row2.createCell(i);
+            }
+            sheet.addMergedRegion(new CellRangeAddress(0, 0, 0, columnSize));
+            sheet.addMergedRegion(new CellRangeAddress(1, 1, 0, columnSize));
+            ExcelExportUtil.setRow1(workBook, sheet, DEFAULT_EXPORT_FILE_TITLE_NAME);
+            ExcelExportUtil.setRow2(workBook, sheet, param.getStartDay(), param.getEndDay());
+        };
+    }
+
+    @Override
+    protected Integer getStartRow() {
+        return 2;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/export/AttendResultStatisticalExportAsyncService.java

@@ -0,0 +1,158 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.report.param.AttendReportStatisticalParam
+ *  cn.cloudwalk.client.ninca.attendance.report.result.AttendReportStatisticalExcelResult
+ *  cn.cloudwalk.client.ninca.attendance.report.result.AttendReportStatisticalResult
+ *  cn.cloudwalk.client.ninca.attendance.report.service.AttendReportService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.page.CloudwalkPageAble
+ *  cn.cloudwalk.cloud.page.CloudwalkPageInfo
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.common.ExcelCallback
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtils
+ *  org.apache.poi.hssf.usermodel.HSSFCellStyle
+ *  org.apache.poi.hssf.usermodel.HSSFFont
+ *  org.apache.poi.hssf.usermodel.HSSFRow
+ *  org.apache.poi.ss.usermodel.BorderStyle
+ *  org.apache.poi.ss.usermodel.FillPatternType
+ *  org.apache.poi.ss.usermodel.HorizontalAlignment
+ *  org.apache.poi.ss.usermodel.IndexedColors
+ *  org.apache.poi.ss.usermodel.VerticalAlignment
+ *  org.apache.poi.ss.util.CellRangeAddress
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.export;
+
+import cn.cloudwalk.client.ninca.attendance.report.param.AttendReportStatisticalParam;
+import cn.cloudwalk.client.ninca.attendance.report.result.AttendReportStatisticalExcelResult;
+import cn.cloudwalk.client.ninca.attendance.report.result.AttendReportStatisticalResult;
+import cn.cloudwalk.client.ninca.attendance.report.service.AttendReportService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.page.CloudwalkPageAble;
+import cn.cloudwalk.cloud.page.CloudwalkPageInfo;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.common.ExcelCallback;
+import cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtils;
+import cn.cloudwalk.service.ninca.attendance.export.AttendAbstractExportAsyncService;
+import cn.cloudwalk.service.ninca.attendance.export.ExcelExportUtil;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import org.apache.poi.hssf.usermodel.HSSFCellStyle;
+import org.apache.poi.hssf.usermodel.HSSFFont;
+import org.apache.poi.hssf.usermodel.HSSFRow;
+import org.apache.poi.ss.usermodel.BorderStyle;
+import org.apache.poi.ss.usermodel.FillPatternType;
+import org.apache.poi.ss.usermodel.HorizontalAlignment;
+import org.apache.poi.ss.usermodel.IndexedColors;
+import org.apache.poi.ss.usermodel.VerticalAlignment;
+import org.apache.poi.ss.util.CellRangeAddress;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendResultStatisticalExportAsyncService
+extends AttendAbstractExportAsyncService<AttendReportStatisticalParam, AttendReportStatisticalExcelResult> {
+    private static final String DEFAULT_EXPORT_FILE_NAME = "\u8003\u52e4\u6309\u6708\u7edf\u8ba1\u5bfc\u51fa";
+    private static final String DEFAULT_EXPORT_FILE_TITLE_NAME = "\u4e0a\u4e0b\u73ed\u6253\u5361_\u6708\u62a5";
+    private static final int DEFAULT_EXPORT_START_ROW = 3;
+    @Autowired
+    private AttendReportService attendReportService;
+
+    @Override
+    protected CloudwalkPageAble<AttendReportStatisticalExcelResult> queryPage(AttendReportStatisticalParam param, CloudwalkPageInfo pageInfo, CloudwalkCallContext context) throws ServiceException {
+        CloudwalkResult result = this.attendReportService.statistical(param, pageInfo, context);
+        if (result.isSuccess()) {
+            ArrayList<AttendReportStatisticalExcelResult> excelResults = new ArrayList<AttendReportStatisticalExcelResult>();
+            List resultList = (List)((CloudwalkPageAble)result.getData()).getDatas();
+            for (AttendReportStatisticalResult statisticalResult : resultList) {
+                AttendReportStatisticalExcelResult excelResult = (AttendReportStatisticalExcelResult)BeanCopyUtils.copyProperties((Object)statisticalResult, AttendReportStatisticalExcelResult.class);
+                excelResult.setRuleType(statisticalResult.getRuleType() == null ? null : AttendTypeEnum.getMessageByCode((Integer)statisticalResult.getRuleType()));
+                excelResult.setStartNormal(Integer.valueOf(statisticalResult.getNormal() - statisticalResult.getCorrect()));
+                excelResult.setLateTime(DateUtils.formatTimeDurationHour((long)((long)statisticalResult.getLateTime().intValue() * 60000L), (int)2));
+                excelResult.setLeaveEarlyTime(DateUtils.formatTimeDurationHour((long)((long)statisticalResult.getLeaveEarlyTime().intValue() * 60000L), (int)2));
+                excelResult.setAbsenteeism(DateUtils.formatTimeDurationHour((long)((long)statisticalResult.getAbsenteeism().intValue() * 60000L), (int)2));
+                int totalTime = statisticalResult.getLateTime() + statisticalResult.getLeaveEarlyTime() + statisticalResult.getAbsenteeism();
+                excelResult.setTotalTime(DateUtils.formatTimeDurationHour((long)((long)totalTime * 60000L), (int)2));
+                excelResult.setLabelNames(statisticalResult.getLabelNames() == null ? null : statisticalResult.getLabelNames().toString());
+                excelResults.add(excelResult);
+            }
+            return new CloudwalkPageAble(excelResults, pageInfo, ((CloudwalkPageAble)result.getData()).getTotalRows());
+        }
+        throw new ServiceException(result.getCode(), result.getMessage());
+    }
+
+    @Override
+    protected String getDefaultFileName() {
+        return DEFAULT_EXPORT_FILE_NAME + DateUtils.formatDate((Date)new Date(), (String)"yyyyMMddHHmmss") + ".xls";
+    }
+
+    @Override
+    protected String getDefaultFileTitleName() {
+        return DEFAULT_EXPORT_FILE_TITLE_NAME;
+    }
+
+    @Override
+    protected ExcelCallback getExcelCallback(Object object) {
+        AttendReportStatisticalParam param = (AttendReportStatisticalParam)object;
+        return (workBook, sheet) -> {
+            HSSFRow row1 = sheet.createRow(0);
+            HSSFRow row2 = sheet.createRow(1);
+            HSSFRow row3 = sheet.createRow(2);
+            int columnSize = ExcelExportUtil.getColumnSize(AttendReportStatisticalExcelResult.class);
+            for (int i = 0; i < columnSize; ++i) {
+                row1.createCell(i);
+                row1.setHeight((short)700);
+                row2.createCell(i);
+                row3.createCell(i);
+            }
+            sheet.addMergedRegion(new CellRangeAddress(0, 0, 0, columnSize - 1));
+            sheet.addMergedRegion(new CellRangeAddress(1, 1, 0, columnSize - 1));
+            sheet.addMergedRegion(new CellRangeAddress(2, 2, 0, 6));
+            sheet.addMergedRegion(new CellRangeAddress(2, 2, 7, 9));
+            sheet.addMergedRegion(new CellRangeAddress(2, 2, 10, 13));
+            sheet.addMergedRegion(new CellRangeAddress(2, 2, 14, 21));
+            ExcelExportUtil.setRow1(workBook, sheet, DEFAULT_EXPORT_FILE_TITLE_NAME);
+            ExcelExportUtil.setRow2(workBook, sheet, param.getStartDay(), param.getEndDay());
+            HSSFCellStyle cellStyle3 = workBook.createCellStyle();
+            HSSFFont font3 = workBook.createFont();
+            font3.setFontHeightInPoints((short)11);
+            cellStyle3.setFont(font3);
+            cellStyle3.setFillForegroundColor(IndexedColors.SKY_BLUE.getIndex());
+            cellStyle3.setFillPattern(FillPatternType.SOLID_FOREGROUND);
+            cellStyle3.setAlignment(HorizontalAlignment.CENTER);
+            cellStyle3.setVerticalAlignment(VerticalAlignment.CENTER);
+            sheet.getRow(2).getCell(0).setCellValue("\u57fa\u672c\u4fe1\u606f");
+            sheet.getRow(2).getCell(0).setCellStyle(cellStyle3);
+            sheet.getRow(2).getCell(7).setCellValue("\u6982\u89c8");
+            sheet.getRow(2).getCell(7).setCellStyle(cellStyle3);
+            sheet.getRow(2).getCell(10).setCellValue("\u5f02\u5e38\u65f6\u95f4\u7edf\u8ba1");
+            sheet.getRow(2).getCell(10).setCellStyle(cellStyle3);
+            sheet.getRow(2).getCell(14).setCellValue("\u8003\u52e4\u6b21\u6570\u8be6\u60c5");
+            sheet.getRow(2).getCell(14).setCellStyle(cellStyle3);
+            sheet.getRow(2).getCell(22).setCellValue("\u52a0\u73ed");
+            sheet.getRow(2).getCell(22).setCellStyle(cellStyle3);
+            HSSFCellStyle cellBorder = workBook.createCellStyle();
+            cellBorder.setBorderRight(BorderStyle.THIN);
+            sheet.getRow(2).getCell(6).setCellStyle(cellBorder);
+            sheet.getRow(2).getCell(9).setCellStyle(cellBorder);
+            sheet.getRow(2).getCell(13).setCellStyle(cellBorder);
+            sheet.getRow(2).getCell(21).setCellStyle(cellBorder);
+        };
+    }
+
+    @Override
+    protected Integer getStartRow() {
+        return 3;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/export/AttendSchedulingExportAsyncService.java

@@ -0,0 +1,134 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.config.param.AttendClassSchedulingDetailParam
+ *  cn.cloudwalk.client.ninca.attendance.config.result.AttendClassSchedulingDetailResult
+ *  cn.cloudwalk.client.ninca.attendance.config.result.AttendClassSchedulingExcelResult
+ *  cn.cloudwalk.client.ninca.attendance.config.result.AttendClassSchedulingResult
+ *  cn.cloudwalk.client.ninca.attendance.config.service.AttendClassSchedulingService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.page.CloudwalkPageAble
+ *  cn.cloudwalk.cloud.page.CloudwalkPageInfo
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.common.ExcelCallback
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtils
+ *  org.apache.poi.hssf.usermodel.HSSFRow
+ *  org.apache.poi.ss.util.CellRangeAddress
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.export;
+
+import cn.cloudwalk.client.ninca.attendance.config.param.AttendClassSchedulingDetailParam;
+import cn.cloudwalk.client.ninca.attendance.config.result.AttendClassSchedulingDetailResult;
+import cn.cloudwalk.client.ninca.attendance.config.result.AttendClassSchedulingExcelResult;
+import cn.cloudwalk.client.ninca.attendance.config.result.AttendClassSchedulingResult;
+import cn.cloudwalk.client.ninca.attendance.config.service.AttendClassSchedulingService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.page.CloudwalkPageAble;
+import cn.cloudwalk.cloud.page.CloudwalkPageInfo;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.common.ExcelCallback;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtils;
+import cn.cloudwalk.service.ninca.attendance.export.AttendAbstractExportAsyncService;
+import cn.cloudwalk.service.ninca.attendance.export.ExcelExportUtil;
+import java.lang.reflect.Method;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+import org.apache.poi.hssf.usermodel.HSSFRow;
+import org.apache.poi.ss.util.CellRangeAddress;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendSchedulingExportAsyncService
+extends AttendAbstractExportAsyncService<AttendClassSchedulingDetailParam, AttendClassSchedulingExcelResult> {
+    private static final String DEFAULT_EXPORT_FILE_NAME = "\u6392\u73ed\u660e\u7ec6\u5bfc\u51fa";
+    private static final String DEFAULT_EXPORT_FILE_TITLE_NAME = "\u6392\u73ed\u660e\u7ec6";
+    private static final int DEFAULT_EXPORT_START_ROW = 1;
+    @Autowired
+    private AttendClassSchedulingService attendClassSchedulingService;
+
+    @Override
+    protected CloudwalkPageAble<AttendClassSchedulingExcelResult> queryPage(AttendClassSchedulingDetailParam param, CloudwalkPageInfo pageInfo, CloudwalkCallContext context) throws ServiceException {
+        try {
+            CloudwalkResult result = this.attendClassSchedulingService.queryDetail(param, pageInfo, context, true);
+            SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");
+            List dates = DateUtils.getDays((long)param.getSchedulingStartDate(), (long)param.getSchedulingEndDate());
+            AttendClassSchedulingExcelResult excel = new AttendClassSchedulingExcelResult();
+            for (String data : dates) {
+                Date d = new Date(DateUtils.dateToStampFormat((String)data, (String)"yyyyMMdd"));
+                Class<?> clazz = excel.getClass();
+                String setMethodName = "set" + DateUtils.dateToWeek((String)sf.format(d));
+                Method setAttributeMethod = null;
+                setAttributeMethod = AttendClassSchedulingExcelResult.class.getDeclaredMethod(setMethodName, String.class);
+                setAttributeMethod.invoke(excel, data);
+            }
+            ArrayList<AttendClassSchedulingExcelResult> excelResults = new ArrayList<AttendClassSchedulingExcelResult>();
+            excelResults.add(excel);
+            if (CollectionUtils.isNotEmpty((Collection)((Collection)result.getData()))) {
+                List results = (List)result.getData();
+                for (AttendClassSchedulingDetailResult detailResult : results) {
+                    AttendClassSchedulingExcelResult excelResult = (AttendClassSchedulingExcelResult)BeanCopyUtils.copyProperties((Object)detailResult, AttendClassSchedulingExcelResult.class);
+                    for (AttendClassSchedulingResult schedulingResult : detailResult.getSchedulingList()) {
+                        Date d = new Date(schedulingResult.getDate());
+                        Class<?> clazz = excelResult.getClass();
+                        String setMethodName = "set" + DateUtils.dateToWeek((String)sf.format(d).toString());
+                        Method setAttributeMethod = null;
+                        setAttributeMethod = AttendClassSchedulingExcelResult.class.getDeclaredMethod(setMethodName, String.class);
+                        setAttributeMethod.invoke(excelResult, schedulingResult.getShiftName());
+                    }
+                    excelResults.add(excelResult);
+                }
+            }
+            return new CloudwalkPageAble(excelResults, pageInfo, (long)((List)result.getData()).size());
+        }
+        catch (Exception e) {
+            this.logger.error("\u6392\u73ed\u8003\u52e4\u5bfc\u51fa\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @Override
+    protected String getDefaultFileName() {
+        return DEFAULT_EXPORT_FILE_NAME + DateUtils.formatDate((Date)new Date(), (String)"yyyyMMddHHmmss") + ".xls";
+    }
+
+    @Override
+    protected String getDefaultFileTitleName() {
+        return DEFAULT_EXPORT_FILE_TITLE_NAME;
+    }
+
+    @Override
+    protected ExcelCallback getExcelCallback(Object object) {
+        return (workBook, sheet) -> {
+            HSSFRow row1 = sheet.createRow(0);
+            HSSFRow row2 = sheet.createRow(1);
+            int columnSize = ExcelExportUtil.getColumnSize(AttendClassSchedulingExcelResult.class);
+            for (int i = 0; i < columnSize; ++i) {
+                row1.createCell(i);
+                row1.setHeight((short)700);
+                row2.createCell(i);
+            }
+            sheet.addMergedRegion(new CellRangeAddress(0, 0, 0, columnSize));
+            sheet.addMergedRegion(new CellRangeAddress(1, 1, 0, columnSize));
+            ExcelExportUtil.setRow1(workBook, sheet, this.getDefaultFileTitleName());
+        };
+    }
+
+    @Override
+    protected Integer getStartRow() {
+        return 1;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/export/ExcelExportUtil.java

@@ -0,0 +1,78 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.common.ninca.attendance.annotation.ExcelAttribute
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtils
+ *  org.apache.poi.hssf.usermodel.HSSFCellStyle
+ *  org.apache.poi.hssf.usermodel.HSSFFont
+ *  org.apache.poi.hssf.usermodel.HSSFRichTextString
+ *  org.apache.poi.hssf.usermodel.HSSFSheet
+ *  org.apache.poi.hssf.usermodel.HSSFWorkbook
+ *  org.apache.poi.ss.usermodel.Font
+ *  org.apache.poi.ss.usermodel.HorizontalAlignment
+ *  org.apache.poi.ss.usermodel.RichTextString
+ *  org.apache.poi.ss.usermodel.VerticalAlignment
+ */
+package cn.cloudwalk.service.ninca.attendance.export;
+
+import cn.cloudwalk.common.ninca.attendance.annotation.ExcelAttribute;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtils;
+import java.lang.reflect.Field;
+import java.util.Date;
+import org.apache.poi.hssf.usermodel.HSSFCellStyle;
+import org.apache.poi.hssf.usermodel.HSSFFont;
+import org.apache.poi.hssf.usermodel.HSSFRichTextString;
+import org.apache.poi.hssf.usermodel.HSSFSheet;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
+import org.apache.poi.ss.usermodel.Font;
+import org.apache.poi.ss.usermodel.HorizontalAlignment;
+import org.apache.poi.ss.usermodel.RichTextString;
+import org.apache.poi.ss.usermodel.VerticalAlignment;
+
+class ExcelExportUtil {
+    ExcelExportUtil() {
+    }
+
+    static void setRow1(HSSFWorkbook workBook, HSSFSheet sheet, String row1Str) {
+        HSSFCellStyle cellStyle1 = workBook.createCellStyle();
+        HSSFFont font1 = workBook.createFont();
+        font1.setFontHeightInPoints((short)15);
+        font1.setBold(Boolean.TRUE.booleanValue());
+        cellStyle1.setAlignment(HorizontalAlignment.LEFT);
+        cellStyle1.setVerticalAlignment(VerticalAlignment.CENTER);
+        HSSFRichTextString row1String = new HSSFRichTextString(row1Str);
+        row1String.applyFont(0, row1Str.length(), (Font)font1);
+        sheet.getRow(0).getCell(0).setCellValue((RichTextString)row1String);
+        sheet.getRow(0).getCell(0).setCellStyle(cellStyle1);
+    }
+
+    static void setRow2(HSSFWorkbook workBook, HSSFSheet sheet, Long startDay, Long endDay) {
+        HSSFCellStyle cellStyle2 = workBook.createCellStyle();
+        HSSFFont font2 = workBook.createFont();
+        font2.setFontHeightInPoints((short)10);
+        font2.setBold(Boolean.TRUE.booleanValue());
+        cellStyle2.setAlignment(HorizontalAlignment.LEFT);
+        cellStyle2.setVerticalAlignment(VerticalAlignment.CENTER);
+        String startStr = DateUtils.formatDate((Date)new Date(startDay), (String)"yyyy-MM-dd");
+        String endStr = DateUtils.formatDate((Date)new Date(endDay), (String)"yyyy-MM-dd");
+        String exportStr = DateUtils.formatDate((Date)new Date(), (String)"yyyy-MM-dd HH:mm:ss");
+        String row2Str = "\u7edf\u8ba1\u65f6\u95f4\uff1a" + startStr + "~" + endStr + " \u5bfc\u51fa\u65f6\u95f4\uff1a" + exportStr;
+        HSSFRichTextString row2String = new HSSFRichTextString(row2Str);
+        row2String.applyFont(0, row2Str.length(), (Font)font2);
+        sheet.getRow(1).getCell(0).setCellValue((RichTextString)row2String);
+        sheet.getRow(1).getCell(0).setCellStyle(cellStyle2);
+    }
+
+    static int getColumnSize(Class clazz) {
+        Field[] allFields = clazz.getDeclaredFields();
+        int size = 0;
+        for (Field field : allFields) {
+            ExcelAttribute attr = field.getAnnotation(ExcelAttribute.class);
+            if (attr == null || !attr.isExport()) continue;
+            ++size;
+        }
+        return size;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/holiday/HolidayServiceImpl.java

@@ -0,0 +1,73 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.holiday.SysHolidayManager
+ *  cn.cloudwalk.client.ninca.attendance.holiday.param.HolidayListParam
+ *  cn.cloudwalk.client.ninca.attendance.holiday.service.HolidayService
+ *  cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleHolidayQueryResult
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.common.ninca.attendance.bean.holiday.dto.SysHolidayConfDTO
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtil
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.holiday;
+
+import cn.cloudwalk.biz.intelligent.ninca.holiday.SysHolidayManager;
+import cn.cloudwalk.client.ninca.attendance.holiday.param.HolidayListParam;
+import cn.cloudwalk.client.ninca.attendance.holiday.service.HolidayService;
+import cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleHolidayQueryResult;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.common.ninca.attendance.bean.holiday.dto.SysHolidayConfDTO;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtil;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.ArrayList;
+import java.util.List;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+@Service
+public class HolidayServiceImpl
+extends AbstractCloudwalkService
+implements HolidayService {
+    @Resource
+    private SysHolidayManager sysHolidayManager;
+
+    public CloudwalkResult<List<AttendRuleHolidayQueryResult>> list(HolidayListParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            Long startDate = null;
+            startDate = param.getStartDate() == null ? Long.valueOf(DateUtil.getCurrYearFirst().getTime()) : param.getStartDate();
+            Long endDate = param.getEndDate();
+            List resultList = this.sysHolidayManager.gets(startDate, endDate);
+            return CloudwalkResult.success(this.setHolidayResult(resultList));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u67e5\u8be2\u7cfb\u7edf\u8282\u5047\u65e5\u5931\u8d25", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private List<AttendRuleHolidayQueryResult> setHolidayResult(List<SysHolidayConfDTO> resultList) {
+        if (CollectionUtils.isEmpty(resultList)) {
+            return new ArrayList<AttendRuleHolidayQueryResult>();
+        }
+        ArrayList<AttendRuleHolidayQueryResult> list = new ArrayList<AttendRuleHolidayQueryResult>(110);
+        for (SysHolidayConfDTO confDTO : resultList) {
+            AttendRuleHolidayQueryResult result = new AttendRuleHolidayQueryResult();
+            result.setHoliday(confDTO.getHolidayDate());
+            result.setType(confDTO.getType());
+            list.add(result);
+        }
+        return list;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/record/push/AttendRecordPushEvent.java

@@ -0,0 +1,154 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.cwos.client.event.event.CustomEvent
+ */
+package cn.cloudwalk.service.ninca.attendance.record.push;
+
+import cn.cloudwalk.cwos.client.event.event.CustomEvent;
+import java.math.BigDecimal;
+
+public class AttendRecordPushEvent
+extends CustomEvent {
+    private String id;
+    private String personId;
+    private String personName;
+    private String orgId;
+    private String orgName;
+    private String deviceCode;
+    private String districtMergeName;
+    private String deviceAreaName;
+    private Long signTime;
+    private String faceUrl;
+    private String spotImgPath;
+    private String panoramaPath;
+    private BigDecimal score;
+    private Integer status;
+    private BigDecimal threshold;
+
+    public String getTopic() {
+        return "ATTEND_RECORD_TOPIC";
+    }
+
+    public String getId() {
+        return this.id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getPersonId() {
+        return this.personId;
+    }
+
+    public void setPersonId(String personId) {
+        this.personId = personId;
+    }
+
+    public String getPersonName() {
+        return this.personName;
+    }
+
+    public void setPersonName(String personName) {
+        this.personName = personName;
+    }
+
+    public String getOrgId() {
+        return this.orgId;
+    }
+
+    public void setOrgId(String orgId) {
+        this.orgId = orgId;
+    }
+
+    public String getOrgName() {
+        return this.orgName;
+    }
+
+    public void setOrgName(String orgName) {
+        this.orgName = orgName;
+    }
+
+    public String getDeviceCode() {
+        return this.deviceCode;
+    }
+
+    public void setDeviceCode(String deviceCode) {
+        this.deviceCode = deviceCode;
+    }
+
+    public String getDistrictMergeName() {
+        return this.districtMergeName;
+    }
+
+    public void setDistrictMergeName(String districtMergeName) {
+        this.districtMergeName = districtMergeName;
+    }
+
+    public String getDeviceAreaName() {
+        return this.deviceAreaName;
+    }
+
+    public void setDeviceAreaName(String deviceAreaName) {
+        this.deviceAreaName = deviceAreaName;
+    }
+
+    public Long getSignTime() {
+        return this.signTime;
+    }
+
+    public void setSignTime(Long signTime) {
+        this.signTime = signTime;
+    }
+
+    public String getFaceUrl() {
+        return this.faceUrl;
+    }
+
+    public void setFaceUrl(String faceUrl) {
+        this.faceUrl = faceUrl;
+    }
+
+    public String getSpotImgPath() {
+        return this.spotImgPath;
+    }
+
+    public void setSpotImgPath(String spotImgPath) {
+        this.spotImgPath = spotImgPath;
+    }
+
+    public String getPanoramaPath() {
+        return this.panoramaPath;
+    }
+
+    public void setPanoramaPath(String panoramaPath) {
+        this.panoramaPath = panoramaPath;
+    }
+
+    public BigDecimal getScore() {
+        return this.score;
+    }
+
+    public void setScore(BigDecimal score) {
+        this.score = score;
+    }
+
+    public Integer getStatus() {
+        return this.status;
+    }
+
+    public void setStatus(Integer status) {
+        this.status = status;
+    }
+
+    public BigDecimal getThreshold() {
+        return this.threshold;
+    }
+
+    public void setThreshold(BigDecimal threshold) {
+        this.threshold = threshold;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/record/push/aspect/AttendRecordAddAspect.java

@@ -0,0 +1,94 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.cloud.serial.UUIDSerial
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendRecordDTO
+ *  cn.cloudwalk.common.ninca.attendance.util.StringUtils
+ *  cn.cloudwalk.cwos.client.event.event.BaseEvent
+ *  cn.cloudwalk.event.CloudwalkEventManager
+ *  javax.annotation.Resource
+ *  org.aspectj.lang.ProceedingJoinPoint
+ *  org.aspectj.lang.annotation.Around
+ *  org.aspectj.lang.annotation.Aspect
+ *  org.aspectj.lang.annotation.Pointcut
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.core.annotation.Order
+ *  org.springframework.stereotype.Component
+ */
+package cn.cloudwalk.service.ninca.attendance.record.push.aspect;
+
+import cn.cloudwalk.cloud.serial.UUIDSerial;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendRecordDTO;
+import cn.cloudwalk.common.ninca.attendance.util.StringUtils;
+import cn.cloudwalk.cwos.client.event.event.BaseEvent;
+import cn.cloudwalk.event.CloudwalkEventManager;
+import cn.cloudwalk.service.ninca.attendance.common.AttendanceProperties;
+import cn.cloudwalk.service.ninca.attendance.record.push.AttendRecordPushEvent;
+import javax.annotation.Resource;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.annotation.Order;
+import org.springframework.stereotype.Component;
+
+@Aspect
+@Order(value=-999)
+@Component
+public class AttendRecordAddAspect {
+    private static final Logger logger = LoggerFactory.getLogger(AttendRecordAddAspect.class);
+    @Autowired
+    private AttendanceProperties attendanceProperties;
+    @Resource
+    private CloudwalkEventManager cloudwalkEventManager;
+    @Autowired
+    private UUIDSerial uuidSerial;
+
+    @Pointcut(value="execution(* cn.cloudwalk.biz.intelligent.ninca.result.AttendRecordManager.add(..))")
+    public void recogRecordAddPointcut() {
+    }
+
+    @Around(value="recogRecordAddPointcut()")
+    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
+        Object[] args = joinPoint.getArgs();
+        AttendRecordDTO param = (AttendRecordDTO)args[0];
+        Integer addResult = (Integer)joinPoint.proceed();
+        try {
+            if (addResult > 0 && this.attendanceProperties.isRecordPush()) {
+                if (StringUtils.isNotBlank((String)this.attendanceProperties.getRecordPushServiceCode())) {
+                    AttendRecordPushEvent pushEvent = this.buildRecordPushEvent(param);
+                    this.cloudwalkEventManager.publish((BaseEvent)pushEvent);
+                } else {
+                    logger.error("\u63a8\u9001\u8003\u52e4\u8bb0\u5f55,\u914d\u7f6eserviceCode\u4e3a\u7a7a\uff0c\u4e0d\u6267\u884c\u63a8\u9001");
+                }
+            }
+        }
+        catch (Exception e) {
+            logger.error("\u63a8\u9001\u8003\u52e4\u8bb0\u5f55\u5f02\u5e38,\u539f\u56e0\uff1a", (Throwable)e);
+        }
+        return addResult;
+    }
+
+    private AttendRecordPushEvent buildRecordPushEvent(AttendRecordDTO param) {
+        AttendRecordPushEvent event = (AttendRecordPushEvent)((Object)BeanCopyUtils.copyProperties((Object)param, AttendRecordPushEvent.class));
+        event.setMessageId(this.uuidSerial.uuid());
+        event.setFaceUrl(this.genFullPath(param.getFaceUrl()));
+        event.setPanoramaPath(this.genFullPath(param.getPanoramaPath()));
+        event.setSpotImgPath(this.genFullPath(param.getSpotImgPath()));
+        event.setServiceCode(this.attendanceProperties.getRecordPushServiceCode());
+        return event;
+    }
+
+    private String genFullPath(String path) {
+        return StringUtils.isNotBlank((String)path) ? this.attendanceProperties.getCwosPicUrl() + path : null;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/report/AttendBusinessDayReportServiceImpl.java

@@ -0,0 +1,105 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.report.AttendBusinessDayReportManager
+ *  cn.cloudwalk.client.ninca.attendance.report.service.AttendBusinessDayReportService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendBusinessDayReportAddDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendBusinessDayReportEditDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendBusinessDayReportQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendBusinessDayReportQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendBusinessDayReportResultGenQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendBusinessDayReportResultGenQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ *  org.springframework.transaction.annotation.Transactional
+ */
+package cn.cloudwalk.service.ninca.attendance.report;
+
+import cn.cloudwalk.biz.intelligent.ninca.report.AttendBusinessDayReportManager;
+import cn.cloudwalk.client.ninca.attendance.report.service.AttendBusinessDayReportService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendBusinessDayReportAddDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendBusinessDayReportEditDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendBusinessDayReportQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendBusinessDayReportQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendBusinessDayReportResultGenQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendBusinessDayReportResultGenQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class AttendBusinessDayReportServiceImpl
+extends AbstractCloudwalkService
+implements AttendBusinessDayReportService {
+    @Resource
+    private AttendBusinessDayReportManager attendBusinessDayReportManager;
+
+    @Transactional(rollbackFor={Exception.class})
+    public CloudwalkResult<Boolean> exec(Long date, CloudwalkCallContext context) throws ServiceException {
+        try {
+            Long time = DateUtils.todayStart((Date)new Date(date));
+            AttendBusinessDayReportResultGenQueryDTO genQueryDTO = new AttendBusinessDayReportResultGenQueryDTO();
+            genQueryDTO.setBusinessId(context.getCompany().getCompanyId());
+            genQueryDTO.setAttrTime(time);
+            AttendBusinessDayReportResultGenQueryResultDTO resultGenDTO = this.attendBusinessDayReportManager.resultGenQuery(genQueryDTO);
+            if (resultGenDTO == null) {
+                resultGenDTO = this.getResultGenDTO();
+            }
+            AttendBusinessDayReportQueryDTO queryDTO = new AttendBusinessDayReportQueryDTO();
+            queryDTO.setBusinessId(context.getCompany().getCompanyId());
+            queryDTO.setAttrDay(time);
+            List resultList = this.attendBusinessDayReportManager.query(queryDTO);
+            if (CollectionUtils.isEmpty((Collection)resultList)) {
+                AttendBusinessDayReportAddDTO addDTO = (AttendBusinessDayReportAddDTO)BeanCopyUtils.copyProperties((Object)resultGenDTO, AttendBusinessDayReportAddDTO.class);
+                addDTO.setId(this.genUUID());
+                addDTO.setBusinessId(context.getCompany().getCompanyId());
+                addDTO.setAttrDay(time);
+                addDTO.setUnSignIn(resultGenDTO.getNoSign());
+                addDTO.setCreateTime(Long.valueOf(System.currentTimeMillis()));
+                this.attendBusinessDayReportManager.add(addDTO);
+                return CloudwalkResult.success((Object)true);
+            }
+            AttendBusinessDayReportQueryResultDTO resultDTO = (AttendBusinessDayReportQueryResultDTO)resultList.get(0);
+            AttendBusinessDayReportEditDTO editDTO = (AttendBusinessDayReportEditDTO)BeanCopyUtils.copyProperties((Object)resultGenDTO, AttendBusinessDayReportEditDTO.class);
+            editDTO.setId(resultDTO.getId());
+            editDTO.setUnSignIn(resultGenDTO.getNoSign());
+            this.attendBusinessDayReportManager.edit(editDTO);
+            return CloudwalkResult.success((Object)true);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u6708\u62a5\u8868\u4efb\u52a1\u6267\u884c\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private AttendBusinessDayReportResultGenQueryResultDTO getResultGenDTO() {
+        AttendBusinessDayReportResultGenQueryResultDTO resultGenDTO = new AttendBusinessDayReportResultGenQueryResultDTO();
+        resultGenDTO.setNormal(Integer.valueOf(0));
+        resultGenDTO.setAbnormal(Integer.valueOf(0));
+        resultGenDTO.setLate(Integer.valueOf(0));
+        resultGenDTO.setLeaveEarly(Integer.valueOf(0));
+        resultGenDTO.setLateLeaveEarly(Integer.valueOf(0));
+        resultGenDTO.setNoSign(Integer.valueOf(0));
+        return resultGenDTO;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/report/AttendDayReportTaskServiceImpl.java

@@ -0,0 +1,79 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.report.service.AttendBusinessDayReportService
+ *  cn.cloudwalk.client.ninca.attendance.report.service.AttendDayReportTaskService
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultInitService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.common.ninca.attendance.config.FeignRequestUtil
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtil
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.report;
+
+import cn.cloudwalk.client.ninca.attendance.report.service.AttendBusinessDayReportService;
+import cn.cloudwalk.client.ninca.attendance.report.service.AttendDayReportTaskService;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultInitService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.common.ninca.attendance.config.FeignRequestUtil;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtil;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtils;
+import cn.cloudwalk.service.ninca.attendance.common.job.AbstractJobService;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendDayReportTaskServiceImpl
+extends AbstractJobService
+implements AttendDayReportTaskService {
+    @Resource
+    private AttendResultInitService attendResultInitService;
+    @Resource
+    private AttendBusinessDayReportService attendBusinessDayReportService;
+
+    public void execute() {
+        try {
+            long curr = System.currentTimeMillis();
+            this.logger.info("\u5f00\u59cb\u6267\u884c\u8003\u52e4\u65e5\u62a5\u8868\u751f\u6210\u5b9a\u65f6\u4efb\u52a1");
+            List businessIdList = this.attendResultInitService.queryBusinessIdList(null);
+            if (CollectionUtils.isEmpty((Collection)businessIdList)) {
+                this.logger.info("\u8003\u52e4\u65e5\u62a5\u8868\u751f\u6210\uff0c\u6ca1\u6709\u5f85\u521d\u59cb\u5316\u7684\u4f01\u4e1a");
+            }
+            this.logger.info("\u8003\u52e4\u65e5\u62a5\u8868\u751f\u6210\uff0c\u5f85\u521d\u59cb\u5316\u7684\u4f01\u4e1a\u6570\u91cf={}", (Object)businessIdList.size());
+            Date date = new Date();
+            for (String businessId : businessIdList) {
+                Map defaultRequestHeader = FeignRequestUtil.getDefaultRequestHeader((String)businessId);
+                FeignRequestUtil.setRequestHeader((Map)defaultRequestHeader);
+                CloudwalkCallContext context = super.getCloudwalkCallContext(businessId);
+                try {
+                    long curr2 = System.currentTimeMillis();
+                    this.attendBusinessDayReportService.exec(DateUtils.todayStart((Date)date), context);
+                    if (date.getTime() - DateUtils.todayStart((Date)date) <= 600000L) {
+                        Date yesterday = DateUtil.addDays((Date)date, (int)-1);
+                        this.attendBusinessDayReportService.exec(DateUtils.todayStart((Date)yesterday), context);
+                    }
+                    this.logger.info("\u6267\u884c\u4f01\u4e1a\u6708\u62a5\u8868\uff0cbusinessId={}\uff0c\u8017\u65f6={}", (Object)businessIdList, (Object)(System.currentTimeMillis() - curr2));
+                }
+                catch (Exception e) {
+                    this.logger.error("\u8003\u52e4\u65e5\u62a5\u8868\u751f\u6210\u5931\u8d25\uff0c\u539f\u56e0:", (Throwable)e);
+                }
+            }
+            this.logger.info("\u7ed3\u675f\u6267\u884c\u8003\u52e4\u65e5\u62a5\u8868\u751f\u6210\u5b9a\u65f6\u4efb\u52a1\uff0c\u603b\u8017\u65f6={}ms", (Object)(System.currentTimeMillis() - curr));
+        }
+        catch (ServiceException e) {
+            this.logger.error("\u4efb\u52a1\u8003\u52e4\u65e5\u62a5\u8868\u751f\u6210\u5931\u8d25\uff0c\u539f\u56e0", (Throwable)e);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/report/AttendMonthReportServiceImpl.java

@@ -0,0 +1,211 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.report.AttendMonthReportManager
+ *  cn.cloudwalk.biz.intelligent.ninca.report.ReportJobManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.result.PersonResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.service.PersonService
+ *  cn.cloudwalk.client.ninca.attendance.report.service.AttendMonthReportService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.entity.CloudwalkBaseIdentify
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.page.CloudwalkPageAble
+ *  cn.cloudwalk.cloud.page.CloudwalkPageInfo
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendMonthReportDeleteDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendMonthReportResultGenAddDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendMonthReportResultGenPageDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendMonthReportResultGenQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.ReportJobAddDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.ReportJobDeleteDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.ReportJobQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.ReportJobQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.JobExecResultEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.JobExecTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.JobTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ *  org.springframework.transaction.annotation.Transactional
+ */
+package cn.cloudwalk.service.ninca.attendance.report;
+
+import cn.cloudwalk.biz.intelligent.ninca.report.AttendMonthReportManager;
+import cn.cloudwalk.biz.intelligent.ninca.report.ReportJobManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.result.PersonResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.service.PersonService;
+import cn.cloudwalk.client.ninca.attendance.report.service.AttendMonthReportService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.entity.CloudwalkBaseIdentify;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.page.CloudwalkPageAble;
+import cn.cloudwalk.cloud.page.CloudwalkPageInfo;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendMonthReportDeleteDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendMonthReportResultGenAddDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendMonthReportResultGenPageDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendMonthReportResultGenQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.ReportJobAddDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.ReportJobDeleteDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.ReportJobQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.ReportJobQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.em.JobExecResultEnum;
+import cn.cloudwalk.common.ninca.attendance.em.JobExecTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.em.JobTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class AttendMonthReportServiceImpl
+extends AbstractCloudwalkService
+implements AttendMonthReportService {
+    @Resource
+    private AttendMonthReportManager attendMonthReportManager;
+    @Resource
+    private ReportJobManager reportJobManager;
+    @Resource
+    private PersonService personService;
+    private static final int PAGE_SIZE = 1000;
+
+    @Transactional(rollbackFor={Exception.class})
+    public void init(Date month, CloudwalkCallContext context) throws ServiceException {
+        CloudwalkResult<Integer> execResult = this.exec(month, context);
+        if (JobExecResultEnum.EXEC_COMPLETED.getCode().equals(execResult.getData())) {
+            month = DateUtils.getMonth((Date)month, (int)1);
+            this.init(month, context);
+        }
+    }
+
+    @Transactional(rollbackFor={Exception.class})
+    public CloudwalkResult<Integer> exec(Date month, CloudwalkCallContext context) throws ServiceException {
+        try {
+            if (DateUtils.todayStart((Date)month).equals(DateUtils.getMonthFirstDate((Date)new Date()))) {
+                return CloudwalkResult.success((Object)JobExecResultEnum.EXEC_COMPLETED.getCode());
+            }
+            Boolean isCurrMonth = DateUtils.getMonthFirstDate((Date)new Date()) == DateUtils.getMonthFirstDate((Date)month);
+            String monthStr = DateUtils.formatDate((Date)month, (String)"yyyyMM");
+            ReportJobQueryDTO jobQueryDTO = new ReportJobQueryDTO();
+            jobQueryDTO.setBusinessId(context.getCompany().getCompanyId());
+            jobQueryDTO.setValue(monthStr);
+            jobQueryDTO.setJobType(JobTypeEnum.ATTEND_MONTH_REPORT.getCode());
+            List jobQueryResultList = this.reportJobManager.query(jobQueryDTO);
+            if (CollectionUtils.isEmpty((Collection)jobQueryResultList)) {
+                int res = this.insert(1, month, monthStr, isCurrMonth, context);
+                if (res > 0) {
+                    this.initJob(res, monthStr, isCurrMonth, context);
+                    return CloudwalkResult.success((Object)JobExecResultEnum.EXEC_COMPLETED.getCode());
+                }
+                Integer result = isCurrMonth != false ? JobExecResultEnum.EXEC_COMPLETED.getCode() : JobExecResultEnum.NOT_EXEC.getCode();
+                return CloudwalkResult.success((Object)result);
+            }
+            if (JobExecTypeEnum.ONGOING.getCode().equals(((ReportJobQueryResultDTO)jobQueryResultList.get(0)).getExecType())) {
+                AttendMonthReportDeleteDTO reportDeleteDTO = new AttendMonthReportDeleteDTO();
+                reportDeleteDTO.setBusinessId(context.getCompany().getCompanyId());
+                reportDeleteDTO.setMonth(monthStr);
+                this.attendMonthReportManager.delete(reportDeleteDTO);
+                ReportJobQueryResultDTO reportJobQueryResultDTO = (ReportJobQueryResultDTO)jobQueryResultList.get(0);
+                ReportJobDeleteDTO jobDeleteDTO = new ReportJobDeleteDTO();
+                jobDeleteDTO.setBusinessId(context.getCompany().getCompanyId());
+                jobDeleteDTO.setId(reportJobQueryResultDTO.getId());
+                this.reportJobManager.delete(jobDeleteDTO);
+                int res = this.insert(1, month, monthStr, isCurrMonth, context);
+                if (res > 0) {
+                    this.initJob(res, monthStr, isCurrMonth, context);
+                    return CloudwalkResult.success((Object)JobExecResultEnum.EXEC_COMPLETED.getCode());
+                }
+                return CloudwalkResult.success((Object)JobExecResultEnum.NOT_EXEC.getCode());
+            }
+            if (JobExecTypeEnum.COMPLETED.getCode().equals(((ReportJobQueryResultDTO)jobQueryResultList.get(0)).getExecType())) {
+                return CloudwalkResult.success((Object)JobExecResultEnum.NOT_EXEC.getCode());
+            }
+            return CloudwalkResult.success((Object)JobExecResultEnum.EXEC_COMPLETED.getCode());
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u8003\u52e4\u6708\u62a5\u8868\u7ed3\u679c\u751f\u6210\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private Integer insert(int currPage, Date month, String monthStr, Boolean isCurrMonth, CloudwalkCallContext context) throws DataAccessException, ServiceException {
+        long totalPage;
+        AttendMonthReportResultGenPageDTO genQueryDTO = new AttendMonthReportResultGenPageDTO();
+        genQueryDTO.setBusinessId(context.getCompany().getCompanyId());
+        if (isCurrMonth.booleanValue()) {
+            genQueryDTO.setStartDay(Long.valueOf(DateUtils.getMonthFirstDate((Date)month)));
+            genQueryDTO.setEndDay(DateUtils.todayStart());
+        } else {
+            genQueryDTO.setStartDay(Long.valueOf(DateUtils.getMonthFirstDate((Date)month)));
+            genQueryDTO.setEndDay(Long.valueOf(DateUtils.getMonthLastDate((Date)month)));
+        }
+        genQueryDTO.setMonth(monthStr);
+        CloudwalkPageInfo pageInfo = new CloudwalkPageInfo(currPage, 1000);
+        CloudwalkPageAble pageResult = this.attendMonthReportManager.resultGenPage(genQueryDTO, pageInfo);
+        int execCount = 0;
+        if (CollectionUtils.isNotEmpty((Collection)pageResult.getDatas())) {
+            ArrayList<AttendMonthReportResultGenAddDTO> insertList = new ArrayList<AttendMonthReportResultGenAddDTO>(pageResult.getDatas().size());
+            long nowTime = System.currentTimeMillis();
+            List<String> personIds = pageResult.getDatas().stream().map(AttendMonthReportResultGenQueryResultDTO::getPersonId).collect(Collectors.toList());
+            Map<String, List<PersonResult>> personTmpMap = this.getPerson(personIds, context);
+            for (AttendMonthReportResultGenQueryResultDTO resultDTO : pageResult.getDatas()) {
+                PersonResult personResult;
+                AttendMonthReportResultGenAddDTO addDTO = (AttendMonthReportResultGenAddDTO)BeanCopyUtils.copyProperties((Object)resultDTO, AttendMonthReportResultGenAddDTO.class);
+                if (personTmpMap != null && personTmpMap.get(resultDTO.getPersonId()) != null && CollectionUtils.isNotEmpty((Collection)(personResult = personTmpMap.get(resultDTO.getPersonId()).get(0)).getOrganizationIds())) {
+                    addDTO.setOrgId((String)personResult.getOrganizationIds().get(0));
+                }
+                addDTO.setCreateTime(Long.valueOf(nowTime));
+                addDTO.setLastUpdateTime(Long.valueOf(nowTime));
+                insertList.add(addDTO);
+            }
+            int res = this.attendMonthReportManager.insert(insertList);
+            execCount += res;
+        }
+        if ((totalPage = pageResult.getTotalPages()) > (long)currPage) {
+            execCount += this.insert(currPage + 1, month, monthStr, isCurrMonth, context).intValue();
+        }
+        return execCount;
+    }
+
+    private void initJob(int count, String monthStr, Boolean isCurrMonth, CloudwalkCallContext context) throws DataAccessException {
+        ReportJobAddDTO jobAddDTO = new ReportJobAddDTO();
+        jobAddDTO.setId(this.genUUID());
+        jobAddDTO.setBusinessId(context.getCompany().getCompanyId());
+        jobAddDTO.setValue(monthStr);
+        jobAddDTO.setTargetCount(null);
+        jobAddDTO.setCompleteCount(Integer.valueOf(count));
+        Integer execType = isCurrMonth != false ? JobExecTypeEnum.ONGOING.getCode() : JobExecTypeEnum.COMPLETED.getCode();
+        jobAddDTO.setExecType(execType);
+        jobAddDTO.setJobType(JobTypeEnum.ATTEND_MONTH_REPORT.getCode());
+        jobAddDTO.setCreateTime(Long.valueOf(System.currentTimeMillis()));
+        jobAddDTO.setLastUpdateTime(Long.valueOf(System.currentTimeMillis()));
+        this.reportJobManager.add(jobAddDTO);
+    }
+
+    private Map<String, List<PersonResult>> getPerson(List<String> personIds, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        PersonQueryParam personQueryParam = new PersonQueryParam();
+        personQueryParam.setIds(personIds);
+        CloudwalkResult personListResult = this.personService.list(personQueryParam, cloudwalkContext);
+        if (personListResult.isSuccess() && CollectionUtils.isNotEmpty((Collection)((Collection)personListResult.getData()))) {
+            return ((List)personListResult.getData()).stream().collect(Collectors.groupingBy(CloudwalkBaseIdentify::getId));
+        }
+        return null;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/report/AttendMonthReportTaskServiceImpl.java

@@ -0,0 +1,69 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.report.service.AttendMonthReportService
+ *  cn.cloudwalk.client.ninca.attendance.report.service.AttendMonthReportTaskService
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultInitService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.common.ninca.attendance.config.FeignRequestUtil
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.report;
+
+import cn.cloudwalk.client.ninca.attendance.report.service.AttendMonthReportService;
+import cn.cloudwalk.client.ninca.attendance.report.service.AttendMonthReportTaskService;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultInitService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.common.ninca.attendance.config.FeignRequestUtil;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.attendance.common.job.AbstractJobService;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendMonthReportTaskServiceImpl
+extends AbstractJobService
+implements AttendMonthReportTaskService {
+    @Resource
+    private AttendResultInitService attendResultInitService;
+    @Resource
+    private AttendMonthReportService attendMonthReportService;
+
+    public void execute() {
+        try {
+            long curr = System.currentTimeMillis();
+            this.logger.info("\u5f00\u59cb\u6267\u884c\u8003\u52e4\u6708\u62a5\u8868\u751f\u6210\u5b9a\u65f6\u4efb\u52a1");
+            List businessIdList = this.attendResultInitService.queryBusinessIdList(null);
+            if (CollectionUtils.isEmpty((Collection)businessIdList)) {
+                this.logger.info("\u8003\u52e4\u6708\u62a5\u8868\u751f\u6210\uff0c\u6ca1\u6709\u5f85\u521d\u59cb\u5316\u7684\u4f01\u4e1a");
+            }
+            this.logger.info("\u8003\u52e4\u6708\u62a5\u8868\u751f\u6210\uff0c\u5f85\u521d\u59cb\u5316\u7684\u4f01\u4e1a\u6570\u91cf={}", (Object)businessIdList.size());
+            for (String businessId : businessIdList) {
+                Date month = new Date();
+                Map defaultRequestHeader = FeignRequestUtil.getDefaultRequestHeader((String)businessId);
+                FeignRequestUtil.setRequestHeader((Map)defaultRequestHeader);
+                CloudwalkCallContext context = super.getCloudwalkCallContext(businessId);
+                try {
+                    this.attendMonthReportService.init(month, context);
+                }
+                catch (Exception e) {
+                    this.logger.error("\u8003\u52e4\u6708\u62a5\u8868\u751f\u6210\u5931\u8d25\uff0c\u539f\u56e0:", (Throwable)e);
+                }
+            }
+            this.logger.info("\u7ed3\u675f\u6267\u884c\u8003\u52e4\u6708\u62a5\u8868\u751f\u6210\u5b9a\u65f6\u4efb\u52a1\uff0c\u603b\u8017\u65f6={}ms", (Object)(System.currentTimeMillis() - curr));
+        }
+        catch (ServiceException e) {
+            this.logger.error("\u4efb\u52a1\u8003\u52e4\u6708\u62a5\u8868\u751f\u6210\u5931\u8d25\uff0c\u539f\u56e0", (Throwable)e);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/report/AttendReportConvertServiceImpl.java

@@ -0,0 +1,305 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendClassManager
+ *  cn.cloudwalk.biz.intelligent.ninca.result.AttendRecordManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.organization.param.OrganizationListParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.organization.result.OrganizationResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.organization.service.OrganizationService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.result.PersonResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.service.PersonService
+ *  cn.cloudwalk.client.ninca.attendance.report.result.AttendReportDetailResult
+ *  cn.cloudwalk.client.ninca.attendance.report.result.AttendReportStatisticalResult
+ *  cn.cloudwalk.client.ninca.attendance.report.service.AttendReportConvertService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.entity.CloudwalkBaseIdentify
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassGetsDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendReportDetailResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendReportStatisticalResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendRecordQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendRecordQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleGetsDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendReportResultStatusEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.report;
+
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendClassManager;
+import cn.cloudwalk.biz.intelligent.ninca.result.AttendRecordManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.organization.param.OrganizationListParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.organization.result.OrganizationResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.organization.service.OrganizationService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.result.PersonResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.service.PersonService;
+import cn.cloudwalk.client.ninca.attendance.report.result.AttendReportDetailResult;
+import cn.cloudwalk.client.ninca.attendance.report.result.AttendReportStatisticalResult;
+import cn.cloudwalk.client.ninca.attendance.report.service.AttendReportConvertService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.entity.CloudwalkBaseIdentify;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassGetsDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendReportDetailResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendReportStatisticalResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendRecordQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendRecordQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleGetsDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendReportResultStatusEnum;
+import cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum;
+import cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtils;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendReportConvertServiceImpl
+implements AttendReportConvertService {
+    @Resource
+    private AttendRecordManager attendRecordManager;
+    @Resource
+    private PersonService personService;
+    @Resource
+    private AttendRuleManager attendRuleManager;
+    @Resource
+    private AttendClassManager attendClassManager;
+    @Resource
+    private OrganizationService organizationService;
+
+    public List<AttendReportDetailResult> convertDetailResult(List<AttendReportDetailResultDTO> resultList, CloudwalkCallContext cloudwalkContext) throws DataAccessException, ServiceException {
+        ArrayList<AttendReportDetailResult> attendReportDetailResultList = new ArrayList<AttendReportDetailResult>(20);
+        if (CollectionUtils.isNotEmpty(resultList)) {
+            List<String> startRecordIds = resultList.stream().filter(item -> item.getStartRecordId() != null).map(AttendReportDetailResultDTO::getStartRecordId).collect(Collectors.toList());
+            Map<String, List<AttendRecordQueryResultDTO>> startRecordMap = this.getRecord(startRecordIds, cloudwalkContext);
+            List<String> endRecordIds = resultList.stream().filter(item -> item.getEndRecordId() != null).map(AttendReportDetailResultDTO::getEndRecordId).collect(Collectors.toList());
+            Map<String, List<AttendRecordQueryResultDTO>> endRecordMap = this.getRecord(endRecordIds, cloudwalkContext);
+            List<String> personIds = resultList.stream().map(AttendReportDetailResultDTO::getPersonId).collect(Collectors.toList());
+            Map<String, List<PersonResult>> personTmpMap = this.getPerson(personIds, cloudwalkContext);
+            List<String> orgIds = resultList.stream().map(AttendReportDetailResultDTO::getOrgId).collect(Collectors.toList());
+            Map<String, List<OrganizationResult>> orgTmpMap = this.getOrgMap(orgIds, cloudwalkContext);
+            for (AttendReportDetailResultDTO dto : resultList) {
+                AttendReportDetailResult detailResult = (AttendReportDetailResult)BeanCopyUtils.copyProperties((Object)dto, AttendReportDetailResult.class);
+                if (personTmpMap != null && personTmpMap.get(detailResult.getPersonId()) != null) {
+                    PersonResult personResult = personTmpMap.get(detailResult.getPersonId()).get(0);
+                    detailResult.setTelephone(personResult.getPhone());
+                    detailResult.setPersonName(personResult.getName());
+                    detailResult.setLabelNames(personResult.getLabelNames());
+                }
+                if (orgTmpMap != null && orgTmpMap.get(dto.getOrgId()) != null) {
+                    detailResult.setOrgName(orgTmpMap.get(dto.getOrgId()).get(0).getName());
+                }
+                this.setDetailStatus(detailResult, dto);
+                this.setWorHours(detailResult, dto);
+                this.setReasonDesc(detailResult, dto);
+                this.setSignCount(detailResult, dto);
+                this.setOverTime(detailResult, dto);
+                this.setDeviceMsg(detailResult, dto, startRecordMap, endRecordMap);
+                attendReportDetailResultList.add(detailResult);
+            }
+        }
+        return attendReportDetailResultList;
+    }
+
+    private Map<String, List<OrganizationResult>> getOrgMap(List<String> orgIds, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        OrganizationListParam listParam = new OrganizationListParam();
+        listParam.setIds(orgIds);
+        listParam.setByLoginUser(Boolean.FALSE);
+        CloudwalkResult orgQueryResult = this.organizationService.list(listParam, cloudwalkContext);
+        if (!orgQueryResult.isSuccess() || CollectionUtils.isEmpty((Collection)((Collection)orgQueryResult.getData()))) {
+            return null;
+        }
+        return ((List)orgQueryResult.getData()).stream().collect(Collectors.groupingBy(OrganizationResult::getId));
+    }
+
+    public List<AttendReportStatisticalResult> convertStatistical(List<AttendReportStatisticalResultDTO> result, CloudwalkCallContext context) throws ServiceException, DataAccessException {
+        ArrayList<AttendReportStatisticalResult> resultList = new ArrayList<AttendReportStatisticalResult>(20);
+        if (CollectionUtils.isNotEmpty(result)) {
+            List<String> personIds = result.stream().map(AttendReportStatisticalResultDTO::getPersonId).collect(Collectors.toList());
+            Map<String, List<PersonResult>> personTmpMap = this.getPerson(personIds, context);
+            List<String> orgIds = result.stream().map(AttendReportStatisticalResultDTO::getOrgId).collect(Collectors.toList());
+            Map<String, List<OrganizationResult>> orgTmpMap = this.getOrgMap(orgIds, context);
+            List ruleIds = result.stream().filter(item -> item.getRuleType().equals(AttendTypeEnum.STANDARD.getCode()) || item.getRuleType().equals(AttendTypeEnum.FLEXIBLE.getCode())).map(AttendReportStatisticalResultDTO::getRuleId).collect(Collectors.toList());
+            Map<String, List<AttendRuleQueryResultDTO>> tmpRuleMap = null;
+            if (CollectionUtils.isNotEmpty(ruleIds)) {
+                AttendRuleGetsDTO ruleGetsDTO = new AttendRuleGetsDTO();
+                ruleGetsDTO.setBusinessId(context.getCompany().getCompanyId());
+                ruleGetsDTO.setRuleIds(ruleIds);
+                List ruleList = this.attendRuleManager.gets(ruleGetsDTO);
+                if (CollectionUtils.isNotEmpty((Collection)ruleList)) {
+                    tmpRuleMap = ruleList.stream().collect(Collectors.groupingBy(AttendRuleQueryResultDTO::getId));
+                }
+            }
+            Map<String, List<AttendClassQueryResultDTO>> tmpClassMap = null;
+            List classIds = result.stream().filter(item -> item.getRuleType().equals(AttendTypeEnum.SCHEDULING.getCode())).map(AttendReportStatisticalResultDTO::getRuleId).collect(Collectors.toList());
+            if (CollectionUtils.isNotEmpty(classIds)) {
+                AttendClassGetsDTO classGetsDTO = new AttendClassGetsDTO();
+                classGetsDTO.setBusinessId(context.getCompany().getCompanyId());
+                classGetsDTO.setIds(classIds);
+                List getsResultList = this.attendClassManager.gets(classGetsDTO);
+                if (CollectionUtils.isNotEmpty((Collection)getsResultList)) {
+                    tmpClassMap = getsResultList.stream().collect(Collectors.groupingBy(AttendClassQueryResultDTO::getId));
+                }
+            }
+            for (AttendReportStatisticalResultDTO dto : result) {
+                AttendReportStatisticalResult attendReportStatisticalResult = (AttendReportStatisticalResult)BeanCopyUtils.copyProperties((Object)dto, AttendReportStatisticalResult.class);
+                if (personTmpMap != null && personTmpMap.get(attendReportStatisticalResult.getPersonId()) != null) {
+                    PersonResult personResult = personTmpMap.get(attendReportStatisticalResult.getPersonId()).get(0);
+                    attendReportStatisticalResult.setTelephone(personResult.getPhone());
+                    attendReportStatisticalResult.setPersonName(personResult.getName());
+                    attendReportStatisticalResult.setLabelNames(personResult.getLabelNames());
+                }
+                if (orgTmpMap != null && orgTmpMap.get(dto.getOrgId()) != null) {
+                    attendReportStatisticalResult.setOrgName(orgTmpMap.get(dto.getOrgId()).get(0).getName());
+                }
+                if (AttendTypeEnum.FLEXIBLE.getCode().equals(dto.getRuleType())) {
+                    attendReportStatisticalResult.setLeaveEarlyTime(dto.getfLeaveEarlyTime());
+                    attendReportStatisticalResult.setAbsenteeism(dto.getfAbsenteeism());
+                }
+                if (AttendTypeEnum.SCHEDULING.getCode().equals(dto.getRuleType())) {
+                    if (tmpClassMap != null && CollectionUtils.isNotEmpty((Collection)tmpClassMap.get(dto.getRuleId()))) {
+                        attendReportStatisticalResult.setRuleName(tmpClassMap.get(dto.getRuleId()).get(0).getName());
+                    }
+                } else if (tmpRuleMap != null && CollectionUtils.isNotEmpty((Collection)tmpRuleMap.get(dto.getRuleId()))) {
+                    attendReportStatisticalResult.setRuleName(tmpRuleMap.get(dto.getRuleId()).get(0).getName());
+                }
+                attendReportStatisticalResult.setMonth(DateUtils.dateToStampFormat((String)dto.getAttendMonth(), (String)"yyyyMM"));
+                resultList.add(attendReportStatisticalResult);
+            }
+        }
+        return resultList;
+    }
+
+    private void setDeviceMsg(AttendReportDetailResult detailResult, AttendReportDetailResultDTO dto, Map<String, List<AttendRecordQueryResultDTO>> startRecordMap, Map<String, List<AttendRecordQueryResultDTO>> endRecordMap) {
+        List<AttendRecordQueryResultDTO> attendRecordList = null;
+        if (startRecordMap != null && CollectionUtils.isNotEmpty(attendRecordList = startRecordMap.get(dto.getStartRecordId()))) {
+            detailResult.setStartDeviceName(attendRecordList.get(0).getDeviceName());
+            detailResult.setStartDeviceAddress(attendRecordList.get(0).getDeviceAreaName());
+        }
+        if (endRecordMap != null && CollectionUtils.isNotEmpty(attendRecordList = endRecordMap.get(dto.getEndRecordId()))) {
+            detailResult.setEndDeviceName(attendRecordList.get(0).getDeviceName());
+            detailResult.setEndDeviceAddress(attendRecordList.get(0).getDeviceAreaName());
+        }
+    }
+
+    private void setOverTime(AttendReportDetailResult detailResult, AttendReportDetailResultDTO dto) {
+        if (dto.getOverTime() != null && dto.getOverTime() > 0) {
+            detailResult.setIsOverTime(YesNoTypeEnum.Y.getCode());
+            detailResult.setOverTime(DateUtils.formatTimeDurationHour((long)((long)dto.getOverTime().intValue() * 60000L), (int)2));
+        } else {
+            detailResult.setIsOverTime(YesNoTypeEnum.N.getCode());
+            detailResult.setOverTime("0");
+        }
+    }
+
+    private void setSignCount(AttendReportDetailResult detailResult, AttendReportDetailResultDTO dto) {
+        if (AttendResultStatusEnum.UN_SIGN_IN.getCode().equals(dto.getStartWorkState()) && AttendResultStatusEnum.UN_SIGN_IN.getCode().equals(dto.getEndWorkState())) {
+            detailResult.setSignCount(Integer.valueOf(0));
+        } else if (AttendResultStatusEnum.UN_SIGN_IN.getCode().equals(dto.getStartWorkState()) || AttendResultStatusEnum.UN_SIGN_IN.getCode().equals(dto.getEndWorkState())) {
+            detailResult.setSignCount(Integer.valueOf(1));
+        } else {
+            detailResult.setSignCount(Integer.valueOf(2));
+        }
+    }
+
+    private void setReasonDesc(AttendReportDetailResult detailResult, AttendReportDetailResultDTO dto) {
+        StringBuilder startReasonDesc = new StringBuilder();
+        if (!AttendResultStatusEnum.NORMAL.getCode().equals(detailResult.getStartWorkState())) {
+            if (AttendResultStatusEnum.UN_SIGN_IN.getCode().equals(detailResult.getStartWorkState())) {
+                startReasonDesc.append("\u7f3a\u5361");
+            } else if (detailResult.getStartWorkTime() != null && detailResult.getRuleStartWorkTime() != null) {
+                String str = DateUtils.formatTimeDurationHour((long)(detailResult.getStartWorkTime() - detailResult.getRuleStartWorkTime()), (int)3);
+                startReasonDesc.append(AttendResultStatusEnum.getMessageByCode((Integer)detailResult.getStartWorkState())).append(str);
+            }
+        }
+        StringBuilder endReasonDesc = new StringBuilder();
+        if (!AttendResultStatusEnum.NORMAL.getCode().equals(detailResult.getEndWorkState())) {
+            if (AttendResultStatusEnum.UN_SIGN_IN.getCode().equals(detailResult.getEndWorkState())) {
+                endReasonDesc.append("\u7f3a\u5361");
+            } else if (AttendTypeEnum.STANDARD.getCode().equals(detailResult.getRuleType()) || AttendTypeEnum.SCHEDULING.getCode().equals(detailResult.getRuleType())) {
+                if (detailResult.getRuleEndWorkTime() != null && detailResult.getEndWorkTime() != null) {
+                    String str = DateUtils.formatTimeDurationHour((long)(detailResult.getRuleEndWorkTime() - detailResult.getEndWorkTime()), (int)3);
+                    endReasonDesc.append(AttendResultStatusEnum.getMessageByCode((Integer)detailResult.getEndWorkState())).append(str);
+                }
+            } else if (AttendTypeEnum.FLEXIBLE.getCode().equals(detailResult.getRuleType()) && detailResult.getStartWorkTime() != null && dto.getStandardTime() != null) {
+                String str = DateUtils.formatTimeDurationHour((long)(detailResult.getStartWorkTime() + (long)(dto.getStandardTime() * 60 * 1000) - detailResult.getEndWorkTime()), (int)3);
+                endReasonDesc.append(AttendResultStatusEnum.getMessageByCode((Integer)detailResult.getEndWorkState())).append(str);
+            }
+        }
+        if (startReasonDesc.length() + endReasonDesc.length() > 0) {
+            detailResult.setReasonDesc(startReasonDesc.append("\uff0c").append((CharSequence)endReasonDesc).toString());
+        }
+    }
+
+    private void setWorHours(AttendReportDetailResult detailResult, AttendReportDetailResultDTO dto) {
+        if (dto.getStartWorkTime() != null && dto.getEndWorkTime() != null && dto.getEndWorkTime() - dto.getStartWorkTime() > 0L) {
+            detailResult.setWorkHours(DateUtils.formatTimeDurationHour((long)(dto.getEndWorkTime() - dto.getStartWorkTime()), (int)3));
+        } else {
+            detailResult.setWorkHours("0");
+        }
+    }
+
+    private void setDetailStatus(AttendReportDetailResult detailResult, AttendReportDetailResultDTO dto) {
+        if (AttendResultStatusEnum.NORMAL.getCode().equals(dto.getStartWorkState()) && AttendResultStatusEnum.NORMAL.getCode().equals(dto.getEndWorkState())) {
+            detailResult.setInitStatus(AttendReportResultStatusEnum.NORMAL.getCode());
+            detailResult.setEndStatus(AttendReportResultStatusEnum.NORMAL.getCode());
+        } else if (AttendResultStatusEnum.UN_SIGN_IN.getCode().equals(dto.getStartWorkState()) || AttendResultStatusEnum.UN_SIGN_IN.getCode().equals(dto.getEndWorkState())) {
+            detailResult.setInitStatus(AttendReportResultStatusEnum.UN_SIGN_IN.getCode());
+            detailResult.setEndStatus(AttendReportResultStatusEnum.UN_SIGN_IN.getCode());
+        } else {
+            detailResult.setInitStatus(AttendReportResultStatusEnum.TIME_EXCEPTION.getCode());
+            detailResult.setEndStatus(AttendReportResultStatusEnum.TIME_EXCEPTION.getCode());
+        }
+        if (dto.getReason() != null) {
+            detailResult.setEndStatus(AttendReportResultStatusEnum.NORMAL.getCode());
+        }
+    }
+
+    private Map<String, List<PersonResult>> getPerson(List<String> personIds, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        PersonQueryParam personQueryParam = new PersonQueryParam();
+        personQueryParam.setIds(personIds);
+        CloudwalkResult personListResult = this.personService.list(personQueryParam, cloudwalkContext);
+        if (personListResult.isSuccess() && CollectionUtils.isNotEmpty((Collection)((Collection)personListResult.getData()))) {
+            return ((List)personListResult.getData()).stream().collect(Collectors.groupingBy(CloudwalkBaseIdentify::getId));
+        }
+        return null;
+    }
+
+    private Map<String, List<AttendRecordQueryResultDTO>> getRecord(List<String> endRecordIds, CloudwalkCallContext cloudwalkContext) throws DataAccessException {
+        if (CollectionUtils.isNotEmpty(endRecordIds)) {
+            AttendRecordQueryDTO queryDTO = new AttendRecordQueryDTO();
+            queryDTO.setIds(endRecordIds);
+            queryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            List recordQueryResultList = this.attendRecordManager.query(queryDTO);
+            return recordQueryResultList.stream().collect(Collectors.groupingBy(AttendRecordQueryResultDTO::getId));
+        }
+        return null;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/report/AttendReportQueryServiceImpl.java

@@ -0,0 +1,75 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.report.AttendBusinessDayReportManager
+ *  cn.cloudwalk.client.ninca.attendance.report.param.AttendDayReportQueryParam
+ *  cn.cloudwalk.client.ninca.attendance.report.result.AttendDayReportQueryResult
+ *  cn.cloudwalk.client.ninca.attendance.report.service.AttendReportQueryService
+ *  cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendBusinessDayReportQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendBusinessDayReportQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.report;
+
+import cn.cloudwalk.biz.intelligent.ninca.report.AttendBusinessDayReportManager;
+import cn.cloudwalk.client.ninca.attendance.report.param.AttendDayReportQueryParam;
+import cn.cloudwalk.client.ninca.attendance.report.result.AttendDayReportQueryResult;
+import cn.cloudwalk.client.ninca.attendance.report.service.AttendReportQueryService;
+import cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendBusinessDayReportQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendBusinessDayReportQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.Collection;
+import java.util.List;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+@Service(value="attendReportQueryService")
+public class AttendReportQueryServiceImpl
+extends AbstractCloudwalkService
+implements AttendReportQueryService {
+    @Resource
+    private AttendBusinessDayReportManager attendBusinessDayReportManager;
+
+    @CloudwalkParamsValidate
+    public CloudwalkResult<AttendDayReportQueryResult> queryDay(AttendDayReportQueryParam param, CloudwalkCallContext context) throws ServiceException {
+        try {
+            AttendBusinessDayReportQueryDTO queryDTO = (AttendBusinessDayReportQueryDTO)BeanCopyUtils.copyProperties((Object)param, AttendBusinessDayReportQueryDTO.class);
+            List resultList = this.attendBusinessDayReportManager.query(queryDTO);
+            int normalNum = 0;
+            int lateNum = 0;
+            int earlyNum = 0;
+            if (CollectionUtils.isNotEmpty((Collection)resultList)) {
+                for (AttendBusinessDayReportQueryResultDTO dto : resultList) {
+                    normalNum += dto.getNormal() == null ? 0 : dto.getNormal();
+                    lateNum += dto.getLate() == null ? 0 : dto.getLate();
+                    earlyNum += dto.getLeaveEarly() == null ? 0 : dto.getLeaveEarly();
+                }
+            }
+            AttendDayReportQueryResult result = new AttendDayReportQueryResult();
+            result.setNormalNum(Integer.valueOf(normalNum));
+            result.setLateNum(Integer.valueOf(lateNum));
+            result.setEarlyNum(Integer.valueOf(earlyNum));
+            result.setTotalNum(Integer.valueOf(normalNum + lateNum + earlyNum));
+            return CloudwalkResult.success((Object)result);
+        }
+        catch (Exception e) {
+            this.logger.error("\u65e5\u8868\u62a5\u67e5\u8be2\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/report/AttendReportServiceImpl.java

@@ -0,0 +1,330 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.report.AttendMonthReportManager
+ *  cn.cloudwalk.biz.intelligent.ninca.report.AttendReportManager
+ *  cn.cloudwalk.biz.intelligent.ninca.result.AttendResultManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.organization.param.OrganizationListParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.organization.result.OrganizationResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.organization.service.OrganizationService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.service.PersonService
+ *  cn.cloudwalk.client.ninca.attendance.report.param.AttendReportCorrectionParam
+ *  cn.cloudwalk.client.ninca.attendance.report.param.AttendReportDetailParam
+ *  cn.cloudwalk.client.ninca.attendance.report.param.AttendReportRecordParam
+ *  cn.cloudwalk.client.ninca.attendance.report.param.AttendReportStatisticalParam
+ *  cn.cloudwalk.client.ninca.attendance.report.result.AttendReportDetailResult
+ *  cn.cloudwalk.client.ninca.attendance.report.result.AttendReportRecordResult
+ *  cn.cloudwalk.client.ninca.attendance.report.result.AttendReportStatisticalResult
+ *  cn.cloudwalk.client.ninca.attendance.report.service.AttendBusinessDayReportService
+ *  cn.cloudwalk.client.ninca.attendance.report.service.AttendReportConvertService
+ *  cn.cloudwalk.client.ninca.attendance.report.service.AttendReportService
+ *  cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.entity.CloudwalkBaseIdentify
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.page.CloudwalkPageAble
+ *  cn.cloudwalk.cloud.page.CloudwalkPageInfo
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendMonthReportEditDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendMonthReportQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendMonthReportQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendMonthReportResultGenPageDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendMonthReportResultGenQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendReportCorrectionDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendReportDetailQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendReportRecordQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendReportRecordResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.report.AttendReportStatisticalQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendResultReasonEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.StringUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ *  org.springframework.transaction.annotation.Transactional
+ */
+package cn.cloudwalk.service.ninca.attendance.report;
+
+import cn.cloudwalk.biz.intelligent.ninca.report.AttendMonthReportManager;
+import cn.cloudwalk.biz.intelligent.ninca.report.AttendReportManager;
+import cn.cloudwalk.biz.intelligent.ninca.result.AttendResultManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.organization.param.OrganizationListParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.organization.result.OrganizationResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.organization.service.OrganizationService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.service.PersonService;
+import cn.cloudwalk.client.ninca.attendance.report.param.AttendReportCorrectionParam;
+import cn.cloudwalk.client.ninca.attendance.report.param.AttendReportDetailParam;
+import cn.cloudwalk.client.ninca.attendance.report.param.AttendReportRecordParam;
+import cn.cloudwalk.client.ninca.attendance.report.param.AttendReportStatisticalParam;
+import cn.cloudwalk.client.ninca.attendance.report.result.AttendReportDetailResult;
+import cn.cloudwalk.client.ninca.attendance.report.result.AttendReportRecordResult;
+import cn.cloudwalk.client.ninca.attendance.report.result.AttendReportStatisticalResult;
+import cn.cloudwalk.client.ninca.attendance.report.service.AttendBusinessDayReportService;
+import cn.cloudwalk.client.ninca.attendance.report.service.AttendReportConvertService;
+import cn.cloudwalk.client.ninca.attendance.report.service.AttendReportService;
+import cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.entity.CloudwalkBaseIdentify;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.page.CloudwalkPageAble;
+import cn.cloudwalk.cloud.page.CloudwalkPageInfo;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendMonthReportEditDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendMonthReportQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendMonthReportQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendMonthReportResultGenPageDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendMonthReportResultGenQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendReportCorrectionDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendReportDetailQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendReportRecordQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendReportRecordResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.report.AttendReportStatisticalQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendResultReasonEnum;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtils;
+import cn.cloudwalk.common.ninca.attendance.util.StringUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class AttendReportServiceImpl
+extends AbstractCloudwalkService
+implements AttendReportService {
+    @Resource
+    private AttendReportManager attendReportManager;
+    @Resource
+    private AttendMonthReportManager attendMonthReportManager;
+    @Resource
+    private AttendResultManager attendResultManager;
+    @Resource
+    private AttendReportConvertService attendReportConvertService;
+    @Resource
+    private PersonService personService;
+    @Resource
+    private OrganizationService organizationService;
+    @Resource
+    private AttendBusinessDayReportService attendBusinessDayReportService;
+
+    @CloudwalkParamsValidate(argsIndexs={0, 1})
+    public CloudwalkResult<CloudwalkPageAble<AttendReportDetailResult>> detail(AttendReportDetailParam param, CloudwalkPageInfo pageInfo, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        AttendReportDetailQueryDTO queryDTO = (AttendReportDetailQueryDTO)BeanCopyUtils.copyProperties((Object)param, AttendReportDetailQueryDTO.class);
+        queryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+        try {
+            CloudwalkPageAble pageResult;
+            if (CollectionUtils.isNotEmpty((Collection)param.getRoleIds()) && !param.getRoleIds().contains("smart-attendanceBusinessAdmin")) {
+                List<String> orgIds = this.getMergeOrgIds(param.getOrgIds(), cloudwalkContext);
+                if (CollectionUtils.isEmpty(orgIds)) {
+                    return CloudwalkResult.success((Object)new CloudwalkPageAble(new ArrayList(), pageInfo, 0L));
+                }
+                queryDTO.setOrgIds(orgIds);
+            }
+            if (CollectionUtils.isNotEmpty((Collection)param.getLabelIds())) {
+                List<String> personIds = this.getMergePersonIds(param.getPersonIds(), param.getLabelIds(), cloudwalkContext);
+                if (CollectionUtils.isEmpty(personIds)) {
+                    return CloudwalkResult.success((Object)new CloudwalkPageAble(new ArrayList(), pageInfo, 0L));
+                }
+                queryDTO.setPersonIds(personIds);
+            }
+            if (CollectionUtils.isEmpty((Collection)(pageResult = this.attendReportManager.detail(queryDTO, pageInfo)).getDatas())) {
+                return CloudwalkResult.success((Object)new CloudwalkPageAble(new ArrayList(), pageInfo, 0L));
+            }
+            List list = this.attendReportConvertService.convertDetailResult((List)pageResult.getDatas(), cloudwalkContext);
+            return CloudwalkResult.success((Object)new CloudwalkPageAble((Collection)list, pageInfo, pageResult.getTotalRows()));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u8003\u52e4\u62a5\u8868\u8be6\u60c5\u67e5\u8be2\u5931\u8d25,\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private List<String> getMergeOrgIds(List<String> orgIds, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        OrganizationListParam listParam = new OrganizationListParam();
+        listParam.setByLoginUser(Boolean.TRUE);
+        CloudwalkResult orgQueryResult = this.organizationService.list(listParam, cloudwalkContext);
+        if (!orgQueryResult.isSuccess() || CollectionUtils.isEmpty((Collection)((Collection)orgQueryResult.getData()))) {
+            return null;
+        }
+        List<String> cwosOrgList = ((List)orgQueryResult.getData()).stream().map(OrganizationResult::getId).collect(Collectors.toList());
+        List<String> mergeList = null;
+        mergeList = CollectionUtils.isNotEmpty(orgIds) ? orgIds.stream().filter(cwosOrgList::contains).collect(Collectors.toList()) : cwosOrgList;
+        return mergeList;
+    }
+
+    @CloudwalkParamsValidate(argsIndexs={0, 1})
+    public CloudwalkResult<CloudwalkPageAble<AttendReportStatisticalResult>> statistical(AttendReportStatisticalParam param, CloudwalkPageInfo pageInfo, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        AttendReportStatisticalQueryDTO queryDTO = (AttendReportStatisticalQueryDTO)BeanCopyUtils.copyProperties((Object)param, AttendReportStatisticalQueryDTO.class);
+        queryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+        queryDTO.setMonth(DateUtils.formatDate((Date)new Date(param.getStartDay()), (String)"yyyyMM"));
+        try {
+            CloudwalkPageAble pageResult;
+            if (CollectionUtils.isNotEmpty((Collection)param.getRoleIds()) && !param.getRoleIds().contains("smart-attendanceBusinessAdmin")) {
+                List<String> orgIds = this.getMergeOrgIds(param.getOrgIds(), cloudwalkContext);
+                if (CollectionUtils.isEmpty(orgIds)) {
+                    return CloudwalkResult.success((Object)new CloudwalkPageAble(new ArrayList(), pageInfo, 0L));
+                }
+                queryDTO.setOrgIds(orgIds);
+            }
+            if (CollectionUtils.isNotEmpty((Collection)param.getLabelIds())) {
+                List<String> personIds = this.getMergePersonIds(param.getPersonIds(), param.getLabelIds(), cloudwalkContext);
+                if (CollectionUtils.isEmpty(personIds)) {
+                    return CloudwalkResult.success((Object)new CloudwalkPageAble(new ArrayList(), pageInfo, 0L));
+                }
+                queryDTO.setPersonIds(personIds);
+            }
+            if (CollectionUtils.isEmpty((Collection)(pageResult = this.attendMonthReportManager.page(queryDTO, pageInfo)).getDatas())) {
+                return CloudwalkResult.success((Object)new CloudwalkPageAble(new ArrayList(), pageInfo, 0L));
+            }
+            List resultList = this.attendReportConvertService.convertStatistical((List)pageResult.getDatas(), cloudwalkContext);
+            return CloudwalkResult.success((Object)new CloudwalkPageAble((Collection)resultList, pageInfo, pageResult.getTotalRows()));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u8003\u52e4\u62a5\u8868\u8003\u52e4\u8d8b\u52bf\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private List<String> getMergePersonIds(List<String> personIds, List<String> labelIds, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        PersonQueryParam personQueryParam = new PersonQueryParam();
+        personQueryParam.setIds(personIds);
+        personQueryParam.setLabelIds(labelIds);
+        CloudwalkResult personResult = this.personService.list(personQueryParam, cloudwalkContext);
+        if (personResult.isSuccess() && personResult.getData() != null) {
+            return ((List)personResult.getData()).stream().map(CloudwalkBaseIdentify::getId).collect(Collectors.toList());
+        }
+        return null;
+    }
+
+    @CloudwalkParamsValidate(argsIndexs={0, 1})
+    public CloudwalkResult<List<AttendReportRecordResult>> record(AttendReportRecordParam param, CloudwalkPageInfo pageInfo, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        AttendReportRecordQueryDTO queryDTO = (AttendReportRecordQueryDTO)BeanCopyUtils.copyProperties((Object)param, AttendReportRecordQueryDTO.class);
+        queryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+        try {
+            if (CollectionUtils.isNotEmpty((Collection)param.getRoleIds()) && !param.getRoleIds().contains("smart-attendanceBusinessAdmin")) {
+                List<String> orgIds = this.getMergeOrgIds(param.getOrgIds(), cloudwalkContext);
+                if (CollectionUtils.isEmpty(orgIds)) {
+                    return CloudwalkResult.success(new ArrayList());
+                }
+                queryDTO.setOrgIds(orgIds);
+            }
+            List resultList = this.attendReportManager.record(queryDTO);
+            ArrayList<AttendReportRecordResult> recordResultList = new ArrayList<AttendReportRecordResult>(resultList.size());
+            for (AttendReportRecordResultDTO resultDTO : resultList) {
+                AttendReportRecordResult recordResult = (AttendReportRecordResult)BeanCopyUtils.copyProperties((Object)resultDTO, AttendReportRecordResult.class);
+                if (resultDTO.getAttendDay() != null) {
+                    recordResult.setAttendDay(DateUtils.dateToStamp((String)resultDTO.getAttendDay()));
+                }
+                recordResultList.add(recordResult);
+            }
+            return CloudwalkResult.success(recordResultList);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u8003\u52e4\u8bb0\u5f55\u62a5\u8868\u6309\u6708\u67e5\u8be2\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @Transactional(rollbackFor={Exception.class})
+    public CloudwalkResult<Boolean> correction(AttendReportCorrectionParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            if (AttendResultReasonEnum.getEnumByCode((Integer)param.getReason()) == null) {
+                this.logger.error("\u8003\u52e4\u5f02\u5e38\u539f\u56e0\u4fee\u6539\uff0c\u65e0\u6cd5\u8bc6\u522b\u7684\u5f02\u5e38\u539f\u56e0\u7c7b\u578b\uff0c\u53c2\u6570={}", (Object)param);
+                return CloudwalkResult.fail((String)"76240228", (String)this.getMessage("76240228"));
+            }
+            AttendReportCorrectionDTO correctionDTO = (AttendReportCorrectionDTO)BeanCopyUtils.copyProperties((Object)param, AttendReportCorrectionDTO.class);
+            correctionDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            correctionDTO.setLastUpdateTime(Long.valueOf(System.currentTimeMillis()));
+            correctionDTO.setLastUpdateUserId(cloudwalkContext.getUser().getCaller());
+            correctionDTO.setCorrectTime(Long.valueOf(System.currentTimeMillis()));
+            Integer res = this.attendReportManager.correction(correctionDTO);
+            AttendResultQueryDTO resultQueryDTO = new AttendResultQueryDTO();
+            resultQueryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            resultQueryDTO.setId(param.getId());
+            List queryResultList = this.attendResultManager.query(resultQueryDTO);
+            if (CollectionUtils.isNotEmpty((Collection)queryResultList)) {
+                AttendResultDTO attendResultDTO = (AttendResultDTO)queryResultList.get(0);
+                this.correctMonthReport(attendResultDTO, cloudwalkContext);
+                this.correctDayReport(attendResultDTO, cloudwalkContext);
+            }
+            return CloudwalkResult.success((Object)true);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u8003\u4fee\u6b63\u52e4\u5f02\u5e38\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<List<OrganizationResult>> orgList(List<String> roleIds, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            OrganizationListParam listParam = new OrganizationListParam();
+            listParam.setByLoginUser(Boolean.FALSE);
+            if (CollectionUtils.isNotEmpty(roleIds) && !roleIds.contains("smart-attendanceBusinessAdmin")) {
+                listParam.setByLoginUser(Boolean.TRUE);
+            } else {
+                listParam.setByLoginUser(Boolean.FALSE);
+            }
+            return this.organizationService.list(listParam, cloudwalkContext);
+        }
+        catch (Exception e) {
+            this.logger.error("\u7ec4\u7ec7\u5217\u8868\u67e5\u8be2\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private void correctDayReport(AttendResultDTO attendResultDTO, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        this.attendBusinessDayReportService.exec(DateUtils.todayStart((Date)new Date(attendResultDTO.getAttrTime())), cloudwalkContext);
+    }
+
+    private void correctMonthReport(AttendResultDTO queryResultDTO, CloudwalkCallContext cloudwalkContext) throws DataAccessException {
+        AttendMonthReportQueryDTO statisticalQueryDTO = new AttendMonthReportQueryDTO();
+        statisticalQueryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+        statisticalQueryDTO.setPersonId(queryResultDTO.getPersonId());
+        statisticalQueryDTO.setMonth(DateUtils.formatDate((Date)new Date(queryResultDTO.getAttrTime()), (String)"yyyyMM"));
+        statisticalQueryDTO.setSchedulingId(queryResultDTO.getSchedulingId());
+        statisticalQueryDTO.setRuleId(queryResultDTO.getRuleId());
+        List monthReportQueryResultList = this.attendMonthReportManager.query(statisticalQueryDTO);
+        if (CollectionUtils.isNotEmpty((Collection)monthReportQueryResultList)) {
+            CloudwalkPageInfo pageInfo = new CloudwalkPageInfo(1, 999);
+            Date month = new Date(queryResultDTO.getAttrTime());
+            boolean isCurrMonth = DateUtils.getMonthFirstDate((Date)new Date()) == DateUtils.getMonthFirstDate((Date)month);
+            AttendMonthReportResultGenPageDTO genQueryDTO = new AttendMonthReportResultGenPageDTO();
+            if (isCurrMonth) {
+                genQueryDTO.setStartDay(Long.valueOf(DateUtils.getMonthFirstDate((Date)month)));
+                genQueryDTO.setEndDay(DateUtils.todayStart());
+            } else {
+                genQueryDTO.setStartDay(Long.valueOf(DateUtils.getMonthFirstDate((Date)month)));
+                genQueryDTO.setEndDay(Long.valueOf(DateUtils.getMonthLastDate((Date)month)));
+            }
+            genQueryDTO.setPersonId(queryResultDTO.getPersonId());
+            genQueryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            CloudwalkPageAble pageResult = this.attendMonthReportManager.resultGenPage(genQueryDTO, pageInfo);
+            if (CollectionUtils.isNotEmpty((Collection)pageResult.getDatas())) {
+                for (AttendMonthReportResultGenQueryResultDTO data : pageResult.getDatas()) {
+                    if (!StringUtils.equals((String)data.getRuleId(), (String)queryResultDTO.getRuleId()) || !StringUtils.equals((String)data.getSchedulingId(), (String)queryResultDTO.getSchedulingId())) continue;
+                    AttendMonthReportQueryResultDTO dto = (AttendMonthReportQueryResultDTO)monthReportQueryResultList.get(0);
+                    AttendMonthReportEditDTO editDTO = (AttendMonthReportEditDTO)BeanCopyUtils.copyProperties((Object)data, AttendMonthReportEditDTO.class);
+                    editDTO.setId(dto.getId());
+                    this.attendMonthReportManager.edit(editDTO);
+                }
+            }
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/AttendResultFlexibilityGenServiceImpl.java

@@ -0,0 +1,46 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultFlexibilityGenService
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.result;
+
+import cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultFlexibilityGenService;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import cn.cloudwalk.service.ninca.attendance.result.handle.flexibility.AttendResultFlexEndEarlyHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.flexibility.AttendResultFlexEndNormalHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.flexibility.AttendResultFlexEndOverTimeHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.flexibility.AttendResultFlexStartNormalHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.flexibility.AttendResultFlexStartOverTimeHandle;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendResultFlexibilityGenServiceImpl
+extends AbstractCloudwalkService
+implements AttendResultFlexibilityGenService {
+    public void execute(AttendResultGenCallContext callContext) throws ServiceException {
+        this.handle(callContext);
+    }
+
+    private void handle(AttendResultGenCallContext callContext) throws ServiceException {
+        AttendResultFlexStartOverTimeHandle startOverTimeHandle = new AttendResultFlexStartOverTimeHandle();
+        AttendResultFlexStartNormalHandle startNormalHandle = new AttendResultFlexStartNormalHandle();
+        AttendResultFlexEndOverTimeHandle endOverTimeHandle = new AttendResultFlexEndOverTimeHandle();
+        AttendResultFlexEndEarlyHandle endEarlyHandle = new AttendResultFlexEndEarlyHandle();
+        AttendResultFlexEndNormalHandle endNormalHandle = new AttendResultFlexEndNormalHandle();
+        startOverTimeHandle.nextHandle(startNormalHandle);
+        startNormalHandle.nextHandle(endOverTimeHandle);
+        endOverTimeHandle.nextHandle(endEarlyHandle);
+        endEarlyHandle.nextHandle(endNormalHandle);
+        startOverTimeHandle.exec((AbstractAttendResultGenCallContext)callContext);
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/AttendResultGenLogicCorrectionServiceImpl.java

@@ -0,0 +1,70 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.result.AttendResultManager
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultGenLogicCorrectionService
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.result;
+
+import cn.cloudwalk.biz.intelligent.ninca.result.AttendResultManager;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultGenLogicCorrectionService;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.List;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendResultGenLogicCorrectionServiceImpl
+extends AbstractCloudwalkService
+implements AttendResultGenLogicCorrectionService {
+    @Resource
+    private AttendResultManager attendResultManager;
+
+    public CloudwalkResult<Boolean> correction(List<AttendResultDTO> attendResultList, AttendResultGenCallContext callContext) throws DataAccessException {
+        int resultSize = 2;
+        if (CollectionUtils.isEmpty(attendResultList) || attendResultList.size() != resultSize) {
+            return CloudwalkResult.success((Object)true);
+        }
+        AttendResultDTO result1 = attendResultList.get(0);
+        AttendResultDTO result2 = attendResultList.get(1);
+        if (result2.getStartworkTime() == null) {
+            result2.setStartworkTime(result1.getEndworkTime());
+            result2.setStartRecordId(result1.getEndRecordId());
+        } else {
+            if (result2.getStartworkTime() < result1.getEndworkTime()) {
+                result2.setStartworkTime(result1.getEndworkTime());
+                result2.setStartRecordId(result1.getEndRecordId());
+                if (result2.getEndworkTime() != null && result2.getEndworkTime() <= result2.getStartworkTime()) {
+                    result2.setEndworkTime(null);
+                    result2.setEndRecordId(null);
+                }
+            } else if (result2.getStartworkTime().equals(result1.getEndworkTime())) {
+                result2.setStartworkTime(result1.getEndworkTime());
+                result2.setStartRecordId(result1.getEndRecordId());
+            } else {
+                if (result2.getEndworkTime() == null) {
+                    result2.setEndworkTime(result2.getStartworkTime());
+                    result2.setEndRecordId(result2.getStartRecordId());
+                }
+                result2.setStartworkTime(result1.getEndworkTime());
+                result2.setStartRecordId(result1.getEndRecordId());
+            }
+            this.attendResultManager.correctUpdate(result2);
+        }
+        return CloudwalkResult.success((Object)true);
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/AttendResultGenServiceImpl.java

@@ -0,0 +1,251 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.result.PersonResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.service.PersonService
+ *  cn.cloudwalk.client.ninca.attendance.report.service.AttendBusinessDayReportService
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultFlexibilityGenService
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultGenLogicCorrectionService
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultGenService
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultRoadMapService
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultRuleService
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultSchedulingGenService
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultService
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultStandardGenService
+ *  cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultPersonInfoDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.config.FeignRequestUtil
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtils
+ *  cn.cloudwalk.intelligent.lock.annotation.RequiredLock
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ *  org.springframework.transaction.annotation.Transactional
+ */
+package cn.cloudwalk.service.ninca.attendance.result;
+
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.result.PersonResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.service.PersonService;
+import cn.cloudwalk.client.ninca.attendance.report.service.AttendBusinessDayReportService;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultFlexibilityGenService;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultGenLogicCorrectionService;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultGenService;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultRoadMapService;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultRuleService;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultSchedulingGenService;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultService;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultStandardGenService;
+import cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultPersonInfoDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleResultDTO;
+import cn.cloudwalk.common.ninca.attendance.config.FeignRequestUtil;
+import cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtils;
+import cn.cloudwalk.intelligent.lock.annotation.RequiredLock;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class AttendResultGenServiceImpl
+extends AbstractCloudwalkService
+implements AttendResultGenService {
+    @Resource(name="standard")
+    private AttendResultRuleService attendResultRuleService;
+    @Resource
+    private AttendResultStandardGenService attendResultStandardGenService;
+    @Resource
+    private AttendResultFlexibilityGenService attendResultFlexibilityGenService;
+    @Resource
+    private AttendResultService attendResultService;
+    @Resource
+    private PersonService personService;
+    @Resource(name="scheduling")
+    private AttendResultRuleService attendResultRuleV2Service;
+    @Resource
+    private AttendResultSchedulingGenService attendResultSchedulingGenService;
+    @Resource
+    private AttendResultRoadMapService attendResultRoadMapService;
+    @Resource
+    private AttendResultGenLogicCorrectionService attendResultGenLogicCorrectionService;
+    @Resource
+    private AttendBusinessDayReportService attendBusinessDayReportService;
+
+    @Transactional(rollbackFor={Exception.class})
+    @CloudwalkParamsValidate
+    @RequiredLock(name="('attend').concat(#param.businessId).concat(':').concat(#param.imageId)")
+    public CloudwalkResult<Boolean> gen(AttendResultSignParam param, CloudwalkCallContext context) throws ServiceException {
+        try {
+            this.logger.info("\u5f00\u59cb\u6267\u884c\u8003\u52e4\u7ed3\u679c\uff0c\u6253\u5361\u65f6\u95f4\uff1a{}", (Object)param.getSignTime());
+            long curr = System.currentTimeMillis();
+            CloudwalkResult<Boolean> cloudwalkResult = this.genCommand(param, context);
+            this.logger.info("\u7ed3\u675f\u6267\u884c\u8003\u52e4\u7ed3\u679c\uff0c\u6253\u5361\u65f6\u95f4\uff1a{}\uff0c\u6267\u884c\u8017\u65f6\uff1a{}", (Object)param.getSignTime(), (Object)(System.currentTimeMillis() - curr));
+            return cloudwalkResult;
+        }
+        catch (Exception e) {
+            this.logger.error("\u751f\u6210\u8003\u52e4\u7ed3\u679c\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private CloudwalkResult<Boolean> genCommand(AttendResultSignParam param, CloudwalkCallContext context) throws ServiceException, DataAccessException {
+        Map defaultRequestHeader = FeignRequestUtil.getDefaultRequestHeader((String)param.getBusinessId());
+        FeignRequestUtil.setRequestHeader((Map)defaultRequestHeader);
+        AttendResultGenCallContext callContext = new AttendResultGenCallContext();
+        callContext.setSignParam(param);
+        callContext.setContext(context);
+        AttendResultPersonInfoDTO personInfoDTO = this.getPersonInfo(callContext);
+        if (personInfoDTO == null) {
+            return CloudwalkResult.fail((String)"76240250", (String)this.getMessage("76240250"));
+        }
+        callContext.setPersonInfoDTO(personInfoDTO);
+        CloudwalkResult matchResult = null;
+        boolean schedulingRoad = this.attendResultRoadMapService.getRoadMap(callContext);
+        if (schedulingRoad) {
+            matchResult = this.attendResultRuleV2Service.matchRule(callContext);
+            if (matchResult == null || this.checkMatchResult((CloudwalkResult<Boolean>)matchResult, callContext)) {
+                this.logger.info("\u6392\u73ed\u8003\u52e4\u751f\u6210\u8003\u52e4\u7ed3\u679c\u5931\u8d25\uff0c\u4eba\u5458\u6ca1\u6709\u5339\u914d\u7684\u8003\u52e4\u89c4\u5219\u6216\u65f6\u6bb5\uff0c\u4eba\u5458id={}", (Object)callContext.getPersonInfoDTO().getId());
+                return CloudwalkResult.fail((String)"76240229", (String)this.getMessage("76240229"));
+            }
+            String recordId = this.attendResultService.initRecord(callContext);
+            this.executeAndUpdateResult(callContext, param, context, recordId);
+        } else {
+            matchResult = this.attendResultRuleService.matchRule(callContext);
+            if (matchResult == null || !this.checkStandMatchResult((CloudwalkResult<Boolean>)matchResult, callContext)) {
+                this.logger.info("\u6807\u51c6\u8003\u52e4\u751f\u6210\u8003\u52e4\u7ed3\u679c\u5931\u8d25\uff0c\u4eba\u5458\u6ca1\u6709\u5339\u914d\u7684\u8003\u52e4\u89c4\u5219\u6216\u65f6\u6bb5\uff0c\u4eba\u5458id={}", (Object)callContext.getPersonInfoDTO().getId());
+                return CloudwalkResult.fail((String)"76240229", (String)this.getMessage("76240229"));
+            }
+            ArrayList<AttendResultDTO> attendResultList = new ArrayList<AttendResultDTO>();
+            String recordId = this.attendResultService.initRecord(callContext);
+            for (AttendResultRuleResultDTO ruleResultDTO : callContext.getRuleResultList()) {
+                callContext.setRuleDTO(ruleResultDTO.getRuleDTO());
+                callContext.setResultDTO(ruleResultDTO.getResultDTO());
+                AttendResultDTO attendResultDTO = this.executeAndUpdateResult(callContext, param, context, recordId);
+                attendResultList.add(attendResultDTO);
+            }
+            this.attendResultGenLogicCorrectionService.correction(attendResultList, callContext);
+        }
+        this.correctDayReport(param.getSignTime(), context);
+        return CloudwalkResult.success((Object)true);
+    }
+
+    private void correctDayReport(Long time, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        if (time < DateUtils.todayStart()) {
+            this.attendBusinessDayReportService.exec(DateUtils.todayStart((Date)new Date(time)), cloudwalkContext);
+        }
+    }
+
+    private AttendResultDTO executeAndUpdateResult(AttendResultGenCallContext callContext, AttendResultSignParam param, CloudwalkCallContext context, String recordId) throws ServiceException {
+        AttendResultDTO attendResultDTO = callContext.getResultDTO();
+        Long lasStartWorkTime = attendResultDTO.getStartworkTime();
+        AttendResultSignParam beforeSignParam = (AttendResultSignParam)BeanCopyUtils.copyProperties((Object)callContext.getSignParam(), AttendResultSignParam.class);
+        this.execute(callContext);
+        attendResultDTO.setLastUpdateTime(Long.valueOf(System.currentTimeMillis()));
+        attendResultDTO.setLastUpdateUserId(context.getUser().getCaller());
+        attendResultDTO.setDeviceId(param.getDeviceId());
+        attendResultDTO.setDeviceName(param.getDeviceName());
+        this.setRecordId(callContext, beforeSignParam, lasStartWorkTime, recordId);
+        this.attendResultService.update(attendResultDTO);
+        return attendResultDTO;
+    }
+
+    private boolean checkStandMatchResult(CloudwalkResult<Boolean> matchResult, AttendResultGenCallContext callContext) {
+        if (!matchResult.isSuccess() || CollectionUtils.isEmpty((Collection)callContext.getRuleResultList())) {
+            return false;
+        }
+        if (!callContext.isHoliday()) {
+            for (AttendResultRuleResultDTO ruleResultDTO : callContext.getRuleResultList()) {
+                if (ruleResultDTO.getRuleDTO().getMatchScheduling() != null) continue;
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private void setRecordId(AttendResultGenCallContext callContext, AttendResultSignParam signParam, Long lasStartWorkTime, String recordId) {
+        AttendResultDTO resultDTO = callContext.getResultDTO();
+        if (resultDTO.getStartworkTime() != null && signParam.getSignTime().equals(resultDTO.getStartworkTime())) {
+            if (lasStartWorkTime != null && lasStartWorkTime.equals(resultDTO.getEndworkTime())) {
+                resultDTO.setEndRecordId(resultDTO.getStartRecordId());
+            }
+            resultDTO.setStartRecordId(recordId);
+        } else if (resultDTO.getEndworkTime() != null && signParam.getSignTime().equals(resultDTO.getEndworkTime())) {
+            resultDTO.setEndRecordId(recordId);
+        }
+    }
+
+    private boolean checkMatchResult(CloudwalkResult<Boolean> matchResult, AttendResultGenCallContext callContext) {
+        return !matchResult.isSuccess() || callContext.getResultDTO() == null || callContext.getRuleDTO() == null || !callContext.isHoliday() && callContext.getRuleDTO().getMatchScheduling() == null;
+    }
+
+    private AttendResultPersonInfoDTO getPersonInfo(AttendResultGenCallContext callContext) throws ServiceException {
+        String imageId = callContext.getSignParam().getImageId();
+        PersonQueryParam personQueryParam = new PersonQueryParam();
+        personQueryParam.setImageIds(Collections.singletonList(imageId));
+        CloudwalkResult personListResult = this.personService.list(personQueryParam, callContext.getContext());
+        if (!personListResult.isSuccess() || CollectionUtils.isEmpty((Collection)((Collection)personListResult.getData()))) {
+            this.logger.error("\u751f\u6210\u8003\u52e4\u7ed3\u679c\u5931\u8d25,\u6839\u636eimageId\u67e5\u8be2cwos\u6ca1\u6709\u627e\u5230\u4eba\u5458\u4fe1\u606f\uff0cimageId\uff1a{}", (Object)imageId);
+            throw new ServiceException("\u6839\u636eimageId\u67e5\u8be2cwos\u6ca1\u6709\u627e\u5230\u4eba\u5458\u4fe1\u606f");
+        }
+        PersonResult personResult = (PersonResult)((List)personListResult.getData()).get(0);
+        AttendResultPersonInfoDTO personInfoDTO = (AttendResultPersonInfoDTO)BeanCopyUtils.copyProperties((Object)personResult, AttendResultPersonInfoDTO.class);
+        personInfoDTO.setTelephone(personResult.getPhone());
+        if (CollectionUtils.isEmpty((Collection)personResult.getOrganizationIds()) && CollectionUtils.isEmpty((Collection)personResult.getLabelIds())) {
+            this.logger.error("\u751f\u6210\u8003\u52e4\u7ed3\u679c\u5931\u8d25,\u4eba\u5458\u6ca1\u6709\u7ec4\u7ec7\u548c\u6807\u7b7e\u4fe1\u606f\u65e0\u6cd5\u5339\u914d\u8003\u52e4\u89c4\u5219\uff0cimageId\uff1a{}", (Object)imageId);
+            return null;
+        }
+        if (CollectionUtils.isNotEmpty((Collection)personResult.getOrganizationIds())) {
+            personInfoDTO.setOrgIds(personResult.getOrganizationIds());
+            personInfoDTO.setOrgId((String)personResult.getOrganizationIds().get(0));
+        }
+        if (CollectionUtils.isNotEmpty((Collection)personResult.getOrganizationNames())) {
+            personInfoDTO.setOrgName((String)personResult.getOrganizationNames().get(0));
+        }
+        return personInfoDTO;
+    }
+
+    private void execute(AttendResultGenCallContext callContext) throws ServiceException {
+        AttendResultRuleDTO ruleDTO = callContext.getRuleDTO();
+        if (AttendTypeEnum.STANDARD.getCode().equals(ruleDTO.getType())) {
+            this.attendResultStandardGenService.execute(callContext);
+        } else if (AttendTypeEnum.FLEXIBLE.getCode().equals(ruleDTO.getType())) {
+            this.attendResultFlexibilityGenService.execute(callContext);
+        } else if (AttendTypeEnum.SCHEDULING.getCode().equals(ruleDTO.getType())) {
+            this.attendResultSchedulingGenService.execute(callContext);
+        } else {
+            throw new ServiceException("\u4e0d\u652f\u6301\u7684\u8003\u52e4\u7c7b\u578b\uff0c\u76ee\u524d\u652f\u6301\u30101\u3001\u6807\u51c6\u8003\u52e4 2\u3001\u5f39\u6027\u8003\u52e4 3\u3001\u6392\u73ed\u8003\u52e4\u3011");
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/AttendResultInitServiceImpl.java

@@ -0,0 +1,324 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.result.AttendResultManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleHolidayManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleLabelManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleOrgManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleSchedulingManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.result.PersonResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.service.PersonService
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultInitService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.page.CloudwalkPageAble
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultInitPersonInfoDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleHolidayDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleSchedulingDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleGetsDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleHolidayQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleLabelQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleLabelQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleSchedulingQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.RuleLabelTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.AttendUtil
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.StringUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.result;
+
+import cn.cloudwalk.biz.intelligent.ninca.result.AttendResultManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleHolidayManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleLabelManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleOrgManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleSchedulingManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.result.PersonResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.service.PersonService;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultInitService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.page.CloudwalkPageAble;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultInitPersonInfoDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleHolidayDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleSchedulingDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleGetsDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleHolidayQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleLabelQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleLabelQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleSchedulingQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum;
+import cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.em.RuleLabelTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.AttendUtil;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtils;
+import cn.cloudwalk.common.ninca.attendance.util.StringUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendResultInitServiceImpl
+extends AbstractCloudwalkService
+implements AttendResultInitService {
+    @Resource
+    private AttendResultManager attendResultManager;
+    @Resource
+    private AttendRuleHolidayManager attendRuleHolidayManager;
+    @Resource
+    private AttendRuleSchedulingManager attendRuleSchedulingManager;
+    @Resource
+    private AttendRuleManager attendRuleManager;
+    @Resource
+    private PersonService personService;
+    @Resource
+    private AttendRuleOrgManager attendRuleOrgManager;
+    @Resource
+    private AttendRuleLabelManager attendRuleLabelManager;
+    private final int pageSize = 1000;
+    private final int maxPage = 200;
+
+    public void init(Date initDate, CloudwalkCallContext context) throws ServiceException {
+        String businessId = context.getCompany().getCompanyId();
+        this.logger.info("\u5f00\u59cb\u521d\u59cb\u5316\u4f01\u4e1a\u8003\u52e4\u8bb0\u5f55\uff0c\u4f01\u4e1aid={}", (Object)businessId);
+        try {
+            AttendRuleGetsDTO attendRuleGetsDTO = new AttendRuleGetsDTO();
+            attendRuleGetsDTO.setBusinessId(businessId);
+            attendRuleGetsDTO.setStatus(YesNoTypeEnum.Y.getCode());
+            List ruleList = this.attendRuleManager.gets(attendRuleGetsDTO);
+            if (CollectionUtils.isEmpty((Collection)ruleList)) {
+                return;
+            }
+            ruleList.sort(Comparator.comparing(AttendRuleQueryResultDTO::getLastUpdateTime).reversed());
+            block2: for (AttendRuleQueryResultDTO dto : ruleList) {
+                AttendRuleOrgQueryDTO orgQueryDTO = new AttendRuleOrgQueryDTO();
+                orgQueryDTO.setRuleIds(Collections.singletonList(dto.getId()));
+                List orgList = this.attendRuleOrgManager.query(orgQueryDTO);
+                List<String> orgIds = orgList.stream().map(AttendRuleOrgQueryResultDTO::getOrgId).collect(Collectors.toList());
+                AttendRuleLabelQueryDTO labelQueryDTO = new AttendRuleLabelQueryDTO();
+                labelQueryDTO.setRuleId(dto.getId());
+                List labelList = this.attendRuleLabelManager.query(labelQueryDTO);
+                List<String> includeLabelIds = labelList.stream().filter(item -> item.getType().equals(RuleLabelTypeEnum.include.getCode())).map(AttendRuleLabelQueryResultDTO::getLabelId).collect(Collectors.toList());
+                List<String> excludeLabelIds = labelList.stream().filter(item -> item.getType().equals(RuleLabelTypeEnum.exclude.getCode())).map(AttendRuleLabelQueryResultDTO::getLabelId).collect(Collectors.toList());
+                for (int page = 1; page <= 200; ++page) {
+                    this.logger.info("\u4f01\u4e1aid={}\uff0c\u5f00\u59cb\u6267\u884c\u7b2c{}\u9875\u4eba\u5458", (Object)businessId, (Object)page);
+                    List<AttendResultInitPersonInfoDTO> personList = this.getOrgPersonList(orgIds, includeLabelIds, excludeLabelIds, page, context);
+                    if (CollectionUtils.isEmpty(personList)) {
+                        this.logger.info("\u7ec4\u7ec7\u4e0b\u4eba\u5458\u4e3a\u7a7a\uff0c\u505c\u6b62\u521d\u59cb\u5316\u8be5\u56fe\u5e93\u4eba\u5458\uff0c\u521d\u59cb\u5316\u5230\u7b2c{}\u9875\uff0c\u5355\u9875\u5927\u5c0f:{},\u7ec4\u7ec7ids\uff1a{}", new Object[]{page, 1000, orgIds});
+                        continue block2;
+                    }
+                    this.setPersonRule(businessId, initDate, personList, dto);
+                    List<AttendResultDTO> resultList = this.setAttendRecordDTO(initDate, businessId, personList);
+                    if (!CollectionUtils.isNotEmpty(resultList)) continue;
+                    this.attendResultManager.batchInert(resultList);
+                }
+            }
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u6279\u91cf\u63d2\u5165\u4f01\u4e1a\u8003\u52e4\u7ed3\u679c\u8bb0\u5f55\u5931\u8d25\uff0c\u539f\u56e0:", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private void setPersonRule(String businessId, Date initDate, List<AttendResultInitPersonInfoDTO> personList, AttendRuleQueryResultDTO ruleInfo) {
+        try {
+            long dayStart = DateUtils.todayStart((Date)initDate);
+            long dayEnd = DateUtils.todayEnd((Date)initDate);
+            List<String> existPersonIds = personList.stream().map(AttendResultInitPersonInfoDTO::getId).collect(Collectors.toList());
+            List<String> existResultPersonList = this.queryExistResultPerson(businessId, dayStart, dayEnd, existPersonIds);
+            AttendRuleSchedulingQueryDTO schedulingQueryDTO = new AttendRuleSchedulingQueryDTO();
+            schedulingQueryDTO.setRuleIds(Collections.singletonList(ruleInfo.getId()));
+            List schedulingList = this.attendRuleSchedulingManager.query(schedulingQueryDTO);
+            AttendResultRuleDTO matchRuleDTO = (AttendResultRuleDTO)BeanCopyUtils.copyProperties((Object)ruleInfo, AttendResultRuleDTO.class);
+            List schedulings = BeanCopyUtils.copy((Collection)schedulingList, AttendResultRuleSchedulingDTO.class);
+            matchRuleDTO.setSchedulings(schedulings);
+            AttendRuleHolidayQueryDTO queryDTO = new AttendRuleHolidayQueryDTO();
+            queryDTO.setRuleIds(Collections.singletonList(ruleInfo.getId()));
+            List holidayList = this.attendRuleHolidayManager.query(queryDTO);
+            List resultRuleHolidays = BeanCopyUtils.copy((Collection)holidayList, AttendResultRuleHolidayDTO.class);
+            boolean isHoliday = this.isHoliday(initDate, resultRuleHolidays);
+            for (AttendResultInitPersonInfoDTO personInfoDTO : personList) {
+                if (isHoliday || existResultPersonList.contains(personInfoDTO.getId())) continue;
+                personInfoDTO.setRuleInfo(matchRuleDTO);
+            }
+        }
+        catch (DataAccessException | ServiceException e) {
+            this.logger.error("\u8003\u52e4\u4eba\u5458\u8bbe\u7f6e\u8003\u52e4\u89c4\u5219\u5931\u8d25\uff0c\u539f\u56e0\uff1a", e);
+        }
+    }
+
+    private List<AttendResultInitPersonInfoDTO> getOrgPersonList(List<String> orgIds, List<String> includeLabelIds, List<String> excludeLabelIds, int page, CloudwalkCallContext context) throws ServiceException {
+        PersonQueryParam personQueryParam1 = new PersonQueryParam();
+        personQueryParam1.setOrganizationIds(orgIds);
+        personQueryParam1.setCurrentPage(page);
+        personQueryParam1.setRowsOfPage(1000);
+        CloudwalkResult personDetailResult1 = CollectionUtils.isEmpty(orgIds) ? null : this.personService.page(personQueryParam1, context);
+        PersonQueryParam personQueryParam2 = new PersonQueryParam();
+        personQueryParam2.setLabelIds(includeLabelIds);
+        personQueryParam2.setCurrentPage(page);
+        personQueryParam2.setRowsOfPage(1000);
+        CloudwalkResult personDetailResult2 = CollectionUtils.isEmpty(includeLabelIds) ? null : this.personService.page(personQueryParam2, context);
+        List<PersonResult> personList = this.merge((CloudwalkResult<CloudwalkPageAble<PersonResult>>)personDetailResult1, (CloudwalkResult<CloudwalkPageAble<PersonResult>>)personDetailResult2);
+        Iterator<PersonResult> iterator = personList.iterator();
+        while (iterator.hasNext()) {
+            PersonResult personResult = iterator.next();
+            if (!CollectionUtils.isNotEmpty((Collection)personResult.getLabelIds())) continue;
+            for (String labelId : personResult.getLabelIds()) {
+                if (!excludeLabelIds.contains(labelId)) continue;
+                iterator.remove();
+            }
+        }
+        return this.setInitPersonInfo(personList);
+    }
+
+    private List<PersonResult> merge(CloudwalkResult<CloudwalkPageAble<PersonResult>> personDetailResult1, CloudwalkResult<CloudwalkPageAble<PersonResult>> personDetailResult2) {
+        Collection datas1 = personDetailResult1 == null ? null : ((CloudwalkPageAble)personDetailResult1.getData()).getDatas();
+        Collection datas2 = personDetailResult2 == null ? null : ((CloudwalkPageAble)personDetailResult2.getData()).getDatas();
+        HashMap<String, PersonResult> tmpMap = new HashMap<String, PersonResult>();
+        if (CollectionUtils.isNotEmpty((Collection)datas1)) {
+            for (PersonResult personResult : datas1) {
+                tmpMap.put(personResult.getId(), personResult);
+            }
+        }
+        if (CollectionUtils.isNotEmpty((Collection)datas2)) {
+            for (PersonResult personResult : datas2) {
+                tmpMap.put(personResult.getId(), personResult);
+            }
+        }
+        if (tmpMap.size() > 0) {
+            return new ArrayList<PersonResult>(tmpMap.values());
+        }
+        return new ArrayList<PersonResult>();
+    }
+
+    private List<AttendResultInitPersonInfoDTO> setInitPersonInfo(Collection<PersonResult> personList) {
+        ArrayList<AttendResultInitPersonInfoDTO> infoPersonList = new ArrayList<AttendResultInitPersonInfoDTO>(personList.size());
+        for (PersonResult personResult : personList) {
+            AttendResultInitPersonInfoDTO personInfo = (AttendResultInitPersonInfoDTO)BeanCopyUtils.copyProperties((Object)personResult, AttendResultInitPersonInfoDTO.class);
+            if (CollectionUtils.isNotEmpty((Collection)personResult.getOrganizationIds())) {
+                personInfo.setOrgId((String)personResult.getOrganizationIds().get(0));
+            }
+            if (CollectionUtils.isNotEmpty((Collection)personResult.getOrganizationNames())) {
+                personInfo.setOrgName((String)personResult.getOrganizationNames().get(0));
+            }
+            infoPersonList.add(personInfo);
+        }
+        return infoPersonList;
+    }
+
+    public List<String> queryBusinessIdList(Integer status) throws ServiceException {
+        try {
+            return this.attendResultManager.queryBusinessIdList(status);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u67e5\u8be2\u5f85\u521d\u59cb\u5316\u8003\u52e4\u7ed3\u679c\u7684\u4f01\u4e1a\u5217\u8868\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private List<AttendResultDTO> setAttendRecordDTO(Date initDate, String businessId, List<AttendResultInitPersonInfoDTO> personInfoList) throws ServiceException {
+        ArrayList<AttendResultDTO> attendResultList = new ArrayList<AttendResultDTO>();
+        for (AttendResultInitPersonInfoDTO personInfoDTO : personInfoList) {
+            if (personInfoDTO.getRuleInfo() == null) continue;
+            AttendResultRuleDTO ruleDTO = personInfoDTO.getRuleInfo();
+            for (AttendResultRuleSchedulingDTO schedulingDTO : ruleDTO.getSchedulings()) {
+                AttendResultDTO attendResultDTO = new AttendResultDTO();
+                attendResultDTO.setId(this.genUUID());
+                attendResultDTO.setBusinessId(businessId);
+                attendResultDTO.setRuleId(ruleDTO.getId());
+                attendResultDTO.setRuleName(ruleDTO.getName());
+                attendResultDTO.setRuleType(ruleDTO.getType());
+                attendResultDTO.setSchedulingId(schedulingDTO.getId());
+                attendResultDTO.setSchedulingDesc(schedulingDTO.getSchedulingDesc());
+                attendResultDTO.setOrgId(personInfoDTO.getOrgId() == null ? "" : personInfoDTO.getOrgId());
+                attendResultDTO.setOrgName(personInfoDTO.getOrgName() == null ? "" : personInfoDTO.getOrgName());
+                attendResultDTO.setPersonId(personInfoDTO.getId());
+                attendResultDTO.setPersonName(personInfoDTO.getName());
+                attendResultDTO.setDeviceId("");
+                attendResultDTO.setDeviceName("");
+                attendResultDTO.setAttrTime(DateUtils.todayStart((Date)initDate));
+                attendResultDTO.setStartworkTime(null);
+                attendResultDTO.setEndworkTime(null);
+                if (AttendTypeEnum.STANDARD.getCode().equals(ruleDTO.getType())) {
+                    if (schedulingDTO.getStartworkTime() == null || schedulingDTO.getEndworkTime() == null) {
+                        throw new ServiceException("\u8003\u52e4\u7ed3\u679c\u751f\u6210\u5931\u8d25\uff0c\u8003\u52e4\u89c4\u5219\u6807\u51c6\u8003\u52e4\u914d\u7f6e\u4e0a\u4e0b\u73ed\u65f6\u95f4\u4e3a\u7a7a");
+                    }
+                    long ruleStartworkTime = AttendUtil.getRuleTime((String)schedulingDTO.getStartworkTime(), (long)initDate.getTime()).getTime();
+                    long ruleEndworkTime = AttendUtil.getRuleTime((String)schedulingDTO.getEndworkTime(), (long)initDate.getTime()).getTime();
+                    attendResultDTO.setRuleStartworkTime(Long.valueOf(ruleStartworkTime));
+                    attendResultDTO.setRuleEndworkTime(Long.valueOf(ruleEndworkTime));
+                }
+                attendResultDTO.setStartStatus(AttendResultStatusEnum.UN_SIGN_IN.getCode());
+                attendResultDTO.setEndStatus(AttendResultStatusEnum.UN_SIGN_IN.getCode());
+                attendResultDTO.setStatus(YesNoTypeEnum.Y.getCode());
+                long nowTime = System.currentTimeMillis();
+                attendResultDTO.setCreateTime(Long.valueOf(nowTime));
+                attendResultDTO.setCreateUserId(null);
+                attendResultDTO.setLastUpdateTime(Long.valueOf(nowTime));
+                attendResultDTO.setLastUpdateUserId(null);
+                attendResultDTO.setShotId(ruleDTO.getShotId());
+                attendResultList.add(attendResultDTO);
+            }
+        }
+        return attendResultList;
+    }
+
+    private boolean isHoliday(Date initDate, List<AttendResultRuleHolidayDTO> holidays) {
+        if (CollectionUtils.isNotEmpty(holidays)) {
+            for (AttendResultRuleHolidayDTO holiday : holidays) {
+                String initDateStr = DateUtils.formatDate((Date)initDate, (String)"yyyyMMdd");
+                if (!StringUtils.equals((String)initDateStr, (String)holiday.getHolidayDate())) continue;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private List<String> queryExistResultPerson(String businessId, long dayStart, long dayEnd, List<String> personIds) throws ServiceException {
+        try {
+            return this.attendResultManager.queryExistResultPerson(businessId, dayStart, dayEnd, personIds);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u67e5\u8be2\u5df2\u7ecf\u5b58\u5728\u8003\u52e4\u8bb0\u5f55\u4eba\u5458\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/AttendResultInitTaskServiceImpl.java

@@ -0,0 +1,74 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultInitService
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultInitTaskService
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultInitV2Service
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.common.ninca.attendance.config.FeignRequestUtil
+ *  cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtil
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.result;
+
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultInitService;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultInitTaskService;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultInitV2Service;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.common.ninca.attendance.config.FeignRequestUtil;
+import cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtil;
+import cn.cloudwalk.service.ninca.attendance.common.job.AbstractJobService;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendResultInitTaskServiceImpl
+extends AbstractJobService
+implements AttendResultInitTaskService {
+    @Resource
+    private AttendResultInitService attendResultInitService;
+    @Resource
+    private AttendResultInitV2Service attendResultInitV2Service;
+
+    public void resultInit() {
+        try {
+            long curr = System.currentTimeMillis();
+            Date date = new Date();
+            this.logger.info("\u5f00\u59cb\u6267\u884c\u8003\u52e4\u7ed3\u679c\u521d\u59cb\u5316\u5b9a\u65f6\u4efb\u52a1\uff0c\u521d\u59cb\u5316\u65e5\u671f\uff1a{}", (Object)DateUtil.formatStrDate((Date)date, (String)"yyyy-MM-dd HH:mm:ss"));
+            List businessIdList = this.attendResultInitService.queryBusinessIdList(YesNoTypeEnum.Y.getCode());
+            if (CollectionUtils.isEmpty((Collection)businessIdList)) {
+                this.logger.info("\u4efb\u52a1\u521d\u59cb\u5316\u8003\u52e4\u7ed3\u679c\u8bb0\u5f55\uff0c\u6ca1\u6709\u5f85\u521d\u59cb\u5316\u7684\u4f01\u4e1a");
+            }
+            this.logger.info("\u6267\u884c\u8003\u52e4\u7ed3\u679c\u521d\u59cb\u5316\u5b9a\u65f6\u4efb\u52a1\uff0c\u5f85\u521d\u59cb\u5316\u7684\u4f01\u4e1a\u6570\u91cf={}", (Object)businessIdList.size());
+            for (String businessId : businessIdList) {
+                try {
+                    Map defaultRequestHeader = FeignRequestUtil.getDefaultRequestHeader((String)businessId);
+                    FeignRequestUtil.setRequestHeader((Map)defaultRequestHeader);
+                    CloudwalkCallContext context = super.getCloudwalkCallContext(businessId);
+                    this.attendResultInitV2Service.init(date, context);
+                    this.attendResultInitService.init(date, context);
+                }
+                catch (Exception e) {
+                    this.logger.error("\u521d\u59cb\u5316\u4f01\u4e1a\u8003\u52e4\u7ed3\u679c\u8bb0\u5f55\u5931\u8d25\uff0c\u539f\u56e0:", (Throwable)e);
+                }
+            }
+            this.logger.info("\u6267\u884c\u8003\u52e4\u7ed3\u679c\u521d\u59cb\u5316\u5b9a\u65f6\u4efb\u52a1\u7ed3\u675f\uff0c\u603b\u8017\u65f6={}ms", (Object)(System.currentTimeMillis() - curr));
+        }
+        catch (ServiceException e) {
+            this.logger.error("\u4efb\u52a1\u751f\u6210\u8003\u52e4\u7ed3\u679c\u8bb0\u5f55\u5931\u8d25\uff0c\u539f\u56e0", (Throwable)e);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/AttendResultInitV2ServiceImpl.java

@@ -0,0 +1,302 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendClassManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendSchedulingManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendShiftManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendShiftPeriodManager
+ *  cn.cloudwalk.biz.intelligent.ninca.result.AttendResultManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.result.PersonResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.service.PersonService
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultInitV2Service
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.page.CloudwalkPageAble
+ *  cn.cloudwalk.cloud.page.CloudwalkPageInfo
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingPageDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingPageResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftGetsDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftGetsResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftPeriodQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftPeriodQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultInitPersonInfoDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleSchedulingDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.SchedulingDateTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.AttendUtil
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.result;
+
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendClassManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendSchedulingManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendShiftManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendShiftPeriodManager;
+import cn.cloudwalk.biz.intelligent.ninca.result.AttendResultManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.result.PersonResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.service.PersonService;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultInitV2Service;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.page.CloudwalkPageAble;
+import cn.cloudwalk.cloud.page.CloudwalkPageInfo;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingPageDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingPageResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftGetsDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftGetsResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftPeriodQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftPeriodQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultInitPersonInfoDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleSchedulingDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum;
+import cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.em.SchedulingDateTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.AttendUtil;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendResultInitV2ServiceImpl
+extends AbstractCloudwalkService
+implements AttendResultInitV2Service {
+    @Resource
+    private AttendResultManager attendResultManager;
+    @Resource
+    private PersonService personService;
+    @Resource
+    private AttendClassManager attendClassManager;
+    @Resource
+    private AttendSchedulingManager attendSchedulingManager;
+    @Resource
+    private AttendShiftManager attendShiftManager;
+    @Resource
+    private AttendShiftPeriodManager attendShiftPeriodManager;
+    private final int pageSize = 1000;
+    private final int maxPage = 200;
+
+    public void init(Date initDate, CloudwalkCallContext context) throws ServiceException {
+        String businessId = context.getCompany().getCompanyId();
+        this.logger.info("\u5f00\u59cb\u521d\u59cb\u5316\u4f01\u4e1a\u6392\u73ed\u8003\u52e4\u8bb0\u5f55\uff0c\u4f01\u4e1aid={}", (Object)businessId);
+        try {
+            AttendClassQueryDTO attendClassQueryDTO = new AttendClassQueryDTO();
+            attendClassQueryDTO.setBusinessId(businessId);
+            attendClassQueryDTO.setStatus(YesNoTypeEnum.Y.getCode());
+            attendClassQueryDTO.setIsEnable(YesNoTypeEnum.Y.getCode());
+            List classList = this.attendClassManager.query(attendClassQueryDTO);
+            if (CollectionUtils.isEmpty((Collection)classList)) {
+                this.logger.info("\u4f01\u4e1a:{}\u4e0b\u6ca1\u6709\u8003\u52e4\u73ed\u7ec4\uff0c\u65e0\u9700\u521d\u59cb\u5316", (Object)businessId);
+                return;
+            }
+            classList.sort(Comparator.comparing(AttendClassQueryResultDTO::getLastUpdateTime).reversed());
+            block2: for (AttendClassQueryResultDTO dto : classList) {
+                for (int page = 1; page <= 200; ++page) {
+                    this.logger.info("\u4f01\u4e1aid={}\uff0c\u5f00\u59cb\u6267\u884c\u7b2c{}\u9875\u4eba\u5458", (Object)businessId, (Object)page);
+                    List<AttendSchedulingPageResultDTO> schedulingPersonList = this.querySchedulingPersonList(initDate, dto.getId(), page, context);
+                    if (CollectionUtils.isEmpty(schedulingPersonList)) {
+                        this.logger.info("\u73ed\u7ec4\u4e0b\u6392\u73ed\u4fe1\u606f\u4e3a\u7a7a\uff0c\u505c\u6b62\u521d\u59cb\u5316\u8be5\u73ed\u7ec4\u4e0b\u4eba\u5458\uff0c\u521d\u59cb\u5316\u5230\u7b2c{}\u9875\uff0c\u5355\u9875\u5927\u5c0f:{},\u73ed\u7ec4id\uff1a{}", new Object[]{page, 1000, dto.getId()});
+                        continue block2;
+                    }
+                    List<AttendResultInitPersonInfoDTO> personList = this.getClassPersonList(schedulingPersonList, context);
+                    if (CollectionUtils.isEmpty(personList)) {
+                        this.logger.info("\u73ed\u7ec4\u4e0b\u4eba\u5458\u4e3a\u7a7a\uff0c\u505c\u6b62\u521d\u59cb\u5316\u8be5\u73ed\u7ec4\u4e0b\u4eba\u5458\uff0c\u521d\u59cb\u5316\u5230\u7b2c{}\u9875\uff0c\u5355\u9875\u5927\u5c0f:{},\u73ed\u7ec4id\uff1a{}", new Object[]{page, 1000, dto.getId()});
+                        continue block2;
+                    }
+                    this.setPersonRule(businessId, initDate, personList, dto, schedulingPersonList);
+                    List<AttendResultDTO> resultList = this.setAttendRecordDTO(initDate, businessId, personList);
+                    if (!CollectionUtils.isNotEmpty(resultList)) continue;
+                    this.attendResultManager.batchInert(resultList);
+                }
+            }
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u6279\u91cf\u63d2\u5165\u4f01\u4e1a\u6392\u73ed\u8003\u52e4\u7ed3\u679c\u8bb0\u5f55\u5931\u8d25\uff0c\u539f\u56e0:", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private List<AttendSchedulingPageResultDTO> querySchedulingPersonList(Date initDate, String classId, int page, CloudwalkCallContext context) throws DataAccessException {
+        AttendSchedulingPageDTO schedulingQueryDTO = new AttendSchedulingPageDTO();
+        schedulingQueryDTO.setClassId(classId);
+        schedulingQueryDTO.setBusinessId(context.getCompany().getCompanyId());
+        schedulingQueryDTO.setIsPublish(YesNoTypeEnum.Y.getCode());
+        schedulingQueryDTO.setSchedulingDate(DateUtils.todayStart((Date)initDate));
+        CloudwalkPageInfo pageInfo = new CloudwalkPageInfo(page, 1000);
+        CloudwalkPageAble queryResultList = this.attendSchedulingManager.page(schedulingQueryDTO, pageInfo);
+        if (CollectionUtils.isNotEmpty((Collection)queryResultList.getDatas())) {
+            return (List)queryResultList.getDatas();
+        }
+        return new ArrayList<AttendSchedulingPageResultDTO>();
+    }
+
+    private void setPersonRule(String businessId, Date initDate, List<AttendResultInitPersonInfoDTO> personList, AttendClassQueryResultDTO classDTO, List<AttendSchedulingPageResultDTO> schedulingResultList) {
+        try {
+            long dayStart = DateUtils.todayStart((Date)initDate);
+            long dayEnd = DateUtils.todayEnd((Date)initDate);
+            List<String> existPersonIds = personList.stream().map(AttendResultInitPersonInfoDTO::getId).collect(Collectors.toList());
+            List<String> existResultPersonList = this.queryExistResultPerson(businessId, dayStart, dayEnd, existPersonIds);
+            Map<String, List<AttendSchedulingPageResultDTO>> schedulingMap = schedulingResultList.stream().collect(Collectors.groupingBy(AttendSchedulingPageResultDTO::getPersonId));
+            List shiftIds = schedulingResultList.stream().map(AttendSchedulingPageResultDTO::getShiftId).collect(Collectors.toList());
+            AttendShiftGetsDTO shiftGetsDTO = new AttendShiftGetsDTO();
+            shiftGetsDTO.setIds(shiftIds);
+            List shiftGetsResultList = this.attendShiftManager.gets(shiftGetsDTO);
+            Map<String, List<AttendShiftGetsResultDTO>> shiftMap = shiftGetsResultList.stream().collect(Collectors.groupingBy(AttendShiftGetsResultDTO::getId));
+            AttendShiftPeriodQueryDTO periodQueryDTO = new AttendShiftPeriodQueryDTO();
+            periodQueryDTO.setShiftIds(shiftIds);
+            List periodResultList = this.attendShiftPeriodManager.query(periodQueryDTO);
+            Map<String, List<AttendShiftPeriodQueryResultDTO>> periodMap = periodResultList.stream().collect(Collectors.groupingBy(AttendShiftPeriodQueryResultDTO::getShiftId));
+            for (AttendResultInitPersonInfoDTO personInfoDTO : personList) {
+                if (schedulingMap.get(personInfoDTO.getId()) == null) {
+                    this.logger.info("\u7ed3\u679c\u521d\u59cb\u5316\uff0c\u4eba\u5458{}\u4e0b\u6ca1\u6709\u6392\u73ed", (Object)personInfoDTO.getId());
+                    continue;
+                }
+                AttendSchedulingPageResultDTO schedulingDTO = schedulingMap.get(personInfoDTO.getId()).get(0);
+                AttendShiftGetsResultDTO shiftDTO = shiftMap.get(schedulingDTO.getShiftId()).get(0);
+                List<AttendShiftPeriodQueryResultDTO> periodList = periodMap.get(schedulingDTO.getShiftId());
+                if (shiftDTO == null || CollectionUtils.isEmpty(periodList)) {
+                    this.logger.info("\u7ed3\u679c\u521d\u59cb\u5316\uff0c\u4eba\u5458{}\u4e0b\u6ca1\u6709\u73ed\u79cd\u6216\u8005\u65f6\u6bb5", (Object)personInfoDTO.getId());
+                    continue;
+                }
+                if (!YesNoTypeEnum.Y.getCode().equals(schedulingDTO.getIsPublish()) || !SchedulingDateTypeEnum.WORK_DAY.getCode().equals(schedulingDTO.getSchedulingType()) || !YesNoTypeEnum.Y.getCode().equals(shiftDTO.getIsEnable()) || !YesNoTypeEnum.Y.getCode().equals(shiftDTO.getStatus()) || existResultPersonList.contains(personInfoDTO.getId())) continue;
+                AttendResultRuleDTO matchRuleDTO = (AttendResultRuleDTO)BeanCopyUtils.copyProperties((Object)classDTO, AttendResultRuleDTO.class);
+                List schedulings = BeanCopyUtils.copy(periodList, AttendResultRuleSchedulingDTO.class);
+                matchRuleDTO.setSchedulings(schedulings);
+                matchRuleDTO.setShiftShotId(shiftDTO.getShotId());
+                personInfoDTO.setRuleInfo(matchRuleDTO);
+            }
+        }
+        catch (DataAccessException | ServiceException e) {
+            this.logger.error("\u8003\u52e4\u4eba\u5458\u8bbe\u7f6e\u8003\u52e4\u89c4\u5219\u5931\u8d25\uff0c\u539f\u56e0\uff1a", e);
+        }
+    }
+
+    private List<AttendResultInitPersonInfoDTO> getClassPersonList(List<AttendSchedulingPageResultDTO> schedulingPersonList, CloudwalkCallContext context) throws ServiceException {
+        if (CollectionUtils.isNotEmpty(schedulingPersonList)) {
+            List personIds = schedulingPersonList.stream().map(AttendSchedulingPageResultDTO::getPersonId).collect(Collectors.toList());
+            PersonQueryParam personQueryParam = new PersonQueryParam();
+            personQueryParam.setIds(personIds);
+            CloudwalkResult personDetailResult = this.personService.list(personQueryParam, context);
+            return this.setInitPersonInfo((List)personDetailResult.getData());
+        }
+        return new ArrayList<AttendResultInitPersonInfoDTO>();
+    }
+
+    private List<AttendResultInitPersonInfoDTO> setInitPersonInfo(List<PersonResult> personList) {
+        if (CollectionUtils.isEmpty(personList)) {
+            return new ArrayList<AttendResultInitPersonInfoDTO>();
+        }
+        ArrayList<AttendResultInitPersonInfoDTO> infoPersonList = new ArrayList<AttendResultInitPersonInfoDTO>(personList.size());
+        for (PersonResult personResult : personList) {
+            AttendResultInitPersonInfoDTO personInfo = (AttendResultInitPersonInfoDTO)BeanCopyUtils.copyProperties((Object)personResult, AttendResultInitPersonInfoDTO.class);
+            if (CollectionUtils.isNotEmpty((Collection)personResult.getOrganizationIds())) {
+                personInfo.setOrgId((String)personResult.getOrganizationIds().get(0));
+            }
+            if (CollectionUtils.isNotEmpty((Collection)personResult.getOrganizationNames())) {
+                personInfo.setOrgName((String)personResult.getOrganizationNames().get(0));
+            }
+            infoPersonList.add(personInfo);
+        }
+        return infoPersonList;
+    }
+
+    public List<String> queryBusinessIdList(Integer status) throws ServiceException {
+        try {
+            return this.attendResultManager.queryBusinessIdList(status);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u67e5\u8be2\u5f85\u521d\u59cb\u5316\u8003\u52e4\u7ed3\u679c\u7684\u4f01\u4e1a\u5217\u8868\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private List<AttendResultDTO> setAttendRecordDTO(Date initDate, String businessId, List<AttendResultInitPersonInfoDTO> personInfoList) throws ServiceException {
+        ArrayList<AttendResultDTO> attendResultList = new ArrayList<AttendResultDTO>();
+        for (AttendResultInitPersonInfoDTO personInfoDTO : personInfoList) {
+            if (personInfoDTO.getRuleInfo() == null) continue;
+            AttendResultRuleDTO ruleDTO = personInfoDTO.getRuleInfo();
+            for (AttendResultRuleSchedulingDTO schedulingDTO : ruleDTO.getSchedulings()) {
+                AttendResultDTO attendResultDTO = new AttendResultDTO();
+                attendResultDTO.setId(this.genUUID());
+                attendResultDTO.setBusinessId(businessId);
+                attendResultDTO.setRuleId(ruleDTO.getId());
+                attendResultDTO.setRuleName(ruleDTO.getName());
+                attendResultDTO.setRuleType(ruleDTO.getType());
+                attendResultDTO.setSchedulingId(schedulingDTO.getId());
+                attendResultDTO.setSchedulingDesc(schedulingDTO.getSchedulingDesc() == null ? "" : schedulingDTO.getSchedulingDesc());
+                attendResultDTO.setOrgId(personInfoDTO.getOrgId() == null ? "" : personInfoDTO.getOrgId());
+                attendResultDTO.setOrgName(personInfoDTO.getOrgName() == null ? "" : personInfoDTO.getOrgName());
+                attendResultDTO.setPersonId(personInfoDTO.getId());
+                attendResultDTO.setPersonName(personInfoDTO.getName());
+                attendResultDTO.setDeviceId("");
+                attendResultDTO.setDeviceName("");
+                attendResultDTO.setAttrTime(DateUtils.todayStart((Date)initDate));
+                attendResultDTO.setStartworkTime(null);
+                attendResultDTO.setEndworkTime(null);
+                if (AttendTypeEnum.SCHEDULING.getCode().equals(ruleDTO.getType())) {
+                    if (schedulingDTO.getStartworkTime() == null || schedulingDTO.getEndworkTime() == null) {
+                        throw new ServiceException("\u8003\u52e4\u7ed3\u679c\u751f\u6210\u5931\u8d25\uff0c\u8003\u52e4\u89c4\u5219\u6807\u51c6\u8003\u52e4\u914d\u7f6e\u4e0a\u4e0b\u73ed\u65f6\u95f4\u4e3a\u7a7a");
+                    }
+                    long ruleStartworkTime = AttendUtil.getRuleTime((String)schedulingDTO.getStartworkTime(), (long)initDate.getTime()).getTime();
+                    long ruleEndworkTime = AttendUtil.getRuleTime((String)schedulingDTO.getEndworkTime(), (long)initDate.getTime()).getTime();
+                    attendResultDTO.setRuleStartworkTime(Long.valueOf(ruleStartworkTime));
+                    attendResultDTO.setRuleEndworkTime(Long.valueOf(ruleEndworkTime));
+                }
+                attendResultDTO.setStartStatus(AttendResultStatusEnum.UN_SIGN_IN.getCode());
+                attendResultDTO.setEndStatus(AttendResultStatusEnum.UN_SIGN_IN.getCode());
+                attendResultDTO.setStatus(YesNoTypeEnum.Y.getCode());
+                long nowTime = System.currentTimeMillis();
+                attendResultDTO.setCreateTime(Long.valueOf(nowTime));
+                attendResultDTO.setCreateUserId(null);
+                attendResultDTO.setLastUpdateTime(Long.valueOf(nowTime));
+                attendResultDTO.setLastUpdateUserId(null);
+                attendResultDTO.setShotId(ruleDTO.getShotId());
+                attendResultDTO.setShiftShotId(ruleDTO.getShiftShotId());
+                attendResultList.add(attendResultDTO);
+            }
+        }
+        return attendResultList;
+    }
+
+    private List<String> queryExistResultPerson(String businessId, long dayStart, long dayEnd, List<String> personIds) throws ServiceException {
+        try {
+            return this.attendResultManager.queryExistResultPerson(businessId, dayStart, dayEnd, personIds);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u67e5\u8be2\u5df2\u7ecf\u5b58\u5728\u8003\u52e4\u8bb0\u5f55\u4eba\u5458\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/AttendResultRoadMapServiceImpl.java

@@ -0,0 +1,110 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendSchedulingManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendShiftPeriodManager
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultRoadMapService
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftPeriodQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftPeriodQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.SchedulingDateTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.AttendUtil
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtil
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.result;
+
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendSchedulingManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendShiftPeriodManager;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultRoadMapService;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftPeriodQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftPeriodQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.em.SchedulingDateTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.AttendUtil;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtil;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.List;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendResultRoadMapServiceImpl
+extends AbstractCloudwalkService
+implements AttendResultRoadMapService {
+    @Resource
+    private AttendSchedulingManager attendSchedulingManager;
+    @Resource
+    private AttendShiftPeriodManager attendShiftPeriodManager;
+
+    public boolean getRoadMap(AttendResultGenCallContext callContext) throws ServiceException {
+        try {
+            Long signTime = callContext.getSignParam().getSignTime();
+            Date beforeDay = DateUtil.addDays((Date)new Date(signTime), (int)-1);
+            List<AttendSchedulingQueryResultDTO> beforeSchedulingList = this.getScheduling(callContext, beforeDay.getTime());
+            if (CollectionUtils.isEmpty(beforeSchedulingList)) {
+                List<AttendSchedulingQueryResultDTO> nowDaySchedulingList = this.getScheduling(callContext, signTime);
+                return CollectionUtils.isNotEmpty(nowDaySchedulingList);
+            }
+            boolean checkTime = this.checkTime(beforeSchedulingList, callContext);
+            if (!checkTime) {
+                List<AttendSchedulingQueryResultDTO> nowDaySchedulingList = this.getScheduling(callContext, signTime);
+                return CollectionUtils.isNotEmpty(nowDaySchedulingList);
+            }
+            return true;
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u8003\u52e4\u7ed3\u679c\u751f\u6210\uff0c\u5224\u65ad\u662f\u5426\u6267\u884c\u6392\u73ed\u8def\u7ebf\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private List<AttendSchedulingQueryResultDTO> getScheduling(AttendResultGenCallContext callContext, Long conditionDate) throws DataAccessException {
+        AttendSchedulingQueryDTO queryDTO = new AttendSchedulingQueryDTO();
+        queryDTO.setBusinessId(callContext.getSignParam().getBusinessId());
+        queryDTO.setPersonId(callContext.getPersonInfoDTO().getId());
+        queryDTO.setSchedulingDate(DateUtils.todayStart((Date)new Date(conditionDate)));
+        queryDTO.setIsPublish(YesNoTypeEnum.Y.getCode());
+        return this.attendSchedulingManager.queryList(queryDTO);
+    }
+
+    private boolean checkTime(List<AttendSchedulingQueryResultDTO> schedulingList, AttendResultGenCallContext callContext) throws DataAccessException, ServiceException {
+        if (CollectionUtils.isNotEmpty(schedulingList)) {
+            schedulingList.sort(Comparator.comparing(AttendSchedulingQueryResultDTO::getLastUpdateTime).reversed());
+            AttendSchedulingQueryResultDTO schedulingQueryResultDTO = schedulingList.get(0);
+            if (SchedulingDateTypeEnum.REST_DAY.getCode().equals(schedulingQueryResultDTO.getSchedulingType())) {
+                return false;
+            }
+            AttendShiftPeriodQueryDTO periodQueryDTO = new AttendShiftPeriodQueryDTO();
+            periodQueryDTO.setShiftId(schedulingQueryResultDTO.getShiftId());
+            List periodList = this.attendShiftPeriodManager.query(periodQueryDTO);
+            periodList.sort(Comparator.comparingInt(AttendShiftPeriodQueryResultDTO::getSortValue));
+            AttendShiftPeriodQueryResultDTO periodDTO = (AttendShiftPeriodQueryResultDTO)periodList.get(periodList.size() - 1);
+            Date endAdaptTime = AttendUtil.getRuleTime((String)periodDTO.getEndAdaptTime(), (long)callContext.getSignParam().getSignTime());
+            if (endAdaptTime == null) {
+                throw new ServiceException("\u83b7\u53d6\u6392\u73ed\u6267\u884c\u8def\u7ebf\u65f6\u95f4\u6821\u9a8c\uff0c\u683c\u5f0f\u5316\u65f6\u95f4\u5931\u8d25");
+            }
+            return callContext.getSignParam().getSignTime() <= endAdaptTime.getTime();
+        }
+        return false;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/AttendResultRuleServiceImpl.java

@@ -0,0 +1,307 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleDeviceManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleHolidayManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleSchedulingManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleShotManager
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultRuleService
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultService
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultMatchRuleQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultPersonInfoDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleHolidayDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleSchedulingDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceShotQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleHolidayQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleSchedulingQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.AttendUtil
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtil
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtils
+ *  com.alibaba.fastjson.JSON
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.result;
+
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleDeviceManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleHolidayManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleSchedulingManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleShotManager;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultRuleService;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultService;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultMatchRuleQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultPersonInfoDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleHolidayDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleSchedulingDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceShotQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleHolidayQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleSchedulingQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.AttendUtil;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtil;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import com.alibaba.fastjson.JSON;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.List;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+@Service(value="standard")
+public class AttendResultRuleServiceImpl
+extends AbstractCloudwalkService
+implements AttendResultRuleService {
+    @Resource
+    private AttendResultService attendResultService;
+    @Resource
+    private AttendRuleHolidayManager attendRuleHolidayManager;
+    @Resource
+    private AttendRuleShotManager attendRuleShotManager;
+    @Resource
+    private AttendRuleSchedulingManager attendRuleSchedulingManager;
+    @Resource
+    private AttendRuleDeviceManager attendRuleDeviceManager;
+
+    public CloudwalkResult<Boolean> matchRule(AttendResultGenCallContext callContext) throws ServiceException {
+        try {
+            List<AttendResultRuleDTO> ruleDTOList = this.getRuleList(callContext);
+            if (CollectionUtils.isEmpty(ruleDTOList)) {
+                return CloudwalkResult.fail((String)"76240245", (String)"\u8be5\u6253\u5361\u6ca1\u6709\u5bf9\u5e94\u7684\u65f6\u6bb5");
+            }
+            List<AttendResultDTO> attendResultDTOList = this.getAttendResultList(callContext, ruleDTOList);
+            List<AttendResultRuleResultDTO> ruleResultList = null;
+            if (CollectionUtils.isNotEmpty(attendResultDTOList)) {
+                ruleResultList = this.getRuleResult(ruleDTOList, attendResultDTOList, callContext);
+            }
+            callContext.setRuleResultList(ruleResultList);
+            return CloudwalkResult.success((Object)true);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u8003\u52e4\u7ed3\u679c\u751f\u6210\uff0c\u67e5\u8be2\u5339\u914d\u8003\u52e4\u89c4\u5219\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private List<AttendResultRuleResultDTO> getRuleResult(List<AttendResultRuleDTO> ruleDTOList, List<AttendResultDTO> attendResultDTOList, AttendResultGenCallContext callContext) {
+        ArrayList<AttendResultRuleResultDTO> returnList = new ArrayList<AttendResultRuleResultDTO>();
+        if (callContext.isHoliday()) {
+            AttendResultRuleResultDTO ruleResultDTO = new AttendResultRuleResultDTO();
+            ruleResultDTO.setResultDTO(attendResultDTOList.get(0));
+            ruleResultDTO.setRuleDTO(ruleDTOList.get(0));
+            returnList.add(ruleResultDTO);
+        } else {
+            for (AttendResultDTO resultDTO : attendResultDTOList) {
+                for (AttendResultRuleDTO ruleDTO : ruleDTOList) {
+                    if (!resultDTO.getSchedulingId().equals(ruleDTO.getMatchScheduling().getId())) continue;
+                    AttendResultRuleResultDTO ruleResultDTO = new AttendResultRuleResultDTO();
+                    ruleResultDTO.setResultDTO(resultDTO);
+                    ruleResultDTO.setRuleDTO(ruleDTO);
+                    returnList.add(ruleResultDTO);
+                }
+            }
+        }
+        return returnList;
+    }
+
+    private List<AttendResultDTO> getAttendResultList(AttendResultGenCallContext callContext, List<AttendResultRuleDTO> ruleDTOList) throws ServiceException {
+        ArrayList<AttendResultDTO> returnResultList = new ArrayList<AttendResultDTO>();
+        if (CollectionUtils.isNotEmpty(ruleDTOList)) {
+            if (callContext.isHoliday()) {
+                AttendResultDTO resultDTO = this.getAttendHolidayResult(callContext.getResultList(), callContext);
+                if (resultDTO == null) {
+                    CloudwalkResult initResult = this.attendResultService.init(callContext, ruleDTOList.get(0), callContext.getPersonInfoDTO(), callContext.getContext());
+                    resultDTO = (AttendResultDTO)initResult.getData();
+                }
+                returnResultList.add(resultDTO);
+            } else {
+                for (AttendResultRuleDTO ruleDTO : ruleDTOList) {
+                    AttendResultDTO attendResultDTO = null;
+                    if (ruleDTO.getMatchScheduling() != null) {
+                        attendResultDTO = this.getAttendResult(callContext.getResultList(), ruleDTO, callContext);
+                        if (attendResultDTO == null) {
+                            CloudwalkResult initResult = this.attendResultService.init(callContext, ruleDTO, callContext.getPersonInfoDTO(), callContext.getContext());
+                            attendResultDTO = (AttendResultDTO)initResult.getData();
+                        }
+                    } else {
+                        this.logger.info("\u3010\u6807\u51c6\u8003\u52e4\u3011\u83b7\u53d6\u8003\u52e4\u7ed3\u679c\uff0c\u89c4\u5219\u4e2d\u6ca1\u6709\u5339\u914d\u7684\u65f6\u6bb5\uff0c\u53c2\u6570={}", (Object)JSON.toJSONString((Object)ruleDTO));
+                    }
+                    returnResultList.add(attendResultDTO);
+                }
+            }
+        }
+        return returnResultList;
+    }
+
+    private List<AttendResultRuleDTO> getRuleList(AttendResultGenCallContext callContext) throws DataAccessException, ServiceException {
+        List<Integer> ruleTypes = Arrays.asList(AttendTypeEnum.STANDARD.getCode(), AttendTypeEnum.FLEXIBLE.getCode());
+        List resultList = this.attendResultService.query(callContext, ruleTypes);
+        ArrayList<AttendResultRuleDTO> ruleDTOList = new ArrayList();
+        if (CollectionUtils.isNotEmpty((Collection)resultList)) {
+            ruleDTOList = this.getShotRuleByResultList(resultList, callContext);
+        }
+        if (CollectionUtils.isEmpty(ruleDTOList)) {
+            ruleDTOList = this.getRule(callContext);
+        }
+        callContext.setResultList(resultList);
+        return ruleDTOList;
+    }
+
+    private AttendResultDTO getAttendHolidayResult(List<AttendResultDTO> resultList, AttendResultGenCallContext callContext) {
+        for (AttendResultDTO resultDTO : resultList) {
+            if (!DateUtils.todayStart((Date)new Date(resultDTO.getAttrTime())).equals(DateUtils.todayStart((Date)new Date(callContext.getRuleAttendTime())))) continue;
+            return resultDTO;
+        }
+        return null;
+    }
+
+    private List<AttendResultRuleDTO> getShotRuleByResultList(List<AttendResultDTO> resultList, AttendResultGenCallContext callContext) throws DataAccessException, ServiceException {
+        AttendResultDTO resultDTO;
+        List<AttendResultRuleDTO> ruleDTOList = new ArrayList<AttendResultRuleDTO>();
+        resultList.sort(Comparator.comparing(AttendResultDTO::getAttrTime).reversed());
+        Iterator<AttendResultDTO> iterator = resultList.iterator();
+        while (iterator.hasNext() && !CollectionUtils.isNotEmpty(ruleDTOList = this.getShotRule(resultDTO = iterator.next(), callContext))) {
+        }
+        return ruleDTOList;
+    }
+
+    private AttendResultDTO getAttendResult(List<AttendResultDTO> resultList, AttendResultRuleDTO ruleDTO, AttendResultGenCallContext callContext) {
+        for (AttendResultDTO resultDTO : resultList) {
+            if (!DateUtils.todayStart((Date)new Date(resultDTO.getAttrTime())).equals(DateUtils.todayStart((Date)new Date(callContext.getRuleAttendTime()))) || !resultDTO.getSchedulingId().equals(ruleDTO.getMatchScheduling().getId())) continue;
+            return resultDTO;
+        }
+        return null;
+    }
+
+    private List<AttendResultRuleDTO> getShotRule(AttendResultDTO resultDTO, AttendResultGenCallContext callContext) throws DataAccessException, ServiceException {
+        String shotId = resultDTO.getShotId();
+        List ruleList = this.attendRuleShotManager.queryShotAttendRule(shotId);
+        AttendResultRuleDTO ruleInfo = (AttendResultRuleDTO)ruleList.get(0);
+        List<String> ruleDeviceIds = this.queryShotRuleDeviceIds(ruleInfo.getShotId());
+        if (CollectionUtils.isEmpty(ruleDeviceIds) || !ruleDeviceIds.contains(callContext.getSignParam().getDeviceId())) {
+            this.logger.info("\u5f53\u524d\u8003\u52e4\u4eba\u5458\u6253\u5361\u8bbe\u5907\u4e0d\u662f\u89c4\u5219\u4e0b\u7684\u6709\u6548\u8003\u52e4\u8bbe\u5907\uff0c\u6253\u5361\u8bbe\u5907id\uff1a{}\uff0c\u5feb\u7167\u89c4\u5219id\uff1a{}", (Object)callContext.getSignParam().getDeviceId(), (Object)ruleInfo.getShotId());
+            return null;
+        }
+        List schedulingList = this.attendRuleShotManager.queryShotScheduling(shotId);
+        List resultRuleSchedulingList = BeanCopyUtils.copy((Collection)schedulingList, AttendResultRuleSchedulingDTO.class);
+        ruleInfo.setSchedulings(resultRuleSchedulingList);
+        List holidayList = this.attendRuleShotManager.queryShotRuleHoliday(shotId);
+        List tmpHolidayList = BeanCopyUtils.copy((Collection)holidayList, AttendResultRuleHolidayDTO.class);
+        this.setRuleAttendTime(callContext, ruleInfo);
+        if (!DateUtils.todayStart((Date)new Date(callContext.getRuleAttendTime())).equals(DateUtils.todayStart((Date)new Date(resultDTO.getAttrTime())))) {
+            return null;
+        }
+        if (AttendUtil.nowDayIsHoliday((List)tmpHolidayList, (long)callContext.getRuleAttendTime())) {
+            callContext.setHoliday(true);
+            return Collections.singletonList(ruleInfo);
+        }
+        return this.setSchedule(resultDTO.getAttrTime(), callContext.getSignParam().getSignTime(), ruleInfo);
+    }
+
+    private void setRuleAttendTime(AttendResultGenCallContext callContext, AttendResultRuleDTO ruleDTO) {
+        boolean acrossDay = false;
+        String signTimeHms = DateUtils.formatDate((Date)new Date(callContext.getSignParam().getSignTime()), (String)"yyyy-MM-dd HH:mm:ss").substring(11, 19);
+        String lastEndAdaptTime = ((AttendResultRuleSchedulingDTO)ruleDTO.getSchedulings().get(ruleDTO.getSchedulings().size() - 1)).getEndAdaptTime();
+        if (AttendUtil.parseTime((String)lastEndAdaptTime).getAcross() > 0 && AttendUtil.compare((String)signTimeHms, (String)AttendUtil.parseTime((String)lastEndAdaptTime).getTime()) <= 0) {
+            acrossDay = true;
+        }
+        long ruleAttendTime = acrossDay ? DateUtil.addDays((Date)new Date(callContext.getSignParam().getSignTime()), (int)-1).getTime() : callContext.getSignParam().getSignTime().longValue();
+        callContext.setRuleAttendTime(Long.valueOf(ruleAttendTime));
+    }
+
+    private List<AttendResultRuleDTO> getRule(AttendResultGenCallContext callContext) throws DataAccessException, ServiceException {
+        AttendResultPersonInfoDTO personInfoDTO = callContext.getPersonInfoDTO();
+        AttendResultMatchRuleQueryDTO ruleQueryDTO = new AttendResultMatchRuleQueryDTO();
+        ruleQueryDTO.setBusinessId(callContext.getSignParam().getBusinessId());
+        ruleQueryDTO.setOrgIds(personInfoDTO.getOrgIds());
+        ruleQueryDTO.setLabelIds(personInfoDTO.getLabelIds());
+        AttendResultRuleDTO matchRule = this.attendResultService.queryMatchRule(ruleQueryDTO);
+        if (matchRule == null) {
+            this.logger.info("\u5f53\u524d\u8003\u52e4\u4eba\u5458\u6ca1\u6709\u5339\u914d\u7684\u8003\u52e4\u89c4\u5219\uff0c\u53c2\u6570\uff1a{}", (Object)callContext.getSignParam());
+            return null;
+        }
+        List<String> ruleDeviceIds = this.queryRuleDeviceIds(matchRule.getId());
+        if (CollectionUtils.isEmpty(ruleDeviceIds) || !ruleDeviceIds.contains(callContext.getSignParam().getDeviceId())) {
+            this.logger.info("\u5f53\u524d\u8003\u52e4\u4eba\u5458\u6253\u5361\u8bbe\u5907\u4e0d\u662f\u89c4\u5219\u4e0b\u7684\u6709\u6548\u8003\u52e4\u8bbe\u5907\uff0c\u6253\u5361\u8bbe\u5907id\uff1a{}\uff0c\u89c4\u5219id\uff1a{}", (Object)callContext.getSignParam().getDeviceId(), (Object)matchRule.getId());
+            return null;
+        }
+        AttendRuleHolidayQueryDTO queryDTO = new AttendRuleHolidayQueryDTO();
+        queryDTO.setRuleIds(Collections.singletonList(matchRule.getId()));
+        List holidayList = this.attendRuleHolidayManager.query(queryDTO);
+        List tmpHolidayList = BeanCopyUtils.copy((Collection)holidayList, AttendResultRuleHolidayDTO.class);
+        AttendRuleSchedulingQueryDTO schedulingQueryDTO = new AttendRuleSchedulingQueryDTO();
+        schedulingQueryDTO.setRuleIds(Collections.singletonList(matchRule.getId()));
+        List schedulingList = this.attendRuleSchedulingManager.query(schedulingQueryDTO);
+        List tmpSchedulingList = BeanCopyUtils.copy((Collection)schedulingList, AttendResultRuleSchedulingDTO.class);
+        matchRule.setSchedulings(tmpSchedulingList);
+        this.setRuleAttendTime(callContext, matchRule);
+        if (AttendUtil.nowDayIsHoliday((List)tmpHolidayList, (long)callContext.getRuleAttendTime())) {
+            matchRule.setMatchScheduling(null);
+            callContext.setHoliday(true);
+            return Collections.singletonList(matchRule);
+        }
+        return this.setSchedule(callContext.getRuleAttendTime(), callContext.getSignParam().getSignTime(), matchRule);
+    }
+
+    private List<AttendResultRuleDTO> setSchedule(Long attrTime, Long signTime, AttendResultRuleDTO ruleDTO) throws ServiceException {
+        ArrayList<AttendResultRuleDTO> ruleDTOList = new ArrayList<AttendResultRuleDTO>();
+        List schedulingList = ruleDTO.getSchedulings();
+        schedulingList.sort(Comparator.comparingInt(AttendResultRuleSchedulingDTO::getSortValue));
+        if (AttendTypeEnum.FLEXIBLE.getCode().equals(ruleDTO.getType())) {
+            ruleDTO.setMatchScheduling((AttendResultRuleSchedulingDTO)schedulingList.get(0));
+            return Collections.singletonList(ruleDTO);
+        }
+        for (AttendResultRuleSchedulingDTO schedulingDTO : schedulingList) {
+            long startAdaptTime = AttendUtil.getRuleTime((String)schedulingDTO.getStartAdaptTime(), (long)attrTime).getTime();
+            long endAdaptTime = AttendUtil.getRuleTime((String)schedulingDTO.getEndAdaptTime(), (long)attrTime).getTime();
+            if (signTime < startAdaptTime || signTime > endAdaptTime) continue;
+            AttendResultRuleDTO tmpDTO = (AttendResultRuleDTO)BeanCopyUtils.copyProperties((Object)ruleDTO, AttendResultRuleDTO.class);
+            tmpDTO.setMatchScheduling(schedulingDTO);
+            ruleDTOList.add(tmpDTO);
+        }
+        return ruleDTOList;
+    }
+
+    private List<String> queryShotRuleDeviceIds(String shotId) throws DataAccessException {
+        List resultList = this.attendRuleShotManager.queryShotDevice(shotId);
+        return resultList.stream().map(AttendRuleDeviceShotQueryResultDTO::getDeviceId).collect(Collectors.toList());
+    }
+
+    private List<String> queryRuleDeviceIds(String id) throws DataAccessException {
+        AttendRuleDeviceQueryDTO deviceQueryDTO = new AttendRuleDeviceQueryDTO();
+        deviceQueryDTO.setRuleId(id);
+        List resultList = this.attendRuleDeviceManager.query(deviceQueryDTO);
+        return resultList.stream().map(AttendRuleDeviceQueryResultDTO::getDeviceId).collect(Collectors.toList());
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/AttendResultRuleV2ServiceImpl.java

@@ -0,0 +1,298 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendClassManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendClassShotManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendPeriodShotManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendSchedulingManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendShiftManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendShiftPeriodManager
+ *  cn.cloudwalk.biz.intelligent.ninca.config.AttendShiftShotManager
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultRuleService
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultService
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassShotQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassShotQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftGetsDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftGetsResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftPeriodQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftPeriodShotQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftShotQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleSchedulingDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.V2.AttendResultGenClassDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.V2.AttendResultGenPeriodDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.V2.AttendResultGenShiftDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.SchedulingDateTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.AttendUtil
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtil
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtils
+ *  com.alibaba.fastjson.JSON
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.result;
+
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendClassManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendClassShotManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendPeriodShotManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendSchedulingManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendShiftManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendShiftPeriodManager;
+import cn.cloudwalk.biz.intelligent.ninca.config.AttendShiftShotManager;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultRuleService;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultService;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassShotQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.clas.dto.AttendClassShotQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendSchedulingQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftGetsDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftGetsResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftPeriodQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftPeriodShotQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.config.dto.AttendShiftShotQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleSchedulingDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.V2.AttendResultGenClassDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.V2.AttendResultGenPeriodDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.V2.AttendResultGenShiftDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.em.SchedulingDateTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.AttendUtil;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtil;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import com.alibaba.fastjson.JSON;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.List;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+@Service(value="scheduling")
+public class AttendResultRuleV2ServiceImpl
+extends AbstractCloudwalkService
+implements AttendResultRuleService {
+    @Resource
+    private AttendResultService attendResultService;
+    @Resource
+    private AttendClassShotManager attendClassShotManager;
+    @Resource
+    private AttendPeriodShotManager attendPeriodShotManager;
+    @Resource
+    private AttendSchedulingManager attendSchedulingManager;
+    @Resource
+    private AttendClassManager attendClassManager;
+    @Resource
+    private AttendShiftManager attendShiftManager;
+    @Resource
+    private AttendShiftPeriodManager attendShiftPeriodManager;
+    @Resource
+    private AttendShiftShotManager attendShiftShotManager;
+
+    public CloudwalkResult<Boolean> matchRule(AttendResultGenCallContext callContext) throws ServiceException {
+        try {
+            AttendResultGenClassDTO classDTO = this.getClassInfo(callContext);
+            if (classDTO == null) {
+                return CloudwalkResult.fail((String)"76240245", (String)"\u8be5\u6253\u5361\u6ca1\u6709\u5bf9\u5e94\u73ed\u6b21");
+            }
+            AttendResultDTO attendResultDTO = null;
+            if (CollectionUtils.isNotEmpty((Collection)callContext.getResultList())) {
+                attendResultDTO = this.getAttendResult(callContext.getResultList(), classDTO, callContext);
+            }
+            AttendResultRuleDTO ruleDTO = this.convert(classDTO);
+            if (AttendTypeEnum.SCHEDULING.getCode().equals(classDTO.getType()) && attendResultDTO == null) {
+                CloudwalkResult initResult = this.attendResultService.init(callContext, ruleDTO, callContext.getPersonInfoDTO(), callContext.getContext());
+                attendResultDTO = (AttendResultDTO)initResult.getData();
+            }
+            callContext.setResultDTO(attendResultDTO);
+            callContext.setRuleDTO(ruleDTO);
+            return CloudwalkResult.success((Object)true);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u8003\u52e4\u7ed3\u679c\u751f\u6210\uff0c\u67e5\u8be2\u5339\u914d\u8003\u52e4\u89c4\u5219\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private AttendResultRuleDTO convert(AttendResultGenClassDTO classDTO) {
+        AttendResultRuleDTO ruleDTO = (AttendResultRuleDTO)BeanCopyUtils.copyProperties((Object)classDTO, AttendResultRuleDTO.class);
+        List schedulingList = BeanCopyUtils.copy((Collection)classDTO.getPeriods(), AttendResultRuleSchedulingDTO.class);
+        AttendResultRuleSchedulingDTO matchScheduling = (AttendResultRuleSchedulingDTO)BeanCopyUtils.copyProperties((Object)classDTO.getMatchPeriod(), AttendResultRuleSchedulingDTO.class);
+        int beforeTime = matchScheduling.getBeforeTime() == null ? 0 : matchScheduling.getBeforeTime();
+        int afterTime = matchScheduling.getAfterTime() == null ? 0 : matchScheduling.getAfterTime();
+        int overTime = matchScheduling.getOverTime() == null ? 0 : matchScheduling.getOverTime();
+        matchScheduling.setBeforeTime(Integer.valueOf(beforeTime));
+        matchScheduling.setAfterTime(Integer.valueOf(afterTime));
+        matchScheduling.setOverTime(Integer.valueOf(overTime));
+        ruleDTO.setSchedulings(schedulingList);
+        ruleDTO.setMatchScheduling(matchScheduling);
+        ruleDTO.setShiftShotId(classDTO.getShiftDTO().getShotId());
+        return ruleDTO;
+    }
+
+    private AttendResultGenClassDTO getClassInfo(AttendResultGenCallContext callContext) throws DataAccessException, ServiceException {
+        List<Integer> ruleTypes = Collections.singletonList(AttendTypeEnum.SCHEDULING.getCode());
+        List resultList = this.attendResultService.query(callContext, ruleTypes);
+        AttendResultGenClassDTO classDTO = null;
+        if (CollectionUtils.isNotEmpty((Collection)resultList)) {
+            classDTO = this.getShotRuleByResultList(resultList, callContext);
+            this.logger.info("\u8003\u52e4\u7ed3\u679c\u4e0d\u4e3a\u7a7a\uff0c\u83b7\u53d6\u73ed\u7ec4\u4fe1\u606f\uff0c\u7ed3\u679c\uff1a{}", (Object)JSON.toJSONString((Object)classDTO));
+        }
+        if (classDTO == null) {
+            classDTO = this.getRule(callContext);
+            this.logger.info("\u76f4\u63a5\u5339\u914d\u89c4\u5219\uff0c\u83b7\u53d6\u73ed\u7ec4\u4fe1\u606f\uff0c\u7ed3\u679c\uff1a{}", (Object)JSON.toJSONString((Object)classDTO));
+        }
+        callContext.setResultList(resultList);
+        this.logger.info("\u83b7\u53d6\u8003\u52e4\u7ed3\u679c\uff0c\u4e0a\u4e0b\u6587\uff1a{}", (Object)JSON.toJSONString((Object)callContext));
+        return classDTO;
+    }
+
+    private AttendResultGenClassDTO getShotRuleByResultList(List<AttendResultDTO> resultList, AttendResultGenCallContext callContext) throws DataAccessException, ServiceException {
+        AttendResultDTO resultDTO;
+        AttendResultGenClassDTO classDTO = null;
+        resultList.sort(Comparator.comparing(AttendResultDTO::getAttrTime).reversed());
+        Iterator<AttendResultDTO> iterator = resultList.iterator();
+        while (iterator.hasNext() && (classDTO = this.getShotRule(resultDTO = iterator.next(), callContext)) == null) {
+        }
+        return classDTO;
+    }
+
+    private AttendResultDTO getAttendResult(List<AttendResultDTO> resultList, AttendResultGenClassDTO classDTO, AttendResultGenCallContext callContext) {
+        for (AttendResultDTO resultDTO : resultList) {
+            if (!DateUtils.todayStart((Date)new Date(resultDTO.getAttrTime())).equals(DateUtils.todayStart((Date)new Date(callContext.getRuleAttendTime()))) || !resultDTO.getShiftShotId().equals(classDTO.getMatchPeriod().getId())) continue;
+            return resultDTO;
+        }
+        return null;
+    }
+
+    private AttendResultGenClassDTO getShotRule(AttendResultDTO resultDTO, AttendResultGenCallContext callContext) throws DataAccessException, ServiceException {
+        String classShotId = resultDTO.getShotId();
+        AttendClassShotQueryDTO attendClassShotQueryDTO = new AttendClassShotQueryDTO();
+        attendClassShotQueryDTO.setId(classShotId);
+        attendClassShotQueryDTO.setBusinessId(callContext.getSignParam().getBusinessId());
+        List classList = this.attendClassShotManager.query(attendClassShotQueryDTO);
+        AttendClassShotQueryResultDTO classDTO = (AttendClassShotQueryResultDTO)classList.get(0);
+        AttendShiftShotQueryDTO queryDTO = new AttendShiftShotQueryDTO();
+        queryDTO.setId(resultDTO.getShiftShotId());
+        queryDTO.setBusinessId(callContext.getSignParam().getBusinessId());
+        List queryResultList = this.attendShiftShotManager.query(queryDTO);
+        AttendResultGenShiftDTO shiftDTO = (AttendResultGenShiftDTO)BeanCopyUtils.copyProperties(queryResultList.get(0), AttendResultGenShiftDTO.class);
+        String shiftShotId = resultDTO.getShiftShotId();
+        AttendShiftPeriodShotQueryDTO periodShotQueryDTO = new AttendShiftPeriodShotQueryDTO();
+        periodShotQueryDTO.setShotId(shiftShotId);
+        List periodList = this.attendPeriodShotManager.query(periodShotQueryDTO);
+        List genPeriodList = BeanCopyUtils.copy((Collection)periodList, AttendResultGenPeriodDTO.class);
+        AttendResultGenClassDTO genClassDTO = (AttendResultGenClassDTO)BeanCopyUtils.copyProperties((Object)classDTO, AttendResultGenClassDTO.class);
+        genClassDTO.setPeriods(genPeriodList);
+        this.setSchedule(resultDTO.getAttrTime(), callContext.getSignParam().getSignTime(), genClassDTO);
+        if (genClassDTO.getMatchPeriod() == null) {
+            return null;
+        }
+        callContext.setRuleAttendTime(resultDTO.getAttrTime());
+        genClassDTO.setShiftDTO(shiftDTO);
+        return genClassDTO;
+    }
+
+    private AttendResultGenClassDTO getRule(AttendResultGenCallContext callContext) throws DataAccessException, ServiceException {
+        Long signTime = callContext.getSignParam().getSignTime();
+        AttendResultGenClassDTO classDTO = this.getRule(callContext, signTime);
+        if (classDTO == null || classDTO.getMatchPeriod() == null) {
+            Date beforeDay = DateUtil.addDays((Date)new Date(signTime), (int)-1);
+            return this.getRule(callContext, beforeDay.getTime());
+        }
+        return classDTO;
+    }
+
+    private AttendResultGenClassDTO getRule(AttendResultGenCallContext callContext, Long conditionDate) throws DataAccessException, ServiceException {
+        AttendSchedulingQueryDTO queryDTO = new AttendSchedulingQueryDTO();
+        queryDTO.setBusinessId(callContext.getSignParam().getBusinessId());
+        queryDTO.setPersonId(callContext.getPersonInfoDTO().getId());
+        queryDTO.setSchedulingDate(DateUtils.todayStart((Date)new Date(conditionDate)));
+        queryDTO.setIsPublish(YesNoTypeEnum.Y.getCode());
+        List schedulingList = this.attendSchedulingManager.queryList(queryDTO);
+        if (CollectionUtils.isEmpty((Collection)schedulingList)) {
+            this.logger.info("\u5f53\u524d\u4eba\u5458\u6ca1\u6709\u6392\u73ed,personId:{}", (Object)callContext.getPersonInfoDTO().getId());
+            return null;
+        }
+        schedulingList.sort(Comparator.comparing(AttendSchedulingQueryResultDTO::getLastUpdateTime).reversed());
+        AttendSchedulingQueryResultDTO schedulingQueryResultDTO = (AttendSchedulingQueryResultDTO)schedulingList.get(0);
+        AttendClassQueryDTO classQueryDTO = new AttendClassQueryDTO();
+        classQueryDTO.setId(schedulingQueryResultDTO.getClassId());
+        List classQueryResult = this.attendClassManager.query(classQueryDTO);
+        if (CollectionUtils.isEmpty((Collection)classQueryResult)) {
+            this.logger.info("\u73ed\u7ec4\u4e0d\u5b58\u5728");
+            return null;
+        }
+        if (YesNoTypeEnum.N.getCode().equals(classQueryDTO.getIsEnable()) || YesNoTypeEnum.N.getCode().equals(classQueryDTO.getStatus())) {
+            this.logger.info("\u73ed\u7ec4\u4e0d\u53ef\u7528\u6216\u8005\u5df2\u5220\u9664\uff0c\u73ed\u7ec4id{}", (Object)classQueryDTO.getId());
+            return null;
+        }
+        AttendShiftGetsDTO getsDTO = new AttendShiftGetsDTO();
+        getsDTO.setId(schedulingQueryResultDTO.getShiftId());
+        getsDTO.setBusinessId(callContext.getSignParam().getBusinessId());
+        List getsList = this.attendShiftManager.gets(getsDTO);
+        if (CollectionUtils.isEmpty((Collection)getsList)) {
+            this.logger.info("\u73ed\u79cd\u4e0d\u5b58\u5728");
+            return null;
+        }
+        AttendShiftGetsResultDTO shiftGetsResultDTO = (AttendShiftGetsResultDTO)getsList.get(0);
+        if (YesNoTypeEnum.N.getCode().equals(shiftGetsResultDTO.getIsEnable()) || YesNoTypeEnum.N.getCode().equals(shiftGetsResultDTO.getStatus())) {
+            this.logger.info("\u73ed\u79cd\u4e0d\u53ef\u7528\u6216\u8005\u5df2\u5220\u9664\uff0c\u73ed\u79cdid\uff1a{}", (Object)shiftGetsResultDTO.getId());
+            return null;
+        }
+        if (!SchedulingDateTypeEnum.WORK_DAY.getCode().equals(shiftGetsResultDTO.getShiftType())) {
+            this.logger.info("\u5f53\u5929\u662f\u4f11\u606f\u65e5\uff0c\u4e0d\u7528\u8003\u52e4");
+            return null;
+        }
+        AttendResultGenClassDTO genClassDTO = (AttendResultGenClassDTO)BeanCopyUtils.copyProperties(classQueryResult.get(0), AttendResultGenClassDTO.class);
+        AttendShiftPeriodQueryDTO periodQueryDTO = new AttendShiftPeriodQueryDTO();
+        periodQueryDTO.setShiftId(shiftGetsResultDTO.getId());
+        List periodList = this.attendShiftPeriodManager.query(periodQueryDTO);
+        List periods = BeanCopyUtils.copy((Collection)periodList, AttendResultGenPeriodDTO.class);
+        genClassDTO.setPeriods(periods);
+        callContext.setRuleAttendTime(conditionDate);
+        this.setSchedule(callContext.getRuleAttendTime(), callContext.getSignParam().getSignTime(), genClassDTO);
+        if (genClassDTO.getMatchPeriod() == null) {
+            return null;
+        }
+        genClassDTO.setShiftDTO((AttendResultGenShiftDTO)BeanCopyUtils.copyProperties((Object)shiftGetsResultDTO, AttendResultGenShiftDTO.class));
+        return genClassDTO;
+    }
+
+    private void setSchedule(Long attrTime, Long signTime, AttendResultGenClassDTO classDTO) throws ServiceException {
+        List periodList = classDTO.getPeriods();
+        periodList.sort(Comparator.comparingInt(AttendResultGenPeriodDTO::getSortValue));
+        for (AttendResultGenPeriodDTO periodDTO : periodList) {
+            long startAdaptTime = AttendUtil.getRuleTime((String)periodDTO.getStartAdaptTime(), (long)attrTime).getTime();
+            long endAdaptTime = AttendUtil.getRuleTime((String)periodDTO.getEndAdaptTime(), (long)attrTime).getTime();
+            if (signTime < startAdaptTime || signTime > endAdaptTime) continue;
+            classDTO.setMatchPeriod(periodDTO);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/AttendResultSchedulingGenServiceImpl.java

@@ -0,0 +1,43 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultSchedulingGenService
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.result;
+
+import cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultSchedulingGenService;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import cn.cloudwalk.service.ninca.attendance.result.handle.scheduling.AttendResultSchedulingEndEarlyHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.scheduling.AttendResultSchedulingEndNormalHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.scheduling.AttendResultSchedulingStartLateHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.scheduling.AttendResultSchedulingStartNormalHandle;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendResultSchedulingGenServiceImpl
+extends AbstractCloudwalkService
+implements AttendResultSchedulingGenService {
+    public void execute(AttendResultGenCallContext callContext) throws ServiceException {
+        this.handle(callContext);
+    }
+
+    private void handle(AttendResultGenCallContext callContext) throws ServiceException {
+        AttendResultSchedulingStartLateHandle startLateHandle = new AttendResultSchedulingStartLateHandle();
+        AttendResultSchedulingStartNormalHandle startNormalHandle = new AttendResultSchedulingStartNormalHandle();
+        AttendResultSchedulingEndEarlyHandle endEarlyHandle = new AttendResultSchedulingEndEarlyHandle();
+        AttendResultSchedulingEndNormalHandle endNormalHandle = new AttendResultSchedulingEndNormalHandle();
+        startLateHandle.nextHandle(startNormalHandle);
+        startNormalHandle.nextHandle(endEarlyHandle);
+        endEarlyHandle.nextHandle(endNormalHandle);
+        startLateHandle.exec((AbstractAttendResultGenCallContext)callContext);
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/AttendResultServiceImpl.java

@@ -0,0 +1,217 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.result.AttendRecordManager
+ *  cn.cloudwalk.biz.intelligent.ninca.result.AttendResultManager
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendRecordDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultMatchRuleQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultPersonInfoDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleSchedulingDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultSchedulingQueryResult
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.AttendUtil
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtil
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Repository
+ */
+package cn.cloudwalk.service.ninca.attendance.result;
+
+import cn.cloudwalk.biz.intelligent.ninca.result.AttendRecordManager;
+import cn.cloudwalk.biz.intelligent.ninca.result.AttendResultManager;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendRecordDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultMatchRuleQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultPersonInfoDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleSchedulingDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultSchedulingQueryResult;
+import cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum;
+import cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.AttendUtil;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtil;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.Date;
+import java.util.List;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class AttendResultServiceImpl
+extends AbstractCloudwalkService
+implements AttendResultService {
+    @Resource
+    private AttendResultManager attendResultManager;
+    @Resource
+    private AttendRecordManager attendRecordManager;
+
+    public CloudwalkResult<AttendResultDTO> init(AttendResultGenCallContext callContext, AttendResultRuleDTO ruleDTO, AttendResultPersonInfoDTO personInfoDTO, CloudwalkCallContext context) throws ServiceException {
+        try {
+            AttendResultDTO attendResultDTO = this.setAttendResultDTO(callContext.getSignParam(), callContext.getRuleAttendTime(), ruleDTO, personInfoDTO, context);
+            this.attendResultManager.insert(attendResultDTO);
+            return CloudwalkResult.success((Object)attendResultDTO);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u521d\u59cb\u5316\u8003\u52e4\u7ed3\u679c\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private AttendResultDTO setAttendResultDTO(AttendResultSignParam signParam, long ruleAttendTime, AttendResultRuleDTO ruleDTO, AttendResultPersonInfoDTO personInfoDTO, CloudwalkCallContext context) throws ServiceException {
+        AttendResultDTO attendResultDTO = new AttendResultDTO();
+        attendResultDTO.setId(this.genUUID());
+        attendResultDTO.setBusinessId(signParam.getBusinessId());
+        attendResultDTO.setRuleId(ruleDTO.getId());
+        attendResultDTO.setRuleName(ruleDTO.getName());
+        attendResultDTO.setRuleType(ruleDTO.getType());
+        attendResultDTO.setOrgId(personInfoDTO.getOrgId() == null ? "" : personInfoDTO.getOrgId());
+        attendResultDTO.setOrgName(personInfoDTO.getOrgName() == null ? "" : personInfoDTO.getOrgName());
+        attendResultDTO.setPersonId(personInfoDTO.getId());
+        attendResultDTO.setPersonName(personInfoDTO.getName());
+        attendResultDTO.setDeviceId(signParam.getDeviceId());
+        attendResultDTO.setDeviceName(signParam.getDeviceName());
+        attendResultDTO.setAttrTime(DateUtils.todayStart((Date)new Date(ruleAttendTime)));
+        attendResultDTO.setStartworkTime(null);
+        attendResultDTO.setEndworkTime(null);
+        AttendResultRuleSchedulingDTO scheduling = ruleDTO.getMatchScheduling();
+        if (scheduling != null) {
+            attendResultDTO.setSchedulingId(scheduling.getId() == null ? "" : scheduling.getId());
+            attendResultDTO.setSchedulingDesc(scheduling.getSchedulingDesc() == null ? "" : scheduling.getSchedulingDesc());
+            if ((AttendTypeEnum.STANDARD.getCode().equals(ruleDTO.getType()) || AttendTypeEnum.SCHEDULING.getCode().equals(ruleDTO.getType())) && scheduling.getStartworkTime() != null && scheduling.getEndworkTime() != null) {
+                long ruleStartworkTime = AttendUtil.getRuleTime((String)scheduling.getStartworkTime(), (long)ruleAttendTime).getTime();
+                long ruleEndworkTime = AttendUtil.getRuleTime((String)scheduling.getEndworkTime(), (long)ruleAttendTime).getTime();
+                attendResultDTO.setRuleStartworkTime(Long.valueOf(ruleStartworkTime));
+                attendResultDTO.setRuleEndworkTime(Long.valueOf(ruleEndworkTime));
+            }
+        } else {
+            attendResultDTO.setSchedulingId("");
+            attendResultDTO.setSchedulingDesc("");
+        }
+        attendResultDTO.setStartStatus(AttendResultStatusEnum.UN_SIGN_IN.getCode());
+        attendResultDTO.setEndStatus(AttendResultStatusEnum.UN_SIGN_IN.getCode());
+        attendResultDTO.setStatus(YesNoTypeEnum.Y.getCode());
+        long nowTime = System.currentTimeMillis();
+        attendResultDTO.setCreateTime(Long.valueOf(nowTime));
+        attendResultDTO.setCreateUserId(null);
+        attendResultDTO.setLastUpdateTime(Long.valueOf(nowTime));
+        attendResultDTO.setLastUpdateUserId(null);
+        attendResultDTO.setShotId(ruleDTO.getShotId());
+        attendResultDTO.setShiftShotId(ruleDTO.getShiftShotId());
+        return attendResultDTO;
+    }
+
+    public int update(AttendResultDTO attendResultDTO) throws ServiceException {
+        try {
+            return this.attendResultManager.update(attendResultDTO);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u66f4\u65b0\u8003\u52e4\u7ed3\u679c\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public List<AttendResultDTO> query(AttendResultGenCallContext callContext, List<Integer> types) throws DataAccessException {
+        try {
+            AttendResultSignParam signParam = callContext.getSignParam();
+            AttendResultQueryDTO queryDTO = new AttendResultQueryDTO();
+            queryDTO.setPersonId(callContext.getPersonInfoDTO().getId());
+            Date startDate = DateUtil.addDays((Date)new Date(signParam.getSignTime()), (int)-1);
+            queryDTO.setStartTime(DateUtils.todayStart((Date)startDate));
+            queryDTO.setEndTime(DateUtils.todayEnd((Date)new Date(signParam.getSignTime())));
+            queryDTO.setBusinessId(callContext.getSignParam().getBusinessId());
+            queryDTO.setRuleTypes(types);
+            return this.attendResultManager.query(queryDTO);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u67e5\u8be2\u4eba\u5458\u8003\u52e4\u7ed3\u679c\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new DataAccessException((Throwable)e);
+        }
+    }
+
+    public AttendResultRuleDTO queryMatchRule(AttendResultMatchRuleQueryDTO ruleQueryDTO) throws ServiceException {
+        try {
+            return this.attendResultManager.queryMatchRule(ruleQueryDTO);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u67e5\u8be2\u5339\u914d\u7684\u8003\u52e4\u89c4\u5219\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public AttendResultRuleDTO queryMatchRuleById(AttendResultSchedulingQueryResult queryResult) throws ServiceException {
+        try {
+            return this.attendResultManager.queryMatchRuleById(queryResult);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u67e5\u8be2\u8003\u52e4\u89c4\u5219\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public String initRecord(AttendResultGenCallContext callContext) throws ServiceException {
+        try {
+            AttendRecordDTO attendRecordDTO = this.setAttendRecordDTO(callContext);
+            this.attendRecordManager.add(attendRecordDTO);
+            return attendRecordDTO.getId();
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u751f\u6210\u8003\u52e4\u8bb0\u5f55\u6d41\u6c34\u5931\u8d25\uff0c\u539f\u56e0:", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private AttendRecordDTO setAttendRecordDTO(AttendResultGenCallContext callContext) {
+        AttendResultSignParam signParam = callContext.getSignParam();
+        AttendResultPersonInfoDTO personInfoDTO = callContext.getPersonInfoDTO();
+        AttendRecordDTO attendRecordDTO = new AttendRecordDTO();
+        attendRecordDTO.setId(this.genUUID());
+        attendRecordDTO.setPersonId(callContext.getPersonInfoDTO().getId());
+        attendRecordDTO.setBusinessId(signParam.getBusinessId());
+        attendRecordDTO.setOrgId(personInfoDTO.getOrgId() == null ? "" : personInfoDTO.getOrgId());
+        attendRecordDTO.setOrgName(personInfoDTO.getOrgName() == null ? "" : personInfoDTO.getOrgName());
+        attendRecordDTO.setDeviceId(signParam.getDeviceId());
+        attendRecordDTO.setSignTime(signParam.getSignTime());
+        String faceUrl = signParam.getFaceUrl() == null ? personInfoDTO.getRegFaceUrl() : signParam.getFaceUrl();
+        attendRecordDTO.setFaceUrl(faceUrl == null ? "" : faceUrl);
+        attendRecordDTO.setSpotImgPath(signParam.getSpotImgPath());
+        attendRecordDTO.setPanoramaPath(signParam.getPanoramaPath());
+        attendRecordDTO.setScore(signParam.getScore());
+        attendRecordDTO.setStatus(signParam.getStatus());
+        attendRecordDTO.setThreshold(signParam.getThreshold());
+        attendRecordDTO.setRemark(signParam.getRemark());
+        long nowTime = System.currentTimeMillis();
+        attendRecordDTO.setCreateTime(Long.valueOf(nowTime));
+        attendRecordDTO.setLastUpdateTime(Long.valueOf(nowTime));
+        attendRecordDTO.setDeviceCode(signParam.getDeviceCode());
+        attendRecordDTO.setDeviceAreaId(signParam.getDeviceAreaId());
+        attendRecordDTO.setDeviceAreaName(signParam.getDeviceAreaName());
+        attendRecordDTO.setDeviceName(signParam.getDeviceName());
+        attendRecordDTO.setPersonName(personInfoDTO.getName());
+        attendRecordDTO.setDistrictMergeName(signParam.getDistrictMergeName());
+        return attendRecordDTO;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/AttendResultStandardGenServiceImpl.java

@@ -0,0 +1,49 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.service.AttendResultStandardGenService
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.result;
+
+import cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.service.AttendResultStandardGenService;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import cn.cloudwalk.service.ninca.attendance.result.handle.stand.AttendResultEndEarlyHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.stand.AttendResultEndNormalHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.stand.AttendResultEndOverTimeHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.stand.AttendResultStartLateHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.stand.AttendResultStartNormalHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.stand.AttendResultStartOverTimeHandle;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendResultStandardGenServiceImpl
+extends AbstractCloudwalkService
+implements AttendResultStandardGenService {
+    public void execute(AttendResultGenCallContext callContext) throws ServiceException {
+        this.handle(callContext);
+    }
+
+    private void handle(AttendResultGenCallContext callContext) throws ServiceException {
+        AttendResultStartOverTimeHandle startOverTimeHandle = new AttendResultStartOverTimeHandle();
+        AttendResultStartLateHandle startLateHandle = new AttendResultStartLateHandle();
+        AttendResultStartNormalHandle startNormalHandle = new AttendResultStartNormalHandle();
+        AttendResultEndOverTimeHandle endOverTimeHandle = new AttendResultEndOverTimeHandle();
+        AttendResultEndEarlyHandle endEarlyHandle = new AttendResultEndEarlyHandle();
+        AttendResultEndNormalHandle endNormalHandle = new AttendResultEndNormalHandle();
+        startOverTimeHandle.nextHandle(startLateHandle);
+        startLateHandle.nextHandle(startNormalHandle);
+        startNormalHandle.nextHandle(endOverTimeHandle);
+        endOverTimeHandle.nextHandle(endEarlyHandle);
+        endEarlyHandle.nextHandle(endNormalHandle);
+        startOverTimeHandle.exec((AbstractAttendResultGenCallContext)callContext);
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/handle/AbstractAttendResultHandle.java

@@ -0,0 +1,34 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ */
+package cn.cloudwalk.service.ninca.attendance.result.handle;
+
+import cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+
+public abstract class AbstractAttendResultHandle
+extends AbstractCloudwalkService {
+    private AbstractAttendResultHandle nextHandle;
+    protected static final Long MI_MILL = 60000L;
+
+    public abstract void handle(AbstractAttendResultGenCallContext var1) throws ServiceException;
+
+    public void exec(AbstractAttendResultGenCallContext callContext) throws ServiceException {
+        this.handle(callContext);
+        if (this.nextHandle != null) {
+            this.nextHandle.exec(callContext);
+        } else {
+            this.logger.info("\u5df2\u7ecf\u662f\u6700\u540e\u4e00\u4e2ahandle");
+        }
+    }
+
+    public void nextHandle(AbstractAttendResultHandle nextHandle) {
+        this.nextHandle = nextHandle;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/handle/flexibility/AttendResultFlexEndEarlyHandle.java

@@ -0,0 +1,63 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum
+ */
+package cn.cloudwalk.service.ninca.attendance.result.handle.flexibility;
+
+import cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum;
+import cn.cloudwalk.service.ninca.attendance.result.handle.AbstractAttendResultHandle;
+
+public class AttendResultFlexEndEarlyHandle
+extends AbstractAttendResultHandle {
+    @Override
+    public void handle(AbstractAttendResultGenCallContext callContext) throws ServiceException {
+        this.logger.info("\u5904\u7406\u5f39\u6027\u8003\u52e4\u7ed3\u679c\u662f\u5426\u662f\u4e0b\u73ed\u65e9\u9000");
+        try {
+            AttendResultGenCallContext attendResultGenCallContext = (AttendResultGenCallContext)callContext;
+            AttendResultSignParam signParam = attendResultGenCallContext.getSignParam();
+            AttendResultDTO resultDTO = attendResultGenCallContext.getResultDTO();
+            AttendResultRuleDTO ruleDTO = attendResultGenCallContext.getRuleDTO();
+            if (this.signValid(signParam, resultDTO, ruleDTO, attendResultGenCallContext.isHoliday()) && this.signLate(signParam, ruleDTO, resultDTO)) {
+                resultDTO.setEndStatus(AttendResultStatusEnum.LEAVE_EARLY.getCode());
+                resultDTO.setEndworkTime(signParam.getSignTime());
+                this.nextHandle(null);
+            }
+        }
+        catch (Exception e) {
+            this.logger.error("\u8003\u52e4\u7ed3\u679c\u751f\u6210\uff0c\u5224\u65ad\u662f\u5426\u662f\u4e0b\u73ed\u65e9\u9000\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private boolean signValid(AttendResultSignParam signParam, AttendResultDTO resultDTO, AttendResultRuleDTO ruleDTO, boolean isHoliday) {
+        if (isHoliday) {
+            return false;
+        }
+        if (resultDTO.getStartworkTime() == null) {
+            return false;
+        }
+        if (resultDTO.getEndworkTime() == null) {
+            return true;
+        }
+        return signParam.getSignTime() > resultDTO.getEndworkTime();
+    }
+
+    private boolean signLate(AttendResultSignParam signParam, AttendResultRuleDTO ruleDTO, AttendResultDTO resultDTO) {
+        return signParam.getSignTime() - resultDTO.getStartworkTime() < (long)(ruleDTO.getMatchScheduling().getStandardTime() * 60 * 1000);
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/handle/flexibility/AttendResultFlexEndNormalHandle.java

@@ -0,0 +1,63 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum
+ */
+package cn.cloudwalk.service.ninca.attendance.result.handle.flexibility;
+
+import cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum;
+import cn.cloudwalk.service.ninca.attendance.result.handle.AbstractAttendResultHandle;
+
+public class AttendResultFlexEndNormalHandle
+extends AbstractAttendResultHandle {
+    @Override
+    public void handle(AbstractAttendResultGenCallContext callContext) throws ServiceException {
+        this.logger.info("\u5904\u7406\u5f39\u6027\u8003\u52e4\u7ed3\u679c\u662f\u5426\u662f\u4e0b\u73ed\u6b63\u5e38");
+        try {
+            AttendResultGenCallContext attendResultGenCallContext = (AttendResultGenCallContext)callContext;
+            AttendResultSignParam signParam = attendResultGenCallContext.getSignParam();
+            AttendResultDTO resultDTO = attendResultGenCallContext.getResultDTO();
+            AttendResultRuleDTO ruleDTO = attendResultGenCallContext.getRuleDTO();
+            if (this.signValid(signParam, resultDTO, ruleDTO, attendResultGenCallContext.isHoliday()) && this.signNormal(signParam, ruleDTO, resultDTO)) {
+                resultDTO.setEndStatus(AttendResultStatusEnum.NORMAL.getCode());
+                resultDTO.setEndworkTime(signParam.getSignTime());
+                this.nextHandle(null);
+            }
+        }
+        catch (Exception e) {
+            this.logger.error("\u8003\u52e4\u7ed3\u679c\u751f\u6210\uff0c\u5224\u65ad\u662f\u5426\u662f\u4e0b\u73ed\u6b63\u5e38\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private boolean signValid(AttendResultSignParam signParam, AttendResultDTO resultDTO, AttendResultRuleDTO ruleDTO, boolean isHoliday) {
+        if (isHoliday) {
+            return false;
+        }
+        if (resultDTO.getStartworkTime() == null) {
+            return false;
+        }
+        if (resultDTO.getEndworkTime() == null) {
+            return true;
+        }
+        return signParam.getSignTime() > resultDTO.getEndworkTime();
+    }
+
+    private boolean signNormal(AttendResultSignParam signParam, AttendResultRuleDTO ruleDTO, AttendResultDTO resultDTO) {
+        return signParam.getSignTime() - resultDTO.getStartworkTime() >= (long)(ruleDTO.getMatchScheduling().getStandardTime() * 60 * 1000);
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/handle/flexibility/AttendResultFlexEndOverTimeHandle.java

@@ -0,0 +1,71 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.DateTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.AttendUtil
+ */
+package cn.cloudwalk.service.ninca.attendance.result.handle.flexibility;
+
+import cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum;
+import cn.cloudwalk.common.ninca.attendance.em.DateTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.AttendUtil;
+import cn.cloudwalk.service.ninca.attendance.result.handle.AbstractAttendResultHandle;
+
+public class AttendResultFlexEndOverTimeHandle
+extends AbstractAttendResultHandle {
+    @Override
+    public void handle(AbstractAttendResultGenCallContext callContext) throws ServiceException {
+        this.logger.info("\u5904\u7406\u5f39\u6027\u8003\u52e4\u7ed3\u679c \u662f\u5426\u662f\u4e0b\u73ed\u52a0\u73ed");
+        try {
+            AttendResultGenCallContext attendResultGenCallContext = (AttendResultGenCallContext)callContext;
+            AttendResultSignParam signParam = attendResultGenCallContext.getSignParam();
+            AttendResultDTO resultDTO = attendResultGenCallContext.getResultDTO();
+            AttendResultRuleDTO ruleDTO = attendResultGenCallContext.getRuleDTO();
+            if (this.signValid(signParam, resultDTO, ruleDTO, attendResultGenCallContext.isHoliday())) {
+                resultDTO.setEndStatus(AttendResultStatusEnum.NORMAL.getCode());
+                resultDTO.setEndworkTime(signParam.getSignTime());
+                resultDTO.setDateType(DateTypeEnum.HOLIDAY.getCode());
+                int overTime = 0;
+                if (YesNoTypeEnum.Y.getCode().equals(ruleDTO.getAllowDayoffOvertime())) {
+                    overTime = AttendUtil.calculateDayoffOverTime((AttendResultRuleDTO)ruleDTO, (AttendResultDTO)resultDTO);
+                }
+                resultDTO.setOvertime(Integer.valueOf(overTime));
+                this.nextHandle(null);
+            }
+        }
+        catch (Exception e) {
+            this.logger.error("\u8003\u52e4\u7ed3\u679c\u751f\u6210\uff0c\u5224\u65ad\u662f\u5426\u662f\u4e0b\u73ed\u52a0\u73ed\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private boolean signValid(AttendResultSignParam signParam, AttendResultDTO resultDTO, AttendResultRuleDTO ruleDTO, boolean isHoliday) {
+        if (!isHoliday) {
+            return false;
+        }
+        if (resultDTO.getStartworkTime() == null) {
+            return false;
+        }
+        if (resultDTO.getEndworkTime() == null) {
+            return true;
+        }
+        return signParam.getSignTime() > resultDTO.getEndworkTime();
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/handle/flexibility/AttendResultFlexStartNormalHandle.java

@@ -0,0 +1,65 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum
+ */
+package cn.cloudwalk.service.ninca.attendance.result.handle.flexibility;
+
+import cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum;
+import cn.cloudwalk.service.ninca.attendance.result.handle.AbstractAttendResultHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.flexibility.AttendResultFlexEndEarlyHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.flexibility.AttendResultFlexEndNormalHandle;
+
+public class AttendResultFlexStartNormalHandle
+extends AbstractAttendResultHandle {
+    @Override
+    public void handle(AbstractAttendResultGenCallContext callContext) throws ServiceException {
+        this.logger.info("\u5904\u7406\u5f39\u6027\u8003\u52e4\u7ed3\u679c\u662f\u5426\u662f\u4e0a\u73ed\u6b63\u5e38");
+        try {
+            AttendResultGenCallContext attendResultGenCallContext = (AttendResultGenCallContext)callContext;
+            AttendResultSignParam signParam = attendResultGenCallContext.getSignParam();
+            AttendResultDTO resultDTO = attendResultGenCallContext.getResultDTO();
+            AttendResultRuleDTO ruleDTO = attendResultGenCallContext.getRuleDTO();
+            if (this.signValid(signParam, resultDTO, ruleDTO, attendResultGenCallContext.isHoliday())) {
+                long lastTime = resultDTO.getStartworkTime() != null ? resultDTO.getStartworkTime() : 0L;
+                resultDTO.setStartStatus(AttendResultStatusEnum.NORMAL.getCode());
+                resultDTO.setStartworkTime(signParam.getSignTime());
+                this.nextHandle(null);
+                if (lastTime != 0L) {
+                    signParam.setSignTime(Long.valueOf(lastTime));
+                    AttendResultFlexEndNormalHandle endNormalHandle = new AttendResultFlexEndNormalHandle();
+                    endNormalHandle.nextHandle(new AttendResultFlexEndEarlyHandle());
+                    endNormalHandle.exec(callContext);
+                }
+            }
+        }
+        catch (Exception e) {
+            this.logger.error("\u8003\u52e4\u7ed3\u679c\u751f\u6210\uff0c\u5224\u65ad\u662f\u5426\u662f\u4e0a\u73ed\u6b63\u5e38\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private boolean signValid(AttendResultSignParam signParam, AttendResultDTO resultDTO, AttendResultRuleDTO ruleDTO, boolean isHoliday) {
+        if (isHoliday) {
+            return false;
+        }
+        if (resultDTO.getStartworkTime() == null) {
+            return true;
+        }
+        return signParam.getSignTime() < resultDTO.getStartworkTime();
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/handle/flexibility/AttendResultFlexStartOverTimeHandle.java

@@ -0,0 +1,66 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.DateTypeEnum
+ */
+package cn.cloudwalk.service.ninca.attendance.result.handle.flexibility;
+
+import cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum;
+import cn.cloudwalk.common.ninca.attendance.em.DateTypeEnum;
+import cn.cloudwalk.service.ninca.attendance.result.handle.AbstractAttendResultHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.flexibility.AttendResultFlexEndOverTimeHandle;
+
+public class AttendResultFlexStartOverTimeHandle
+extends AbstractAttendResultHandle {
+    @Override
+    public void handle(AbstractAttendResultGenCallContext callContext) throws ServiceException {
+        this.logger.info("\u5904\u7406\u5f39\u6027\u8003\u52e4\u7ed3\u679c\u662f\u5426\u662f\u4e0a\u73ed\u52a0\u73ed");
+        try {
+            AttendResultGenCallContext attendResultGenCallContext = (AttendResultGenCallContext)callContext;
+            AttendResultSignParam signParam = attendResultGenCallContext.getSignParam();
+            AttendResultDTO resultDTO = attendResultGenCallContext.getResultDTO();
+            AttendResultRuleDTO ruleDTO = attendResultGenCallContext.getRuleDTO();
+            if (this.signValid(signParam, resultDTO, ruleDTO, attendResultGenCallContext.isHoliday())) {
+                long lastTime = resultDTO.getStartworkTime() != null ? resultDTO.getStartworkTime() : 0L;
+                resultDTO.setStartStatus(AttendResultStatusEnum.NORMAL.getCode());
+                resultDTO.setStartworkTime(signParam.getSignTime());
+                resultDTO.setDateType(DateTypeEnum.HOLIDAY.getCode());
+                this.nextHandle(null);
+                if (lastTime != 0L) {
+                    signParam.setSignTime(Long.valueOf(lastTime));
+                    AttendResultFlexEndOverTimeHandle endOverTimeHandle = new AttendResultFlexEndOverTimeHandle();
+                    endOverTimeHandle.exec(callContext);
+                }
+            }
+        }
+        catch (Exception e) {
+            this.logger.error("\u8003\u52e4\u7ed3\u679c\u751f\u6210\uff0c\u5224\u65ad\u662f\u5426\u662f\u4e0a\u73ed\u52a0\u73ed\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private boolean signValid(AttendResultSignParam signParam, AttendResultDTO resultDTO, AttendResultRuleDTO ruleDTO, boolean isHoliday) {
+        if (!isHoliday) {
+            return false;
+        }
+        if (resultDTO.getStartworkTime() == null) {
+            return true;
+        }
+        return signParam.getSignTime() < resultDTO.getStartworkTime();
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/handle/scheduling/AttendResultSchedulingEndEarlyHandle.java

@@ -0,0 +1,66 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.AttendUtil
+ */
+package cn.cloudwalk.service.ninca.attendance.result.handle.scheduling;
+
+import cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum;
+import cn.cloudwalk.common.ninca.attendance.util.AttendUtil;
+import cn.cloudwalk.service.ninca.attendance.result.handle.AbstractAttendResultHandle;
+
+public class AttendResultSchedulingEndEarlyHandle
+extends AbstractAttendResultHandle {
+    @Override
+    public void handle(AbstractAttendResultGenCallContext callContext) throws ServiceException {
+        this.logger.info("\u5904\u7406\u6392\u73ed\u8003\u52e4\u7ed3\u679c\u662f\u5426\u662f\u4e0b\u73ed\u65e9\u9000");
+        try {
+            AttendResultGenCallContext attendResultGenCallContext = (AttendResultGenCallContext)callContext;
+            AttendResultSignParam signParam = attendResultGenCallContext.getSignParam();
+            AttendResultDTO resultDTO = attendResultGenCallContext.getResultDTO();
+            AttendResultRuleDTO ruleDTO = attendResultGenCallContext.getRuleDTO();
+            if (this.signValid(signParam, resultDTO, ruleDTO, attendResultGenCallContext.isHoliday()) && this.signLeaveEarly(signParam, ruleDTO, attendResultGenCallContext.getRuleAttendTime())) {
+                resultDTO.setEndStatus(AttendResultStatusEnum.LEAVE_EARLY.getCode());
+                resultDTO.setEndworkTime(signParam.getSignTime());
+                this.nextHandle(null);
+            }
+        }
+        catch (Exception e) {
+            this.logger.error("\u8003\u52e4\u7ed3\u679c\u751f\u6210\uff0c\u5224\u65ad\u662f\u5426\u662f\u4e0b\u73ed\u65e9\u9000\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private boolean signValid(AttendResultSignParam signParam, AttendResultDTO resultDTO, AttendResultRuleDTO ruleDTO, boolean isHoliday) {
+        if (isHoliday) {
+            return false;
+        }
+        if (resultDTO.getStartworkTime() == null && signParam.getSignTime() < resultDTO.getRuleEndworkTime() - (long)ruleDTO.getMatchScheduling().getBeforeTime().intValue() * MI_MILL) {
+            return false;
+        }
+        if (resultDTO.getEndworkTime() == null) {
+            return true;
+        }
+        return signParam.getSignTime() > resultDTO.getEndworkTime();
+    }
+
+    private boolean signLeaveEarly(AttendResultSignParam signParam, AttendResultRuleDTO ruleDTO, Long attendTime) throws ServiceException {
+        int beforeTime = ruleDTO.getMatchScheduling().getBeforeTime() == null ? 0 : ruleDTO.getMatchScheduling().getBeforeTime();
+        return signParam.getSignTime() - AttendUtil.getRuleTime((String)ruleDTO.getMatchScheduling().getEndworkTime(), (long)attendTime).getTime() + (long)(beforeTime * 60 * 1000) < 0L;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/handle/scheduling/AttendResultSchedulingEndNormalHandle.java

@@ -0,0 +1,73 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.AttendUtil
+ */
+package cn.cloudwalk.service.ninca.attendance.result.handle.scheduling;
+
+import cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum;
+import cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.AttendUtil;
+import cn.cloudwalk.service.ninca.attendance.result.handle.AbstractAttendResultHandle;
+
+public class AttendResultSchedulingEndNormalHandle
+extends AbstractAttendResultHandle {
+    @Override
+    public void handle(AbstractAttendResultGenCallContext callContext) throws ServiceException {
+        this.logger.info("\u5904\u7406\u6392\u73ed\u8003\u52e4\u7ed3\u679c\u662f\u5426\u662f\u4e0b\u73ed\u6b63\u5e38");
+        try {
+            AttendResultGenCallContext attendResultGenCallContext = (AttendResultGenCallContext)callContext;
+            AttendResultSignParam signParam = attendResultGenCallContext.getSignParam();
+            AttendResultDTO resultDTO = attendResultGenCallContext.getResultDTO();
+            AttendResultRuleDTO ruleDTO = attendResultGenCallContext.getRuleDTO();
+            if (this.signValid(signParam, resultDTO, ruleDTO, attendResultGenCallContext.isHoliday()) && this.signNormal(signParam, ruleDTO, attendResultGenCallContext.getRuleAttendTime())) {
+                resultDTO.setEndStatus(AttendResultStatusEnum.NORMAL.getCode());
+                resultDTO.setEndworkTime(signParam.getSignTime());
+                int overTime = 0;
+                if (YesNoTypeEnum.Y.getCode().equals(ruleDTO.getAllowWorkingOvertime())) {
+                    overTime = AttendUtil.calculateOverTime((AttendResultRuleDTO)ruleDTO, (AttendResultDTO)resultDTO, (Long)signParam.getSignTime());
+                }
+                resultDTO.setOvertime(Integer.valueOf(overTime));
+                this.nextHandle(null);
+            }
+        }
+        catch (Exception e) {
+            this.logger.error("\u8003\u52e4\u7ed3\u679c\u751f\u6210\uff0c\u5224\u65ad\u662f\u5426\u662f\u4e0b\u73ed\u6b63\u5e38\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private boolean signValid(AttendResultSignParam signParam, AttendResultDTO resultDTO, AttendResultRuleDTO ruleDTO, boolean isHoliday) {
+        if (isHoliday) {
+            return false;
+        }
+        if (resultDTO.getStartworkTime() == null && signParam.getSignTime() < resultDTO.getRuleEndworkTime() - (long)ruleDTO.getMatchScheduling().getBeforeTime().intValue() * MI_MILL) {
+            return false;
+        }
+        if (resultDTO.getEndworkTime() == null) {
+            return true;
+        }
+        return signParam.getSignTime() > resultDTO.getEndworkTime();
+    }
+
+    private boolean signNormal(AttendResultSignParam signParam, AttendResultRuleDTO ruleDTO, Long attendTime) throws ServiceException {
+        int beforeTime = ruleDTO.getMatchScheduling().getBeforeTime() == null ? 0 : ruleDTO.getMatchScheduling().getBeforeTime();
+        return signParam.getSignTime() - AttendUtil.getRuleTime((String)ruleDTO.getMatchScheduling().getEndworkTime(), (long)attendTime).getTime() + (long)(beforeTime * 60 * 1000) >= 0L;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/handle/scheduling/AttendResultSchedulingStartLateHandle.java

@@ -0,0 +1,75 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.AttendUtil
+ */
+package cn.cloudwalk.service.ninca.attendance.result.handle.scheduling;
+
+import cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum;
+import cn.cloudwalk.common.ninca.attendance.util.AttendUtil;
+import cn.cloudwalk.service.ninca.attendance.result.handle.AbstractAttendResultHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.scheduling.AttendResultSchedulingEndEarlyHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.scheduling.AttendResultSchedulingEndNormalHandle;
+
+public class AttendResultSchedulingStartLateHandle
+extends AbstractAttendResultHandle {
+    @Override
+    public void handle(AbstractAttendResultGenCallContext callContext) throws ServiceException {
+        this.logger.info("\u5904\u7406\u6392\u73ed\u8003\u52e4\u7ed3\u679c\u4e0a\u73ed\u8fdf\u5230");
+        try {
+            AttendResultGenCallContext attendResultGenCallContext = (AttendResultGenCallContext)callContext;
+            AttendResultSignParam signParam = attendResultGenCallContext.getSignParam();
+            AttendResultDTO resultDTO = attendResultGenCallContext.getResultDTO();
+            AttendResultRuleDTO ruleDTO = attendResultGenCallContext.getRuleDTO();
+            if (this.signValid(signParam, resultDTO, ruleDTO, attendResultGenCallContext.isHoliday()) && this.signLate(signParam, ruleDTO, attendResultGenCallContext.getRuleAttendTime())) {
+                long lastTime = resultDTO.getStartworkTime() != null ? resultDTO.getStartworkTime() : 0L;
+                resultDTO.setStartStatus(AttendResultStatusEnum.LATE.getCode());
+                resultDTO.setStartworkTime(signParam.getSignTime());
+                this.nextHandle(null);
+                if (lastTime != 0L) {
+                    signParam.setSignTime(Long.valueOf(lastTime));
+                    AttendResultSchedulingEndNormalHandle endNormalHandle = new AttendResultSchedulingEndNormalHandle();
+                    endNormalHandle.nextHandle(new AttendResultSchedulingEndEarlyHandle());
+                    endNormalHandle.exec(callContext);
+                }
+            }
+        }
+        catch (Exception e) {
+            this.logger.error("\u8003\u52e4\u7ed3\u679c\u751f\u6210\uff0c\u5224\u65ad\u662f\u5426\u662f\u4e0a\u73ed\u8fdf\u5230\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private boolean signValid(AttendResultSignParam signParam, AttendResultDTO resultDTO, AttendResultRuleDTO ruleDTO, boolean isHoliday) {
+        if (isHoliday) {
+            return false;
+        }
+        if (signParam.getSignTime() >= resultDTO.getRuleEndworkTime() - (long)ruleDTO.getMatchScheduling().getBeforeTime().intValue() * MI_MILL) {
+            return false;
+        }
+        if (resultDTO.getStartworkTime() == null) {
+            return true;
+        }
+        return signParam.getSignTime() < resultDTO.getStartworkTime();
+    }
+
+    private boolean signLate(AttendResultSignParam signParam, AttendResultRuleDTO ruleDTO, Long attendTime) throws ServiceException {
+        int afterTime = ruleDTO.getMatchScheduling().getAfterTime() == null ? 0 : ruleDTO.getMatchScheduling().getAfterTime();
+        return signParam.getSignTime() - AttendUtil.getRuleTime((String)ruleDTO.getMatchScheduling().getStartworkTime(), (long)attendTime).getTime() - (long)(afterTime * 60 * 1000) > 0L;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/handle/scheduling/AttendResultSchedulingStartNormalHandle.java

@@ -0,0 +1,75 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.AttendUtil
+ */
+package cn.cloudwalk.service.ninca.attendance.result.handle.scheduling;
+
+import cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum;
+import cn.cloudwalk.common.ninca.attendance.util.AttendUtil;
+import cn.cloudwalk.service.ninca.attendance.result.handle.AbstractAttendResultHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.scheduling.AttendResultSchedulingEndEarlyHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.scheduling.AttendResultSchedulingEndNormalHandle;
+
+public class AttendResultSchedulingStartNormalHandle
+extends AbstractAttendResultHandle {
+    @Override
+    public void handle(AbstractAttendResultGenCallContext callContext) throws ServiceException {
+        this.logger.info("\u5904\u7406\u6392\u73ed\u8003\u52e4\u7ed3\u679c\u662f\u5426\u662f\u4e0a\u73ed\u6b63\u5e38");
+        try {
+            AttendResultGenCallContext attendResultGenCallContext = (AttendResultGenCallContext)callContext;
+            AttendResultSignParam signParam = attendResultGenCallContext.getSignParam();
+            AttendResultDTO resultDTO = attendResultGenCallContext.getResultDTO();
+            AttendResultRuleDTO ruleDTO = attendResultGenCallContext.getRuleDTO();
+            if (this.signValid(signParam, resultDTO, ruleDTO, attendResultGenCallContext.isHoliday()) && this.signNormal(signParam, ruleDTO, attendResultGenCallContext.getRuleAttendTime())) {
+                long lastTime = resultDTO.getStartworkTime() != null ? resultDTO.getStartworkTime() : 0L;
+                resultDTO.setStartStatus(AttendResultStatusEnum.NORMAL.getCode());
+                resultDTO.setStartworkTime(signParam.getSignTime());
+                this.nextHandle(null);
+                if (lastTime != 0L) {
+                    signParam.setSignTime(Long.valueOf(lastTime));
+                    AttendResultSchedulingEndNormalHandle endNormalHandle = new AttendResultSchedulingEndNormalHandle();
+                    endNormalHandle.nextHandle(new AttendResultSchedulingEndEarlyHandle());
+                    endNormalHandle.exec(callContext);
+                }
+            }
+        }
+        catch (Exception e) {
+            this.logger.error("\u8003\u52e4\u7ed3\u679c\u751f\u6210\uff0c\u5224\u65ad\u662f\u5426\u662f\u4e0a\u73ed\u6b63\u5e38\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private boolean signValid(AttendResultSignParam signParam, AttendResultDTO resultDTO, AttendResultRuleDTO ruleDTO, boolean isHoliday) {
+        if (isHoliday) {
+            return false;
+        }
+        if (signParam.getSignTime() >= resultDTO.getRuleEndworkTime() - (long)ruleDTO.getMatchScheduling().getBeforeTime().intValue() * MI_MILL) {
+            return false;
+        }
+        if (resultDTO.getStartworkTime() == null) {
+            return true;
+        }
+        return signParam.getSignTime() < resultDTO.getStartworkTime();
+    }
+
+    private boolean signNormal(AttendResultSignParam signParam, AttendResultRuleDTO ruleDTO, Long attendTime) throws ServiceException {
+        int afterTime = ruleDTO.getMatchScheduling().getAfterTime() == null ? 0 : ruleDTO.getMatchScheduling().getAfterTime();
+        return signParam.getSignTime() - AttendUtil.getRuleTime((String)ruleDTO.getMatchScheduling().getStartworkTime(), (long)attendTime).getTime() - (long)(afterTime * 60 * 1000) <= 0L;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/handle/stand/AttendResultEndEarlyHandle.java

@@ -0,0 +1,66 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.AttendUtil
+ */
+package cn.cloudwalk.service.ninca.attendance.result.handle.stand;
+
+import cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum;
+import cn.cloudwalk.common.ninca.attendance.util.AttendUtil;
+import cn.cloudwalk.service.ninca.attendance.result.handle.AbstractAttendResultHandle;
+
+public class AttendResultEndEarlyHandle
+extends AbstractAttendResultHandle {
+    @Override
+    public void handle(AbstractAttendResultGenCallContext callContext) throws ServiceException {
+        this.logger.info("\u5904\u7406\u6807\u51c6\u8003\u52e4\u7ed3\u679c\u662f\u5426\u662f\u4e0b\u73ed\u65e9\u9000");
+        try {
+            AttendResultGenCallContext attendResultGenCallContext = (AttendResultGenCallContext)callContext;
+            AttendResultSignParam signParam = attendResultGenCallContext.getSignParam();
+            AttendResultDTO resultDTO = attendResultGenCallContext.getResultDTO();
+            AttendResultRuleDTO ruleDTO = attendResultGenCallContext.getRuleDTO();
+            if (this.signValid(signParam, resultDTO, ruleDTO, attendResultGenCallContext.isHoliday()) && this.signLeaveEarly(signParam, ruleDTO, attendResultGenCallContext.getRuleAttendTime())) {
+                resultDTO.setEndStatus(AttendResultStatusEnum.LEAVE_EARLY.getCode());
+                resultDTO.setEndworkTime(signParam.getSignTime());
+                this.nextHandle(null);
+            }
+        }
+        catch (Exception e) {
+            this.logger.error("\u8003\u52e4\u7ed3\u679c\u751f\u6210\uff0c\u5224\u65ad\u662f\u5426\u662f\u4e0b\u73ed\u65e9\u9000\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private boolean signValid(AttendResultSignParam signParam, AttendResultDTO resultDTO, AttendResultRuleDTO ruleDTO, boolean isHoliday) {
+        if (isHoliday) {
+            return false;
+        }
+        if (resultDTO.getStartworkTime() == null && signParam.getSignTime() < resultDTO.getRuleEndworkTime() - (long)ruleDTO.getMatchScheduling().getBeforeTime().intValue() * MI_MILL) {
+            return false;
+        }
+        if (resultDTO.getEndworkTime() == null) {
+            return true;
+        }
+        return signParam.getSignTime() > resultDTO.getEndworkTime();
+    }
+
+    private boolean signLeaveEarly(AttendResultSignParam signParam, AttendResultRuleDTO ruleDTO, Long attendTime) throws ServiceException {
+        int beforeTime = ruleDTO.getMatchScheduling().getBeforeTime() == null ? 0 : ruleDTO.getMatchScheduling().getBeforeTime();
+        return signParam.getSignTime() - AttendUtil.getRuleTime((String)ruleDTO.getMatchScheduling().getEndworkTime(), (long)attendTime).getTime() + (long)(beforeTime * 60 * 1000) < 0L;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/handle/stand/AttendResultEndNormalHandle.java

@@ -0,0 +1,73 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.AttendUtil
+ */
+package cn.cloudwalk.service.ninca.attendance.result.handle.stand;
+
+import cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum;
+import cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.AttendUtil;
+import cn.cloudwalk.service.ninca.attendance.result.handle.AbstractAttendResultHandle;
+
+public class AttendResultEndNormalHandle
+extends AbstractAttendResultHandle {
+    @Override
+    public void handle(AbstractAttendResultGenCallContext callContext) throws ServiceException {
+        this.logger.info("\u5904\u7406\u6807\u51c6\u8003\u52e4\u7ed3\u679c\u662f\u5426\u662f\u4e0b\u73ed\u6b63\u5e38");
+        try {
+            AttendResultGenCallContext attendResultGenCallContext = (AttendResultGenCallContext)callContext;
+            AttendResultSignParam signParam = attendResultGenCallContext.getSignParam();
+            AttendResultDTO resultDTO = attendResultGenCallContext.getResultDTO();
+            AttendResultRuleDTO ruleDTO = attendResultGenCallContext.getRuleDTO();
+            if (this.signValid(signParam, resultDTO, ruleDTO, attendResultGenCallContext.isHoliday()) && this.signNormal(signParam, ruleDTO, attendResultGenCallContext.getRuleAttendTime())) {
+                resultDTO.setEndStatus(AttendResultStatusEnum.NORMAL.getCode());
+                resultDTO.setEndworkTime(signParam.getSignTime());
+                int overTime = 0;
+                if (YesNoTypeEnum.Y.getCode().equals(ruleDTO.getAllowWorkingOvertime())) {
+                    overTime = AttendUtil.calculateOverTime((AttendResultRuleDTO)ruleDTO, (AttendResultDTO)resultDTO, (Long)signParam.getSignTime());
+                }
+                resultDTO.setOvertime(Integer.valueOf(overTime));
+                this.nextHandle(null);
+            }
+        }
+        catch (Exception e) {
+            this.logger.error("\u8003\u52e4\u7ed3\u679c\u751f\u6210\uff0c\u5224\u65ad\u662f\u5426\u662f\u4e0b\u73ed\u6b63\u5e38\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private boolean signValid(AttendResultSignParam signParam, AttendResultDTO resultDTO, AttendResultRuleDTO ruleDTO, boolean isHoliday) {
+        if (isHoliday) {
+            return false;
+        }
+        if (resultDTO.getStartworkTime() == null && signParam.getSignTime() < resultDTO.getRuleEndworkTime() - (long)ruleDTO.getMatchScheduling().getBeforeTime().intValue() * MI_MILL) {
+            return false;
+        }
+        if (resultDTO.getEndworkTime() == null) {
+            return true;
+        }
+        return signParam.getSignTime() > resultDTO.getEndworkTime();
+    }
+
+    private boolean signNormal(AttendResultSignParam signParam, AttendResultRuleDTO ruleDTO, Long attendTime) throws ServiceException {
+        int beforeTime = ruleDTO.getMatchScheduling().getBeforeTime() == null ? 0 : ruleDTO.getMatchScheduling().getBeforeTime();
+        return signParam.getSignTime() - AttendUtil.getRuleTime((String)ruleDTO.getMatchScheduling().getEndworkTime(), (long)attendTime).getTime() + (long)(beforeTime * 60 * 1000) >= 0L;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/handle/stand/AttendResultEndOverTimeHandle.java

@@ -0,0 +1,71 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.DateTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.AttendUtil
+ */
+package cn.cloudwalk.service.ninca.attendance.result.handle.stand;
+
+import cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum;
+import cn.cloudwalk.common.ninca.attendance.em.DateTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.AttendUtil;
+import cn.cloudwalk.service.ninca.attendance.result.handle.AbstractAttendResultHandle;
+
+public class AttendResultEndOverTimeHandle
+extends AbstractAttendResultHandle {
+    @Override
+    public void handle(AbstractAttendResultGenCallContext callContext) throws ServiceException {
+        this.logger.info("\u5904\u7406\u6807\u51c6\u8003\u52e4\u7ed3\u679c\u662f\u5426\u662f\u4e0b\u73ed\u52a0\u73ed");
+        try {
+            AttendResultGenCallContext attendResultGenCallContext = (AttendResultGenCallContext)callContext;
+            AttendResultSignParam signParam = attendResultGenCallContext.getSignParam();
+            AttendResultDTO resultDTO = attendResultGenCallContext.getResultDTO();
+            AttendResultRuleDTO ruleDTO = attendResultGenCallContext.getRuleDTO();
+            if (this.signValid(signParam, resultDTO, ruleDTO, attendResultGenCallContext.isHoliday())) {
+                resultDTO.setEndStatus(AttendResultStatusEnum.NORMAL.getCode());
+                resultDTO.setEndworkTime(signParam.getSignTime());
+                resultDTO.setDateType(DateTypeEnum.HOLIDAY.getCode());
+                int overTime = 0;
+                if (YesNoTypeEnum.Y.getCode().equals(ruleDTO.getAllowDayoffOvertime())) {
+                    overTime = AttendUtil.calculateDayoffOverTime((AttendResultRuleDTO)ruleDTO, (AttendResultDTO)resultDTO);
+                }
+                resultDTO.setOvertime(Integer.valueOf(overTime));
+                this.nextHandle(null);
+            }
+        }
+        catch (Exception e) {
+            this.logger.error("\u8003\u52e4\u7ed3\u679c\u751f\u6210\uff0c\u5224\u65ad\u662f\u5426\u662f\u4e0b\u73ed\u52a0\u73ed\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private boolean signValid(AttendResultSignParam signParam, AttendResultDTO resultDTO, AttendResultRuleDTO ruleDTO, boolean isHoliday) {
+        if (!isHoliday) {
+            return false;
+        }
+        if (resultDTO.getStartworkTime() == null) {
+            return false;
+        }
+        if (resultDTO.getEndworkTime() == null) {
+            return true;
+        }
+        return signParam.getSignTime() > resultDTO.getEndworkTime();
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/handle/stand/AttendResultStartLateHandle.java

@@ -0,0 +1,75 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.AttendUtil
+ */
+package cn.cloudwalk.service.ninca.attendance.result.handle.stand;
+
+import cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum;
+import cn.cloudwalk.common.ninca.attendance.util.AttendUtil;
+import cn.cloudwalk.service.ninca.attendance.result.handle.AbstractAttendResultHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.stand.AttendResultEndEarlyHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.stand.AttendResultEndNormalHandle;
+
+public class AttendResultStartLateHandle
+extends AbstractAttendResultHandle {
+    @Override
+    public void handle(AbstractAttendResultGenCallContext callContext) throws ServiceException {
+        this.logger.info("\u5904\u7406\u6807\u51c6\u8003\u52e4\u7ed3\u679c\u4e0a\u73ed\u8fdf\u5230");
+        try {
+            AttendResultGenCallContext attendResultGenCallContext = (AttendResultGenCallContext)callContext;
+            AttendResultSignParam signParam = attendResultGenCallContext.getSignParam();
+            AttendResultDTO resultDTO = attendResultGenCallContext.getResultDTO();
+            AttendResultRuleDTO ruleDTO = attendResultGenCallContext.getRuleDTO();
+            if (this.signValid(signParam, resultDTO, ruleDTO, attendResultGenCallContext.isHoliday()) && this.signLate(signParam, ruleDTO, attendResultGenCallContext.getRuleAttendTime())) {
+                long lastTime = resultDTO.getStartworkTime() != null ? resultDTO.getStartworkTime() : 0L;
+                resultDTO.setStartStatus(AttendResultStatusEnum.LATE.getCode());
+                resultDTO.setStartworkTime(signParam.getSignTime());
+                this.nextHandle(null);
+                if (lastTime != 0L) {
+                    signParam.setSignTime(Long.valueOf(lastTime));
+                    AttendResultEndNormalHandle endNormalHandle = new AttendResultEndNormalHandle();
+                    endNormalHandle.nextHandle(new AttendResultEndEarlyHandle());
+                    endNormalHandle.exec(callContext);
+                }
+            }
+        }
+        catch (Exception e) {
+            this.logger.error("\u8003\u52e4\u7ed3\u679c\u751f\u6210\uff0c\u5224\u65ad\u662f\u5426\u662f\u4e0a\u73ed\u8fdf\u5230\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private boolean signValid(AttendResultSignParam signParam, AttendResultDTO resultDTO, AttendResultRuleDTO ruleDTO, boolean isHoliday) {
+        if (isHoliday) {
+            return false;
+        }
+        if (signParam.getSignTime() >= resultDTO.getRuleEndworkTime() - (long)ruleDTO.getMatchScheduling().getBeforeTime().intValue() * MI_MILL) {
+            return false;
+        }
+        if (resultDTO.getStartworkTime() == null) {
+            return true;
+        }
+        return signParam.getSignTime() < resultDTO.getStartworkTime();
+    }
+
+    private boolean signLate(AttendResultSignParam signParam, AttendResultRuleDTO ruleDTO, Long attendTime) throws ServiceException {
+        int afterTime = ruleDTO.getMatchScheduling().getAfterTime() == null ? 0 : ruleDTO.getMatchScheduling().getAfterTime();
+        return signParam.getSignTime() - AttendUtil.getRuleTime((String)ruleDTO.getMatchScheduling().getStartworkTime(), (long)attendTime).getTime() - (long)(afterTime * 60 * 1000) > 0L;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/handle/stand/AttendResultStartNormalHandle.java

@@ -0,0 +1,75 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.AttendUtil
+ */
+package cn.cloudwalk.service.ninca.attendance.result.handle.stand;
+
+import cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum;
+import cn.cloudwalk.common.ninca.attendance.util.AttendUtil;
+import cn.cloudwalk.service.ninca.attendance.result.handle.AbstractAttendResultHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.stand.AttendResultEndEarlyHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.stand.AttendResultEndNormalHandle;
+
+public class AttendResultStartNormalHandle
+extends AbstractAttendResultHandle {
+    @Override
+    public void handle(AbstractAttendResultGenCallContext callContext) throws ServiceException {
+        this.logger.info("\u5904\u7406\u6807\u51c6\u8003\u52e4\u7ed3\u679c\u662f\u5426\u662f\u4e0a\u73ed\u6b63\u5e38");
+        try {
+            AttendResultGenCallContext attendResultGenCallContext = (AttendResultGenCallContext)callContext;
+            AttendResultSignParam signParam = attendResultGenCallContext.getSignParam();
+            AttendResultDTO resultDTO = attendResultGenCallContext.getResultDTO();
+            AttendResultRuleDTO ruleDTO = attendResultGenCallContext.getRuleDTO();
+            if (this.signValid(signParam, resultDTO, ruleDTO, attendResultGenCallContext.isHoliday()) && this.signNormal(signParam, ruleDTO, attendResultGenCallContext.getRuleAttendTime())) {
+                long lastTime = resultDTO.getStartworkTime() != null ? resultDTO.getStartworkTime() : 0L;
+                resultDTO.setStartStatus(AttendResultStatusEnum.NORMAL.getCode());
+                resultDTO.setStartworkTime(signParam.getSignTime());
+                this.nextHandle(null);
+                if (lastTime != 0L) {
+                    signParam.setSignTime(Long.valueOf(lastTime));
+                    AttendResultEndNormalHandle endNormalHandle = new AttendResultEndNormalHandle();
+                    endNormalHandle.nextHandle(new AttendResultEndEarlyHandle());
+                    endNormalHandle.exec(callContext);
+                }
+            }
+        }
+        catch (Exception e) {
+            this.logger.error("\u8003\u52e4\u7ed3\u679c\u751f\u6210\uff0c\u5224\u65ad\u662f\u5426\u662f\u4e0a\u73ed\u6b63\u5e38\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private boolean signValid(AttendResultSignParam signParam, AttendResultDTO resultDTO, AttendResultRuleDTO ruleDTO, boolean isHoliday) {
+        if (isHoliday) {
+            return false;
+        }
+        if (signParam.getSignTime() >= resultDTO.getRuleEndworkTime() - (long)ruleDTO.getMatchScheduling().getBeforeTime().intValue() * MI_MILL) {
+            return false;
+        }
+        if (resultDTO.getStartworkTime() == null) {
+            return true;
+        }
+        return signParam.getSignTime() < resultDTO.getStartworkTime();
+    }
+
+    private boolean signNormal(AttendResultSignParam signParam, AttendResultRuleDTO ruleDTO, Long attendTime) throws ServiceException {
+        int afterTime = ruleDTO.getMatchScheduling().getAfterTime() == null ? 0 : ruleDTO.getMatchScheduling().getAfterTime();
+        return signParam.getSignTime() - AttendUtil.getRuleTime((String)ruleDTO.getMatchScheduling().getStartworkTime(), (long)attendTime).getTime() - (long)(afterTime * 60 * 1000) <= 0L;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/result/handle/stand/AttendResultStartOverTimeHandle.java

@@ -0,0 +1,66 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext
+ *  cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum
+ *  cn.cloudwalk.common.ninca.attendance.em.DateTypeEnum
+ */
+package cn.cloudwalk.service.ninca.attendance.result.handle.stand;
+
+import cn.cloudwalk.client.ninca.attendance.result.common.AbstractAttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.common.AttendResultGenCallContext;
+import cn.cloudwalk.client.ninca.attendance.result.param.AttendResultSignParam;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.result.AttendResultRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendResultStatusEnum;
+import cn.cloudwalk.common.ninca.attendance.em.DateTypeEnum;
+import cn.cloudwalk.service.ninca.attendance.result.handle.AbstractAttendResultHandle;
+import cn.cloudwalk.service.ninca.attendance.result.handle.stand.AttendResultEndOverTimeHandle;
+
+public class AttendResultStartOverTimeHandle
+extends AbstractAttendResultHandle {
+    @Override
+    public void handle(AbstractAttendResultGenCallContext callContext) throws ServiceException {
+        this.logger.info("\u5904\u7406\u6807\u51c6\u8003\u52e4\u7ed3\u679c\u662f\u5426\u662f\u4e0a\u73ed\u52a0\u73ed");
+        try {
+            AttendResultGenCallContext attendResultGenCallContext = (AttendResultGenCallContext)callContext;
+            AttendResultSignParam signParam = attendResultGenCallContext.getSignParam();
+            AttendResultDTO resultDTO = attendResultGenCallContext.getResultDTO();
+            AttendResultRuleDTO ruleDTO = attendResultGenCallContext.getRuleDTO();
+            if (this.signValid(signParam, resultDTO, ruleDTO, attendResultGenCallContext.isHoliday())) {
+                long lastTime = resultDTO.getStartworkTime() != null ? resultDTO.getStartworkTime() : 0L;
+                resultDTO.setStartStatus(AttendResultStatusEnum.NORMAL.getCode());
+                resultDTO.setStartworkTime(signParam.getSignTime());
+                resultDTO.setDateType(DateTypeEnum.HOLIDAY.getCode());
+                this.nextHandle(null);
+                if (lastTime != 0L) {
+                    signParam.setSignTime(Long.valueOf(lastTime));
+                    AttendResultEndOverTimeHandle endOverTimeHandle = new AttendResultEndOverTimeHandle();
+                    endOverTimeHandle.exec(callContext);
+                }
+            }
+        }
+        catch (Exception e) {
+            this.logger.error("\u8003\u52e4\u7ed3\u679c\u751f\u6210\uff0c\u5224\u65ad\u662f\u5426\u662f\u4e0a\u73ed\u52a0\u73ed\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private boolean signValid(AttendResultSignParam signParam, AttendResultDTO resultDTO, AttendResultRuleDTO ruleDTO, boolean isHoliday) {
+        if (!isHoliday) {
+            return false;
+        }
+        if (resultDTO.getStartworkTime() == null) {
+            return true;
+        }
+        return signParam.getSignTime() < resultDTO.getStartworkTime();
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/rule/AttendRuleCheckServiceImpl.java

@@ -0,0 +1,127 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleSchedulingSaveParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleCheckService
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.AttendUtil
+ *  cn.cloudwalk.common.ninca.attendance.util.DateUtils
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.attendance.rule;
+
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleSchedulingSaveParam;
+import cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleCheckService;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.AttendUtil;
+import cn.cloudwalk.common.ninca.attendance.util.DateUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.List;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AttendRuleCheckServiceImpl
+extends AbstractCloudwalkService
+implements AttendRuleCheckService {
+    public CloudwalkResult<Boolean> check(Integer type, List<AttendRuleSchedulingSaveParam> schedulings) throws ServiceException {
+        if (AttendTypeEnum.STANDARD.getCode().equals(type)) {
+            return this.checkStandScheduling(schedulings);
+        }
+        if (AttendTypeEnum.FLEXIBLE.getCode().equals(type)) {
+            return this.checkFlexbleScheduling(schedulings);
+        }
+        return CloudwalkResult.fail((String)"76240223", (String)this.getMessage("76240223"));
+    }
+
+    private CloudwalkResult<Boolean> checkFlexbleScheduling(List<AttendRuleSchedulingSaveParam> schedulings) {
+        AttendRuleSchedulingSaveParam param = schedulings.get(0);
+        if (param.getStandardTime() == null) {
+            return CloudwalkResult.fail((String)"76240222", (String)this.getMessage("76240222"));
+        }
+        return CloudwalkResult.success((Object)true);
+    }
+
+    private CloudwalkResult<Boolean> checkStandScheduling(List<AttendRuleSchedulingSaveParam> schedulings) throws ServiceException {
+        int maxScheduling = 3;
+        if (schedulings.size() > maxScheduling) {
+            return CloudwalkResult.fail((String)"76240235", (String)this.getMessage("76240235"));
+        }
+        int i = 0;
+        for (AttendRuleSchedulingSaveParam scheduling : schedulings) {
+            scheduling.setSortValue(Integer.valueOf(++i));
+        }
+        schedulings.sort(Comparator.comparingInt(AttendRuleSchedulingSaveParam::getSortValue));
+        List<AttendRuleSchedulingSaveParam> formatSchedulingList = this.format(schedulings);
+        String firstStartAdaptTime = formatSchedulingList.get(0).getStartAdaptTime();
+        String backEndAdaptTime = formatSchedulingList.get(schedulings.size() - 1).getEndAdaptTime();
+        long diff = DateUtils.dateToStampFormat((String)backEndAdaptTime, (String)"yyyy-MM-dd HH:mm:ss") - DateUtils.dateToStampFormat((String)firstStartAdaptTime, (String)"yyyy-MM-dd HH:mm:ss");
+        if (diff <= 0L || diff >= 86400000L) {
+            return CloudwalkResult.fail((String)"76240249", (String)this.getMessage("76240252"));
+        }
+        String lastEndWorkTime = null;
+        String lastEndAdaptTime = null;
+        for (AttendRuleSchedulingSaveParam scheduling : formatSchedulingList) {
+            if (this.checkSingleScheduling(scheduling)) {
+                return CloudwalkResult.fail((String)"76240253", (String)this.getMessage("76240253"));
+            }
+            if (lastEndWorkTime != null && lastEndAdaptTime != null && (AttendUtil.compareStr((String)scheduling.getStartAdaptTime(), (String)lastEndWorkTime) <= 0 || AttendUtil.compareStr((String)scheduling.getStartworkTime(), (String)lastEndAdaptTime) <= 0)) {
+                return CloudwalkResult.fail((String)"76240252", (String)this.getMessage("76240252"));
+            }
+            lastEndWorkTime = scheduling.getEndworkTime();
+            lastEndAdaptTime = scheduling.getEndAdaptTime();
+        }
+        return CloudwalkResult.success((Object)true);
+    }
+
+    private boolean checkSingleScheduling(AttendRuleSchedulingSaveParam scheduling) {
+        return AttendUtil.compareStr((String)scheduling.getEndAdaptTime(), (String)scheduling.getEndworkTime()) <= 0 || AttendUtil.compareStr((String)scheduling.getEndworkTime(), (String)scheduling.getStartworkTime()) <= 0 || AttendUtil.compareStr((String)scheduling.getStartworkTime(), (String)scheduling.getStartAdaptTime()) <= 0;
+    }
+
+    private List<AttendRuleSchedulingSaveParam> format(List<AttendRuleSchedulingSaveParam> schedulings) throws ServiceException {
+        ArrayList<AttendRuleSchedulingSaveParam> returnList = new ArrayList<AttendRuleSchedulingSaveParam>(schedulings.size());
+        long nowTime = System.currentTimeMillis();
+        String fssat = schedulings.get(0).getStartAdaptTime();
+        for (AttendRuleSchedulingSaveParam param : schedulings) {
+            AttendRuleSchedulingSaveParam scheduling = (AttendRuleSchedulingSaveParam)BeanCopyUtils.copyProperties((Object)param, AttendRuleSchedulingSaveParam.class);
+            String beforeStartAdaptTime = scheduling.getStartAdaptTime();
+            if (AttendUtil.compareStr((String)scheduling.getStartAdaptTime(), (String)fssat) >= 0) {
+                scheduling.setStartAdaptTime(this.getFormatTime(scheduling.getStartAdaptTime() + "+0", nowTime));
+            } else {
+                scheduling.setStartAdaptTime(this.getFormatTime(scheduling.getStartAdaptTime() + "+1", nowTime));
+            }
+            if (AttendUtil.compareStr((String)scheduling.getStartworkTime(), (String)fssat) > 0) {
+                scheduling.setStartworkTime(this.getFormatTime(scheduling.getStartworkTime() + "+0", nowTime));
+            } else {
+                scheduling.setStartworkTime(this.getFormatTime(scheduling.getStartworkTime() + "+1", nowTime));
+            }
+            if (AttendUtil.compareStr((String)scheduling.getEndworkTime(), (String)fssat) > 0 && AttendUtil.compareStr((String)scheduling.getEndworkTime(), (String)beforeStartAdaptTime) > 0) {
+                scheduling.setEndworkTime(this.getFormatTime(scheduling.getEndworkTime() + "+0", nowTime));
+            } else {
+                scheduling.setEndworkTime(this.getFormatTime(scheduling.getEndworkTime() + "+1", nowTime));
+            }
+            if (AttendUtil.compareStr((String)scheduling.getEndAdaptTime(), (String)fssat) > 0 && AttendUtil.compareStr((String)scheduling.getEndAdaptTime(), (String)beforeStartAdaptTime) > 0) {
+                scheduling.setEndAdaptTime(this.getFormatTime(scheduling.getEndAdaptTime() + "+0", nowTime));
+            } else {
+                scheduling.setEndAdaptTime(this.getFormatTime(scheduling.getEndAdaptTime() + "+1", nowTime));
+            }
+            returnList.add(scheduling);
+        }
+        return returnList;
+    }
+
+    private String getFormatTime(String startAdaptTime, long nowTime) throws ServiceException {
+        Date ruleTime = AttendUtil.getRuleTime((String)startAdaptTime, (long)nowTime);
+        return DateUtils.formatDate((Date)ruleTime, (String)"yyyy-MM-dd HH:mm:ss");
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/rule/AttendRuleDeviceServiceImpl.java

@@ -0,0 +1,157 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleDeviceManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.result.DeviceResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceService
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleAddParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleEditParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleQueryParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleDeviceQueryResult
+ *  cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleDeviceService
+ *  cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceAddDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceDeleteDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ *  org.springframework.transaction.annotation.Transactional
+ */
+package cn.cloudwalk.service.ninca.attendance.rule;
+
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleDeviceManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.result.DeviceResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceService;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleAddParam;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleEditParam;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleQueryParam;
+import cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleDeviceQueryResult;
+import cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleDeviceService;
+import cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceAddDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceDeleteDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class AttendRuleDeviceServiceImpl
+extends AbstractCloudwalkService
+implements AttendRuleDeviceService {
+    @Resource
+    private AttendRuleDeviceManager attendRuleDeviceManager;
+    @Resource
+    private DeviceService deviceService;
+
+    public CloudwalkResult<List<AttendRuleDeviceQueryResult>> query(AttendRuleQueryParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            AttendRuleDeviceQueryDTO queryDTO = (AttendRuleDeviceQueryDTO)BeanCopyUtils.copyProperties((Object)param, AttendRuleDeviceQueryDTO.class);
+            List queryResultList = this.attendRuleDeviceManager.query(queryDTO);
+            if (CollectionUtils.isEmpty((Collection)queryResultList)) {
+                return CloudwalkResult.success(new ArrayList());
+            }
+            List<AttendRuleDeviceQueryResult> returnList = this.getQueryReturnList(queryResultList, cloudwalkContext);
+            return CloudwalkResult.success(returnList);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u67e5\u8be2\u8003\u52e4\u8bbe\u5907\u4fe1\u606f\u5931\u8d25", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private List<AttendRuleDeviceQueryResult> getQueryReturnList(List<AttendRuleDeviceQueryResultDTO> queryResultList, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        List deviceIds = queryResultList.stream().map(AttendRuleDeviceQueryResultDTO::getDeviceId).collect(Collectors.toList());
+        DeviceQueryParam deviceQueryParam = new DeviceQueryParam();
+        deviceQueryParam.setIds(deviceIds);
+        CloudwalkResult deviceResult = this.deviceService.list(deviceQueryParam, cloudwalkContext);
+        Map<String, List<DeviceResult>> tmpDeviceMap = null;
+        if (deviceResult.isSuccess() && CollectionUtils.isNotEmpty((Collection)((Collection)deviceResult.getData()))) {
+            tmpDeviceMap = ((List)deviceResult.getData()).stream().collect(Collectors.groupingBy(DeviceResult::getId));
+        }
+        ArrayList<AttendRuleDeviceQueryResult> returnList = new ArrayList<AttendRuleDeviceQueryResult>(queryResultList.size());
+        for (AttendRuleDeviceQueryResultDTO dto : queryResultList) {
+            AttendRuleDeviceQueryResult result = (AttendRuleDeviceQueryResult)BeanCopyUtils.copyProperties((Object)dto, AttendRuleDeviceQueryResult.class);
+            if (tmpDeviceMap != null && CollectionUtils.isNotEmpty((Collection)tmpDeviceMap.get(dto.getDeviceId()))) {
+                result.setDeviceName(tmpDeviceMap.get(dto.getDeviceId()).get(0).getDeviceName());
+            }
+            returnList.add(result);
+        }
+        return returnList;
+    }
+
+    @Transactional(rollbackFor={Exception.class})
+    @CloudwalkParamsValidate
+    public void add(AttendRuleAddParam param, String ruleId) throws ServiceException {
+        List deviceIds = param.getDeviceIds();
+        long nowTime = System.currentTimeMillis();
+        try {
+            for (String deviceId : deviceIds) {
+                AttendRuleDeviceAddDTO addDTO = new AttendRuleDeviceAddDTO();
+                addDTO.setId(this.genUUID());
+                addDTO.setRuleId(ruleId);
+                addDTO.setDeviceId(deviceId);
+                addDTO.setCreateTime(Long.valueOf(nowTime));
+                addDTO.setCreateUserId(param.getUserId());
+                addDTO.setLastUpdateTime(Long.valueOf(nowTime));
+                addDTO.setLastUpdateUserId(param.getUserId());
+                this.attendRuleDeviceManager.add(addDTO);
+            }
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u65b0\u589e\u8003\u52e4\u8bbe\u5907\u5931\u8d25", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @CloudwalkParamsValidate
+    @Transactional(rollbackFor={Exception.class})
+    public void edit(AttendRuleEditParam param) throws ServiceException {
+        List deviceIds = param.getDeviceIds();
+        long nowTime = System.currentTimeMillis();
+        try {
+            AttendRuleDeviceDeleteDTO deviceDeleteDTO = new AttendRuleDeviceDeleteDTO();
+            deviceDeleteDTO.setRuleId(param.getId());
+            this.attendRuleDeviceManager.delete(deviceDeleteDTO);
+            for (String deviceId : deviceIds) {
+                AttendRuleDeviceAddDTO addDTO = new AttendRuleDeviceAddDTO();
+                addDTO.setId(this.genUUID());
+                addDTO.setRuleId(param.getId());
+                addDTO.setDeviceId(deviceId);
+                addDTO.setCreateTime(Long.valueOf(nowTime));
+                addDTO.setCreateUserId(param.getUserId());
+                addDTO.setLastUpdateTime(Long.valueOf(nowTime));
+                addDTO.setLastUpdateUserId(param.getUserId());
+                this.attendRuleDeviceManager.add(addDTO);
+            }
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u7f16\u8f91\u8003\u52e4\u8bbe\u5907\u5931\u8d25", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/rule/AttendRuleHolidayServiceImpl.java

@@ -0,0 +1,151 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleHolidayManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleManager
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleAddParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleEditParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleHolidayParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleQueryParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleHolidayQueryResult
+ *  cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleHolidayService
+ *  cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleHolidayDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleHolidayQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleHolidayQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ *  org.springframework.transaction.annotation.Transactional
+ */
+package cn.cloudwalk.service.ninca.attendance.rule;
+
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleHolidayManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleManager;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleAddParam;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleEditParam;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleHolidayParam;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleQueryParam;
+import cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleHolidayQueryResult;
+import cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleHolidayService;
+import cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleHolidayDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleHolidayQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleHolidayQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class AttendRuleHolidayServiceImpl
+extends AbstractCloudwalkService
+implements AttendRuleHolidayService {
+    @Resource
+    private AttendRuleManager attendRuleManager;
+    @Resource
+    private AttendRuleHolidayManager attendRuleHolidayManager;
+
+    @CloudwalkParamsValidate
+    public CloudwalkResult<List<AttendRuleHolidayQueryResult>> query(AttendRuleQueryParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            AttendRuleQueryDTO ruleQueryDTO = new AttendRuleQueryDTO();
+            ruleQueryDTO.setRuleId(param.getRuleId());
+            ruleQueryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            AttendRuleQueryResultDTO resultDTO = this.attendRuleManager.query(ruleQueryDTO);
+            if (resultDTO == null) {
+                return CloudwalkResult.fail((String)"76240213", (String)this.getMessage("76240213"));
+            }
+            AttendRuleHolidayQueryDTO queryDTO = new AttendRuleHolidayQueryDTO();
+            queryDTO.setRuleIds(Collections.singletonList(param.getRuleId()));
+            List holidayList = this.attendRuleHolidayManager.query(queryDTO);
+            return CloudwalkResult.success(this.setHolidayResult(holidayList));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u67e5\u8be2\u8003\u52e4\u89c4\u5219\u8282\u5047\u65e5\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private List<AttendRuleHolidayQueryResult> setHolidayResult(List<AttendRuleHolidayQueryResultDTO> holidayList) {
+        if (CollectionUtils.isEmpty(holidayList)) {
+            return new ArrayList<AttendRuleHolidayQueryResult>();
+        }
+        ArrayList<AttendRuleHolidayQueryResult> list = new ArrayList<AttendRuleHolidayQueryResult>(110);
+        for (AttendRuleHolidayQueryResultDTO holidayDTO : holidayList) {
+            AttendRuleHolidayQueryResult result = new AttendRuleHolidayQueryResult();
+            result.setHoliday(holidayDTO.getHolidayDate());
+            result.setType(holidayDTO.getType());
+            list.add(result);
+        }
+        return list;
+    }
+
+    @Transactional(rollbackFor={Exception.class})
+    @CloudwalkParamsValidate
+    public Integer add(AttendRuleAddParam param, String ruleId) throws ServiceException {
+        try {
+            return this.attendRuleHolidayManager.add(this.setHolidayDtoList(param, ruleId));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u65b0\u589e\u8003\u52e4\u89c4\u5219\u8282\u5047\u65e5\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @Transactional(rollbackFor={Exception.class})
+    @CloudwalkParamsValidate
+    public Integer edit(AttendRuleEditParam param) throws ServiceException {
+        try {
+            this.attendRuleHolidayManager.delete(param.getId());
+            AttendRuleAddParam addParam = (AttendRuleAddParam)BeanCopyUtils.copyProperties((Object)param, AttendRuleAddParam.class);
+            if (CollectionUtils.isNotEmpty((Collection)addParam.getHolidays())) {
+                return this.attendRuleHolidayManager.add(this.setHolidayDtoList(addParam, param.getId()));
+            }
+            return 0;
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u7f16\u8f91\u8003\u52e4\u89c4\u5219\u8282\u5047\u65e5\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private List<AttendRuleHolidayDTO> setHolidayDtoList(AttendRuleAddParam param, String ruleId) {
+        List holidayList = param.getHolidays();
+        ArrayList<AttendRuleHolidayDTO> dtoList = new ArrayList<AttendRuleHolidayDTO>(150);
+        for (AttendRuleHolidayParam holidayParam : holidayList) {
+            AttendRuleHolidayDTO dto = new AttendRuleHolidayDTO();
+            dto.setId(this.genUUID());
+            dto.setRuleId(ruleId);
+            dto.setType(holidayParam.getType());
+            dto.setHolidayDate(holidayParam.getHoliday());
+            dto.setCreateTime(param.getNowTime());
+            dto.setCreateUserId(param.getUserId());
+            dto.setLastUpdateTime(param.getNowTime());
+            dto.setLastUpdateUserId(param.getUserId());
+            dtoList.add(dto);
+        }
+        return dtoList;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/rule/AttendRuleImagestoreServiceImpl.java

@@ -0,0 +1,157 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleImagestoreManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStoreQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.result.ImageStoreListResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.service.ImageStoreService
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleAddParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleEditParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleQueryParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleImagestoreQueryResult
+ *  cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleImagestoreService
+ *  cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleImagestoreAddDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleImagestoreDeleteDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleImagestoreQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleImagestoreQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ *  org.springframework.transaction.annotation.Transactional
+ */
+package cn.cloudwalk.service.ninca.attendance.rule;
+
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleImagestoreManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStoreQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.result.ImageStoreListResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.service.ImageStoreService;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleAddParam;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleEditParam;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleQueryParam;
+import cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleImagestoreQueryResult;
+import cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleImagestoreService;
+import cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleImagestoreAddDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleImagestoreDeleteDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleImagestoreQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleImagestoreQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class AttendRuleImagestoreServiceImpl
+extends AbstractCloudwalkService
+implements AttendRuleImagestoreService {
+    @Resource
+    private AttendRuleImagestoreManager attendRuleImagestoreManager;
+    @Resource
+    private ImageStoreService imageStoreService;
+
+    public CloudwalkResult<List<AttendRuleImagestoreQueryResult>> query(AttendRuleQueryParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            AttendRuleImagestoreQueryDTO queryDTO = (AttendRuleImagestoreQueryDTO)BeanCopyUtils.copyProperties((Object)param, AttendRuleImagestoreQueryDTO.class);
+            List queryResultList = this.attendRuleImagestoreManager.query(queryDTO);
+            if (CollectionUtils.isEmpty((Collection)queryResultList)) {
+                return CloudwalkResult.success(new ArrayList());
+            }
+            List<AttendRuleImagestoreQueryResult> returnList = this.getQueryReturnList(queryResultList, cloudwalkContext);
+            return CloudwalkResult.success(returnList);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u67e5\u8be2\u8003\u52e4\u56fe\u5e93\u4fe1\u606f\u5931\u8d25", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private List<AttendRuleImagestoreQueryResult> getQueryReturnList(List<AttendRuleImagestoreQueryResultDTO> queryResultList, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        List imagestoreIds = queryResultList.stream().map(AttendRuleImagestoreQueryResultDTO::getImageStoreId).collect(Collectors.toList());
+        ImageStoreQueryParam queryParam = new ImageStoreQueryParam();
+        queryParam.setIds(imagestoreIds);
+        CloudwalkResult imagestoreResult = this.imageStoreService.list(queryParam, cloudwalkContext);
+        Map<String, List<ImageStoreListResult>> tmpImagestoreMap = null;
+        if (imagestoreResult.isSuccess() && CollectionUtils.isNotEmpty((Collection)((Collection)imagestoreResult.getData()))) {
+            tmpImagestoreMap = ((List)imagestoreResult.getData()).stream().collect(Collectors.groupingBy(ImageStoreListResult::getId));
+        }
+        ArrayList<AttendRuleImagestoreQueryResult> returnList = new ArrayList<AttendRuleImagestoreQueryResult>(queryResultList.size());
+        for (AttendRuleImagestoreQueryResultDTO dto : queryResultList) {
+            AttendRuleImagestoreQueryResult result = (AttendRuleImagestoreQueryResult)BeanCopyUtils.copyProperties((Object)dto, AttendRuleImagestoreQueryResult.class);
+            if (tmpImagestoreMap != null && CollectionUtils.isNotEmpty((Collection)tmpImagestoreMap.get(dto.getImageStoreId()))) {
+                result.setImageStoreName(tmpImagestoreMap.get(dto.getImageStoreId()).get(0).getName());
+            }
+            returnList.add(result);
+        }
+        return returnList;
+    }
+
+    @Transactional(rollbackFor={Exception.class})
+    @CloudwalkParamsValidate
+    public void add(AttendRuleAddParam param, String ruleId) throws ServiceException {
+        ArrayList imagestoreIds = new ArrayList();
+        long nowTime = System.currentTimeMillis();
+        try {
+            for (String imagestoreId : imagestoreIds) {
+                AttendRuleImagestoreAddDTO addDTO = new AttendRuleImagestoreAddDTO();
+                addDTO.setId(this.genUUID());
+                addDTO.setRuleId(ruleId);
+                addDTO.setImageStoreId(imagestoreId);
+                addDTO.setCreateTime(Long.valueOf(nowTime));
+                addDTO.setCreateUserId(param.getUserId());
+                addDTO.setLastUpdateTime(Long.valueOf(nowTime));
+                addDTO.setLastUpdateUserId(param.getUserId());
+                this.attendRuleImagestoreManager.add(addDTO);
+            }
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u65b0\u589e\u8003\u52e4\u56fe\u5e93\u5931\u8d25", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @Transactional(rollbackFor={Exception.class})
+    @CloudwalkParamsValidate
+    public void edit(AttendRuleEditParam param) throws ServiceException {
+        ArrayList imagestoreIds = new ArrayList();
+        long nowTime = System.currentTimeMillis();
+        try {
+            AttendRuleImagestoreDeleteDTO imagestoreDeleteDTO = new AttendRuleImagestoreDeleteDTO();
+            imagestoreDeleteDTO.setRuleId(param.getId());
+            this.attendRuleImagestoreManager.delete(imagestoreDeleteDTO);
+            for (String imagestoreId : imagestoreIds) {
+                AttendRuleImagestoreAddDTO addDTO = new AttendRuleImagestoreAddDTO();
+                addDTO.setId(this.genUUID());
+                addDTO.setRuleId(param.getId());
+                addDTO.setImageStoreId(imagestoreId);
+                addDTO.setCreateTime(Long.valueOf(nowTime));
+                addDTO.setCreateUserId(param.getUserId());
+                addDTO.setLastUpdateTime(Long.valueOf(nowTime));
+                addDTO.setLastUpdateUserId(param.getUserId());
+                this.attendRuleImagestoreManager.add(addDTO);
+            }
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u7f16\u8f91\u8003\u52e4\u56fe\u5e93\u5931\u8d25", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/rule/AttendRuleLabelServiceImpl.java

@@ -0,0 +1,143 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleLabelManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.label.param.LabelQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.label.result.LabelDetailResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.label.service.LabelService
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleEditParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleQueryParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleLabelQueryResult
+ *  cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleLabelService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleLabelAddDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleLabelQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleLabelQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.RuleLabelTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ *  org.springframework.transaction.annotation.Transactional
+ */
+package cn.cloudwalk.service.ninca.attendance.rule;
+
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleLabelManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.label.param.LabelQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.label.result.LabelDetailResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.label.service.LabelService;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleEditParam;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleQueryParam;
+import cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleLabelQueryResult;
+import cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleLabelService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleLabelAddDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleLabelQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleLabelQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.em.RuleLabelTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class AttendRuleLabelServiceImpl
+extends AbstractCloudwalkService
+implements AttendRuleLabelService {
+    @Resource
+    private AttendRuleLabelManager attendRuleLabelManager;
+    @Resource
+    private LabelService labelService;
+
+    public CloudwalkResult<List<AttendRuleLabelQueryResult>> query(AttendRuleQueryParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            AttendRuleLabelQueryDTO queryDTO = (AttendRuleLabelQueryDTO)BeanCopyUtils.copyProperties((Object)param, AttendRuleLabelQueryDTO.class);
+            List resultList = this.attendRuleLabelManager.query(queryDTO);
+            return CloudwalkResult.success(this.convertResult(resultList, cloudwalkContext));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u8003\u52e4\u89c4\u5219\u6807\u7b7e\u67e5\u8be2\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @Transactional(rollbackFor={Exception.class})
+    public void add(List<String> includeLabels, List<String> excludeLabels, String ruleId) throws ServiceException {
+        try {
+            AttendRuleLabelAddDTO addDTO;
+            if (CollectionUtils.isNotEmpty(includeLabels)) {
+                for (String label : includeLabels) {
+                    addDTO = this.getAddDTO(label, ruleId, RuleLabelTypeEnum.include.getCode());
+                    this.attendRuleLabelManager.add(addDTO);
+                }
+            }
+            if (CollectionUtils.isNotEmpty(excludeLabels)) {
+                for (String label : excludeLabels) {
+                    addDTO = this.getAddDTO(label, ruleId, RuleLabelTypeEnum.exclude.getCode());
+                    this.attendRuleLabelManager.add(addDTO);
+                }
+            }
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u8003\u52e4\u89c4\u5219\u6807\u7b7e\u65b0\u589e\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @Transactional(rollbackFor={Exception.class})
+    public void edit(AttendRuleEditParam param) throws ServiceException {
+        try {
+            this.attendRuleLabelManager.delete(param.getId());
+            this.add(param.getIncludeLabels(), param.getExcludeLabels(), param.getId());
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u8003\u52e4\u89c4\u5219\u6807\u7b7e\u7f16\u8f91\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private AttendRuleLabelAddDTO getAddDTO(String label, String ruleId, Integer type) {
+        AttendRuleLabelAddDTO addDTO = new AttendRuleLabelAddDTO();
+        addDTO.setId(this.genUUID());
+        addDTO.setLabelId(label);
+        addDTO.setRuleId(ruleId);
+        addDTO.setType(type);
+        addDTO.setCreateTime(Long.valueOf(System.currentTimeMillis()));
+        return addDTO;
+    }
+
+    private List<AttendRuleLabelQueryResult> convertResult(List<AttendRuleLabelQueryResultDTO> resultList, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        if (CollectionUtils.isEmpty(resultList)) {
+            return new ArrayList<AttendRuleLabelQueryResult>();
+        }
+        CloudwalkResult allLabelResult = this.labelService.getAll(new LabelQueryParam(), cloudwalkContext);
+        Map<String, List<LabelDetailResult>> map = null;
+        if (allLabelResult.isSuccess() && CollectionUtils.isNotEmpty((Collection)((Collection)allLabelResult.getData()))) {
+            map = ((List)allLabelResult.getData()).stream().collect(Collectors.groupingBy(LabelDetailResult::getId));
+        }
+        ArrayList<AttendRuleLabelQueryResult> returnResultList = new ArrayList<AttendRuleLabelQueryResult>();
+        for (AttendRuleLabelQueryResultDTO dto : resultList) {
+            AttendRuleLabelQueryResult result = (AttendRuleLabelQueryResult)BeanCopyUtils.copyProperties((Object)dto, AttendRuleLabelQueryResult.class);
+            if (map != null && map.get(dto.getLabelId()) != null) {
+                result.setLabelName(map.get(dto.getLabelId()).get(0).getName());
+            }
+            returnResultList.add(result);
+        }
+        return returnResultList;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/rule/AttendRuleOrgServiceImpl.java

@@ -0,0 +1,151 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleOrgManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.organization.param.OrganizationListParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.organization.result.OrganizationResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.organization.service.OrganizationService
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleAddParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleEditParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleQueryParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleOrgQueryResult
+ *  cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleOrgService
+ *  cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgAddDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ *  org.springframework.transaction.annotation.Transactional
+ */
+package cn.cloudwalk.service.ninca.attendance.rule;
+
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleOrgManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.organization.param.OrganizationListParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.organization.result.OrganizationResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.organization.service.OrganizationService;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleAddParam;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleEditParam;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleQueryParam;
+import cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleOrgQueryResult;
+import cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleOrgService;
+import cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgAddDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class AttendRuleOrgServiceImpl
+extends AbstractCloudwalkService
+implements AttendRuleOrgService {
+    @Resource
+    private AttendRuleOrgManager attendRuleOrgManager;
+    @Resource
+    private OrganizationService organizationService;
+
+    @Transactional(rollbackFor={Exception.class})
+    @CloudwalkParamsValidate
+    public void add(AttendRuleAddParam param, String ruleId) throws ServiceException {
+        try {
+            this.addOrg(param, ruleId);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u65b0\u589e\u8003\u52e4\u7ec4\u7ec7\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @Transactional(rollbackFor={Exception.class})
+    @CloudwalkParamsValidate
+    public void edit(AttendRuleEditParam param) throws ServiceException {
+        try {
+            this.attendRuleOrgManager.delete(param.getId());
+            if (CollectionUtils.isNotEmpty((Collection)param.getIncludeOrganizations())) {
+                AttendRuleAddParam addParam = (AttendRuleAddParam)BeanCopyUtils.copyProperties((Object)param, AttendRuleAddParam.class);
+                this.addOrg(addParam, param.getId());
+            }
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u4fee\u6539\u8003\u52e4\u7ec4\u7ec7\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<List<AttendRuleOrgQueryResult>> query(AttendRuleQueryParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            AttendRuleOrgQueryDTO queryDTO = new AttendRuleOrgQueryDTO();
+            queryDTO.setRuleIds(Collections.singletonList(param.getRuleId()));
+            List resultList = this.attendRuleOrgManager.query(queryDTO);
+            if (CollectionUtils.isEmpty((Collection)resultList)) {
+                return CloudwalkResult.success(new ArrayList());
+            }
+            return CloudwalkResult.success(this.convertQueryResult(resultList, cloudwalkContext));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u67e5\u8be2\u8003\u52e4\u7ec4\u7ec7\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private List<AttendRuleOrgQueryResult> convertQueryResult(List<AttendRuleOrgQueryResultDTO> queryResultList, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        List orgIds = queryResultList.stream().map(AttendRuleOrgQueryResultDTO::getOrgId).collect(Collectors.toList());
+        OrganizationListParam organizationListParam = new OrganizationListParam();
+        organizationListParam.setIds(orgIds);
+        CloudwalkResult list = this.organizationService.list(organizationListParam, cloudwalkContext);
+        Map<String, List<OrganizationResult>> map = null;
+        if (list.isSuccess() && CollectionUtils.isNotEmpty((Collection)((Collection)list.getData()))) {
+            map = ((List)list.getData()).stream().collect(Collectors.groupingBy(OrganizationResult::getId));
+        }
+        ArrayList<AttendRuleOrgQueryResult> resultList = new ArrayList<AttendRuleOrgQueryResult>(queryResultList.size());
+        for (AttendRuleOrgQueryResultDTO resultDTO : queryResultList) {
+            AttendRuleOrgQueryResult attendRuleOrgQueryResult = (AttendRuleOrgQueryResult)BeanCopyUtils.copyProperties((Object)resultDTO, AttendRuleOrgQueryResult.class);
+            if (map != null && CollectionUtils.isNotEmpty((Collection)map.get(resultDTO.getOrgId()))) {
+                attendRuleOrgQueryResult.setOrgName(map.get(resultDTO.getOrgId()).get(0).getName());
+            }
+            resultList.add(attendRuleOrgQueryResult);
+        }
+        return resultList;
+    }
+
+    private void addOrg(AttendRuleAddParam param, String ruleId) throws DataAccessException {
+        List orgIds = param.getIncludeOrganizations();
+        if (CollectionUtils.isEmpty((Collection)orgIds)) {
+            return;
+        }
+        for (String orgId : orgIds) {
+            AttendRuleOrgAddDTO dto = new AttendRuleOrgAddDTO();
+            dto.setId(this.genUUID());
+            dto.setRuleId(ruleId);
+            dto.setOrgId(orgId);
+            dto.setCreateTime(param.getNowTime());
+            dto.setCreateUserId(param.getUserId());
+            dto.setLastUpdateTime(param.getNowTime());
+            dto.setLastUpdateUserId(param.getUserId());
+            this.attendRuleOrgManager.add(dto);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/rule/AttendRuleSchedulingServiceImpl.java

@@ -0,0 +1,192 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleSchedulingManager
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleAddParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleEditParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleQueryParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleSchedulingSaveParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleScheduleQueryResult
+ *  cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleSchedulingService
+ *  cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleSchedulingDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleSchedulingDeleteDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleSchedulingQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.AttendUtil
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ *  org.springframework.transaction.annotation.Transactional
+ */
+package cn.cloudwalk.service.ninca.attendance.rule;
+
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleSchedulingManager;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleAddParam;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleEditParam;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleQueryParam;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleSchedulingSaveParam;
+import cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleScheduleQueryResult;
+import cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleSchedulingService;
+import cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleSchedulingDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleSchedulingDeleteDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleSchedulingQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.em.AttendTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.AttendUtil;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class AttendRuleSchedulingServiceImpl
+extends AbstractCloudwalkService
+implements AttendRuleSchedulingService {
+    @Resource
+    private AttendRuleManager attendRuleManager;
+    @Resource
+    private AttendRuleSchedulingManager attendRuleSchedulingManager;
+
+    @CloudwalkParamsValidate
+    public CloudwalkResult<List<AttendRuleScheduleQueryResult>> query(AttendRuleQueryParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            AttendRuleQueryDTO ruleQueryDTO = new AttendRuleQueryDTO();
+            ruleQueryDTO.setRuleId(param.getRuleId());
+            ruleQueryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            AttendRuleQueryResultDTO resultDTO = this.attendRuleManager.query(ruleQueryDTO);
+            if (resultDTO == null) {
+                return CloudwalkResult.fail((String)"76240213", (String)this.getMessage("76240213"));
+            }
+            AttendRuleSchedulingQueryDTO queryDTO = new AttendRuleSchedulingQueryDTO();
+            queryDTO.setRuleIds(Collections.singletonList(param.getRuleId()));
+            List resultDto = this.attendRuleSchedulingManager.query(queryDTO);
+            List resultList = BeanCopyUtils.copy((Collection)resultDto, AttendRuleScheduleQueryResult.class);
+            if (AttendTypeEnum.FLEXIBLE.getCode().equals(resultDTO.getType())) {
+                for (AttendRuleScheduleQueryResult result : resultList) {
+                    result.setStartAdaptTime(null);
+                    result.setEndAdaptTime(null);
+                }
+            } else {
+                for (AttendRuleScheduleQueryResult result : resultList) {
+                    result.setStartworkTime(AttendUtil.parseTime((String)result.getStartworkTime()).getTime());
+                    result.setEndworkTime(AttendUtil.parseTime((String)result.getEndworkTime()).getTime());
+                    result.setStartAdaptTime(AttendUtil.parseTime((String)result.getStartAdaptTime()).getTime());
+                    result.setEndAdaptTime(AttendUtil.parseTime((String)result.getEndAdaptTime()).getTime());
+                }
+            }
+            return CloudwalkResult.success((Object)resultList);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u67e5\u8be2\u8003\u52e4\u89c4\u5219\u6392\u73ed\u65f6\u95f4\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @Transactional(rollbackFor={Exception.class})
+    @CloudwalkParamsValidate
+    public void add(AttendRuleAddParam param, String ruleId) throws ServiceException {
+        int i = 0;
+        List schedulings = param.getSchedulings();
+        if (AttendTypeEnum.STANDARD.getCode().equals(param.getType())) {
+            this.formatRuleTime(param.getSchedulings());
+        }
+        for (AttendRuleSchedulingSaveParam saveParam : schedulings) {
+            AttendRuleSchedulingDTO dto = new AttendRuleSchedulingDTO();
+            dto.setId(this.genUUID());
+            dto.setRuleId(ruleId);
+            BeanCopyUtils.copyProperties((Object)saveParam, (Object)dto);
+            dto.setSchedulingDesc("\u73ed\u6b21" + ++i);
+            dto.setCreateTime(param.getNowTime());
+            dto.setCreateUserId(param.getUserId());
+            dto.setLastUpdateTime(param.getNowTime());
+            dto.setLastUpdateUserId(param.getUserId());
+            try {
+                this.attendRuleSchedulingManager.add(dto);
+            }
+            catch (DataAccessException e) {
+                this.logger.error("\u8003\u52e4\u89c4\u5219\u6392\u73ed\u65f6\u95f4\u65b0\u589e\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+                throw new ServiceException((Throwable)e);
+            }
+        }
+    }
+
+    private void formatRuleTime(List<AttendRuleSchedulingSaveParam> schedulings) {
+        schedulings.sort(Comparator.comparingInt(AttendRuleSchedulingSaveParam::getSortValue));
+        String firstStartWorkTime = schedulings.get(0).getStartworkTime();
+        String firstStartAdaptTime = schedulings.get(0).getStartAdaptTime();
+        for (AttendRuleSchedulingSaveParam saveParam : schedulings) {
+            if (AttendUtil.compare((String)saveParam.getStartworkTime(), (String)firstStartWorkTime) < 0) {
+                saveParam.setStartworkTime(saveParam.getStartworkTime() + "+" + 1);
+            } else {
+                saveParam.setStartworkTime(saveParam.getStartworkTime() + "+" + 0);
+            }
+            if (AttendUtil.compare((String)saveParam.getEndworkTime(), (String)firstStartWorkTime) < 0) {
+                saveParam.setEndworkTime(saveParam.getEndworkTime() + "+" + 1);
+            } else {
+                saveParam.setEndworkTime(saveParam.getEndworkTime() + "+" + 0);
+            }
+            if (AttendUtil.compare((String)saveParam.getStartAdaptTime(), (String)firstStartAdaptTime) < 0) {
+                saveParam.setStartAdaptTime(saveParam.getStartAdaptTime() + "+" + 1);
+            } else {
+                saveParam.setStartAdaptTime(saveParam.getStartAdaptTime() + "+" + 0);
+            }
+            if (AttendUtil.compare((String)saveParam.getEndAdaptTime(), (String)firstStartAdaptTime) < 0) {
+                saveParam.setEndAdaptTime(saveParam.getEndAdaptTime() + "+" + 1);
+                continue;
+            }
+            saveParam.setEndAdaptTime(saveParam.getEndAdaptTime() + "+" + 0);
+        }
+    }
+
+    @CloudwalkParamsValidate
+    @Transactional(rollbackFor={Exception.class})
+    public void edit(AttendRuleEditParam param) throws ServiceException {
+        try {
+            AttendRuleSchedulingDeleteDTO deleteDTO = new AttendRuleSchedulingDeleteDTO();
+            deleteDTO.setRuleId(param.getId());
+            this.attendRuleSchedulingManager.delete(deleteDTO);
+            if (AttendTypeEnum.STANDARD.getCode().equals(param.getType())) {
+                this.formatRuleTime(param.getSchedulings());
+            }
+            int i = 0;
+            for (AttendRuleSchedulingSaveParam saveParam : param.getSchedulings()) {
+                AttendRuleSchedulingDTO dto = new AttendRuleSchedulingDTO();
+                dto.setId(this.genUUID());
+                dto.setRuleId(param.getId());
+                BeanCopyUtils.copyProperties((Object)saveParam, (Object)dto);
+                dto.setSchedulingDesc("\u73ed\u6b21" + ++i);
+                dto.setCreateTime(param.getNowTime());
+                dto.setCreateUserId(param.getUserId());
+                dto.setLastUpdateTime(param.getNowTime());
+                dto.setLastUpdateUserId(param.getUserId());
+                this.attendRuleSchedulingManager.add(dto);
+            }
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u8003\u52e4\u89c4\u5219\u6392\u73ed\u65f6\u95f4\u4fee\u6539\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/rule/AttendRuleServiceImpl.java

@@ -0,0 +1,488 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleDeviceManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleOrgManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleSchedulingManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.result.DeviceResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.organization.param.OrganizationListParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.organization.result.OrganizationResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.organization.service.OrganizationService
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendOrgCheckParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleAddParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleDeleteParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleEditParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRulePageQueryParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleQueryParam
+ *  cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleDeviceQueryResult
+ *  cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleInfoQueryResult
+ *  cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleOrgQueryResult
+ *  cn.cloudwalk.client.ninca.attendance.rule.result.AttendRulePageResult
+ *  cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleScheduleQueryResult
+ *  cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleCheckService
+ *  cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleDeviceService
+ *  cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleHolidayService
+ *  cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleLabelService
+ *  cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleOrgService
+ *  cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleSchedulingService
+ *  cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleService
+ *  cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleShotService
+ *  cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.page.CloudwalkPageAble
+ *  cn.cloudwalk.cloud.page.CloudwalkPageInfo
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleGetsDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRulePageDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleSchedulingQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleSchedulingQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum
+ *  cn.cloudwalk.common.ninca.attendance.util.AttendUtil
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ *  org.springframework.transaction.annotation.Transactional
+ */
+package cn.cloudwalk.service.ninca.attendance.rule;
+
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleDeviceManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleOrgManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleSchedulingManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.result.DeviceResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.organization.param.OrganizationListParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.organization.result.OrganizationResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.organization.service.OrganizationService;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendOrgCheckParam;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleAddParam;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleDeleteParam;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleEditParam;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRulePageQueryParam;
+import cn.cloudwalk.client.ninca.attendance.rule.param.AttendRuleQueryParam;
+import cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleDeviceQueryResult;
+import cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleInfoQueryResult;
+import cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleOrgQueryResult;
+import cn.cloudwalk.client.ninca.attendance.rule.result.AttendRulePageResult;
+import cn.cloudwalk.client.ninca.attendance.rule.result.AttendRuleScheduleQueryResult;
+import cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleCheckService;
+import cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleDeviceService;
+import cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleHolidayService;
+import cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleLabelService;
+import cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleOrgService;
+import cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleSchedulingService;
+import cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleService;
+import cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleShotService;
+import cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.page.CloudwalkPageAble;
+import cn.cloudwalk.cloud.page.CloudwalkPageInfo;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleGetsDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRulePageDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleSchedulingQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleSchedulingQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.em.YesNoTypeEnum;
+import cn.cloudwalk.common.ninca.attendance.util.AttendUtil;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractAttendService;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class AttendRuleServiceImpl
+extends AbstractAttendService
+implements AttendRuleService {
+    @Resource
+    private AttendRuleManager attendRuleManager;
+    @Resource
+    private AttendRuleHolidayService attendRuleHolidayService;
+    @Resource
+    private AttendRuleSchedulingService attendRuleSchedulingService;
+    @Resource
+    private AttendRuleShotService attendRuleShotService;
+    @Resource
+    private AttendRuleSchedulingManager attendRuleSchedulingManager;
+    @Resource
+    private AttendRuleDeviceManager attendRuleDeviceManager;
+    @Resource
+    private AttendRuleDeviceService attendRuleDeviceService;
+    @Resource
+    private DeviceService deviceService;
+    @Resource
+    private AttendRuleOrgService attendRuleOrgService;
+    @Resource
+    private AttendRuleOrgManager attendRuleOrgManager;
+    @Resource
+    private OrganizationService organizationService;
+    @Resource
+    private AttendRuleCheckService attendRuleCheckService;
+    @Resource
+    private AttendRuleLabelService attendRuleLabelService;
+
+    @CloudwalkParamsValidate(argsIndexs={0, 1})
+    public CloudwalkResult<CloudwalkPageAble<AttendRulePageResult>> page(AttendRulePageQueryParam param, CloudwalkPageInfo page, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            AttendRulePageDTO queryDTO = (AttendRulePageDTO)BeanCopyUtils.copyProperties((Object)param, AttendRulePageDTO.class);
+            queryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            CloudwalkPageAble list = this.attendRuleManager.page(page, queryDTO);
+            if (CollectionUtils.isEmpty((Collection)list.getDatas())) {
+                return CloudwalkResult.success((Object)new CloudwalkPageAble(new ArrayList(), page, 0L));
+            }
+            List<AttendRulePageResult> result = this.convertPageResult(list.getDatas(), cloudwalkContext);
+            return CloudwalkResult.success((Object)new CloudwalkPageAble(result, page, list.getTotalRows()));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u5206\u9875\u67e5\u8be2\u8003\u52e4\u89c4\u5219\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @Transactional(rollbackFor={Exception.class})
+    @CloudwalkParamsValidate
+    public CloudwalkResult<Boolean> delete(AttendRuleDeleteParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            AttendRuleGetsDTO ruleGetsDTO = new AttendRuleGetsDTO();
+            ruleGetsDTO.setRuleIds(param.getIds());
+            ruleGetsDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            List gets = this.attendRuleManager.gets(ruleGetsDTO);
+            if (CollectionUtils.isNotEmpty((Collection)gets)) {
+                for (AttendRuleQueryResultDTO dto : gets) {
+                    if (YesNoTypeEnum.N.getCode().equals(dto.getStatus())) continue;
+                    AttendRuleDTO updateDTO = new AttendRuleDTO();
+                    updateDTO.setId(dto.getId());
+                    updateDTO.setStatus(YesNoTypeEnum.N.getCode());
+                    updateDTO.setLastUpdateTime(Long.valueOf(System.currentTimeMillis()));
+                    updateDTO.setLastUpdateUserId(cloudwalkContext.getUser().getCaller());
+                    this.attendRuleManager.delete(Collections.singletonList(updateDTO));
+                    super.ruleDeleteCwos(dto.getId(), cloudwalkContext);
+                }
+            }
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u5220\u9664\u8003\u52e4\u89c4\u5219\u67e5\u8be2\u8003\u52e4\u89c4\u5219\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+        return CloudwalkResult.success((Object)true);
+    }
+
+    @CloudwalkParamsValidate
+    public CloudwalkResult<AttendRuleInfoQueryResult> queryInfo(AttendRuleQueryParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            AttendRuleQueryDTO ruleQueryDTO = new AttendRuleQueryDTO();
+            ruleQueryDTO.setRuleId(param.getRuleId());
+            ruleQueryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            AttendRuleQueryResultDTO resultDTO = this.attendRuleManager.query(ruleQueryDTO);
+            if (resultDTO == null) {
+                return CloudwalkResult.fail((String)"76240213", (String)this.getMessage("76240213"));
+            }
+            return CloudwalkResult.success((Object)BeanCopyUtils.copyProperties((Object)resultDTO, AttendRuleInfoQueryResult.class));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u67e5\u8be2\u8003\u52e4\u89c4\u5219\u57fa\u672c\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @Transactional(rollbackFor={Exception.class})
+    @CloudwalkParamsValidate
+    public CloudwalkResult<Boolean> add(AttendRuleAddParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            AttendRuleQueryDTO ruleQueryDTO = new AttendRuleQueryDTO();
+            ruleQueryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            ruleQueryDTO.setName(param.getName());
+            ruleQueryDTO.setStatus(YesNoTypeEnum.Y.getCode());
+            List ruleQueryResultList = this.attendRuleManager.queryList(ruleQueryDTO);
+            if (CollectionUtils.isNotEmpty((Collection)ruleQueryResultList)) {
+                this.logger.error("\u8003\u52e4\u89c4\u5219\u65b0\u589e\uff0c\u53c2\u6570\u6821\u9a8c\u5931\u8d25\uff0c\u539f\u56e0\uff1a\u8003\u52e4\u540d\u79f0\u5df2\u5b58\u5728");
+                return CloudwalkResult.fail((String)"76240251", (String)this.getMessage("76240251"));
+            }
+            if (CollectionUtils.isEmpty((Collection)param.getIncludeOrganizations()) && CollectionUtils.isEmpty((Collection)param.getIncludeLabels())) {
+                this.logger.error("\u8003\u52e4\u89c4\u5219\u65b0\u589e\uff0c\u53c2\u6570\u6821\u9a8c\u5931\u8d25\uff0c\u539f\u56e0\uff1a\u5305\u542b\u673a\u6784\u548c\u5305\u542b\u6807\u7b7e\u4e0d\u80fd\u540c\u65f6\u4e3a\u7a7a");
+                return CloudwalkResult.fail((String)"76240255", (String)this.getMessage("76240255"));
+            }
+            CloudwalkResult checkResult = this.attendRuleCheckService.check(param.getType(), param.getSchedulings());
+            if (!checkResult.isSuccess()) {
+                this.logger.error("\u8003\u52e4\u89c4\u5219\u65b0\u589e\uff0c\u53c2\u6570\u6821\u9a8c\u5931\u8d25\uff0c\u539f\u56e0\uff1a{}", (Object)checkResult.getMessage());
+                return checkResult;
+            }
+            if (CollectionUtils.isNotEmpty((Collection)param.getIncludeOrganizations())) {
+                AttendOrgCheckParam orgCheckParam = new AttendOrgCheckParam();
+                orgCheckParam.setOrgIds(param.getIncludeOrganizations());
+                CloudwalkResult<List<String>> orgCheckResult = this.orgCheck(orgCheckParam, cloudwalkContext);
+                if (CollectionUtils.isNotEmpty((Collection)((Collection)orgCheckResult.getData()))) {
+                    this.logger.error("\u8003\u52e4\u89c4\u5219\u65b0\u589e\uff0c\u7ec4\u7ec7\u6821\u9a8c\u5931\u8d25\uff0c\u539f\u56e0\uff1a\u5b58\u5728\u4e0d\u53ef\u7528\u7684\u7ec4\u7ec7");
+                    return CloudwalkResult.fail((String)"76240242", (String)this.getMessage("76240242"));
+                }
+            }
+            param.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            param.setUserId(cloudwalkContext.getUser().getCaller());
+            param.setNowTime(Long.valueOf(System.currentTimeMillis()));
+            String ruleId = this.genUUID();
+            this.addRuleInfo(param, ruleId, cloudwalkContext);
+            if (CollectionUtils.isNotEmpty((Collection)param.getHolidays())) {
+                this.attendRuleHolidayService.add(param, ruleId);
+            }
+            this.attendRuleSchedulingService.add(param, ruleId);
+            this.attendRuleDeviceService.add(param, ruleId);
+            this.attendRuleOrgService.add(param, ruleId);
+            this.attendRuleLabelService.add(param.getIncludeLabels(), param.getExcludeLabels(), ruleId);
+            CloudwalkResult shotResult = this.attendRuleShotService.addShot(ruleId, cloudwalkContext);
+            AttendRuleDTO ruleEditDto = new AttendRuleDTO();
+            ruleEditDto.setId(ruleId);
+            ruleEditDto.setShotId((String)shotResult.getData());
+            this.attendRuleManager.edit(ruleEditDto);
+            super.saveCwosTransaction(ruleId, param.getName(), param.getDeviceIds(), param.getIncludeOrganizations(), cloudwalkContext);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u65b0\u589e\u8003\u52e4\u89c4\u5219\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+        return CloudwalkResult.success((Object)true);
+    }
+
+    @Transactional(rollbackFor={Exception.class})
+    @CloudwalkParamsValidate
+    public CloudwalkResult<Boolean> edit(AttendRuleEditParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            List existIds;
+            AttendRuleQueryDTO ruleListQueryDTO = new AttendRuleQueryDTO();
+            ruleListQueryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            ruleListQueryDTO.setName(param.getName());
+            ruleListQueryDTO.setStatus(YesNoTypeEnum.Y.getCode());
+            List ruleQueryResultList = this.attendRuleManager.queryList(ruleListQueryDTO);
+            if (CollectionUtils.isNotEmpty((Collection)ruleQueryResultList) && CollectionUtils.isNotEmpty(existIds = ruleQueryResultList.stream().map(AttendRuleQueryResultDTO::getId).filter(item -> !item.equals(param.getId())).collect(Collectors.toList()))) {
+                return CloudwalkResult.fail((String)"76240251", (String)this.getMessage("76240251"));
+            }
+            if (CollectionUtils.isEmpty((Collection)param.getIncludeOrganizations()) && CollectionUtils.isEmpty((Collection)param.getIncludeLabels())) {
+                this.logger.error("\u8003\u52e4\u89c4\u5219\u7f16\u8f91\uff0c\u53c2\u6570\u6821\u9a8c\u5931\u8d25\uff0c\u539f\u56e0\uff1a\u5305\u542b\u673a\u6784\u548c\u5305\u542b\u6807\u7b7e\u4e0d\u80fd\u540c\u65f6\u4e3a\u7a7a");
+                return CloudwalkResult.fail((String)"76240255", (String)this.getMessage("76240255"));
+            }
+            CloudwalkResult checkResult = this.attendRuleCheckService.check(param.getType(), param.getSchedulings());
+            if (!checkResult.isSuccess()) {
+                this.logger.error("\u8003\u52e4\u89c4\u5219\u7f16\u8f91\uff0c\u53c2\u6570\u6821\u9a8c\u5931\u8d25\uff0c\u539f\u56e0\uff1a{}", (Object)checkResult.getMessage());
+                return checkResult;
+            }
+            if (CollectionUtils.isNotEmpty((Collection)param.getIncludeOrganizations())) {
+                AttendOrgCheckParam orgCheckParam = new AttendOrgCheckParam();
+                orgCheckParam.setOrgIds(param.getIncludeOrganizations());
+                orgCheckParam.setRuleId(param.getId());
+                CloudwalkResult<List<String>> orgCheckResult = this.orgCheck(orgCheckParam, cloudwalkContext);
+                if (CollectionUtils.isNotEmpty((Collection)((Collection)orgCheckResult.getData()))) {
+                    this.logger.error("\u8003\u52e4\u89c4\u5219\u7f16\u8f91\uff0c\u7ec4\u7ec7\u6821\u9a8c\u5931\u8d25\uff0c\u539f\u56e0\uff1a\u5b58\u5728\u4e0d\u53ef\u7528\u7684\u7ec4\u7ec7");
+                    return CloudwalkResult.fail((String)"76240242", (String)this.getMessage("76240242"));
+                }
+            }
+            AttendRuleQueryDTO ruleQueryDTO = new AttendRuleQueryDTO();
+            ruleQueryDTO.setRuleId(param.getId());
+            ruleQueryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            AttendRuleQueryResultDTO resultDTO = this.attendRuleManager.query(ruleQueryDTO);
+            if (resultDTO == null) {
+                this.logger.error("\u7f16\u8f91\u8003\u52e4\u89c4\u5219\u5931\u8d25\uff0c\u539f\u56e0\uff1a\u6ca1\u6709\u67e5\u8be2\u5230\u8003\u52e4\u89c4\u5219");
+                return CloudwalkResult.fail((String)"76240213", (String)this.getMessage("76240213"));
+            }
+            AttendRuleDeviceQueryDTO deviceQueryDTO = new AttendRuleDeviceQueryDTO();
+            deviceQueryDTO.setRuleId(param.getId());
+            List deviceList = this.attendRuleDeviceManager.query(deviceQueryDTO);
+            List cwosDeviceIds = deviceList.stream().map(AttendRuleDeviceQueryResultDTO::getDeviceId).collect(Collectors.toList());
+            param.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            param.setUserId(cloudwalkContext.getUser().getCaller());
+            param.setNowTime(Long.valueOf(System.currentTimeMillis()));
+            this.editRuleInfo(param);
+            if (param.getHolidays() != null) {
+                this.attendRuleHolidayService.edit(param);
+            }
+            this.attendRuleSchedulingService.edit(param);
+            this.attendRuleDeviceService.edit(param);
+            this.attendRuleOrgService.edit(param);
+            this.attendRuleLabelService.edit(param);
+            CloudwalkResult shotResult = this.attendRuleShotService.addShot(resultDTO.getId(), cloudwalkContext);
+            AttendRuleDTO ruleEditDto = new AttendRuleDTO();
+            ruleEditDto.setId(param.getId());
+            ruleEditDto.setShotId((String)shotResult.getData());
+            this.attendRuleManager.edit(ruleEditDto);
+            ArrayList<String> unBindDeviceList = new ArrayList<String>();
+            for (String oldDeviceId : cwosDeviceIds) {
+                if (param.getDeviceIds().contains(oldDeviceId)) continue;
+                unBindDeviceList.add(oldDeviceId);
+            }
+            ArrayList<String> newDeviceList = new ArrayList<String>();
+            for (String deviceId : param.getDeviceIds()) {
+                if (cwosDeviceIds.contains(deviceId)) continue;
+                newDeviceList.add(deviceId);
+            }
+            super.ruleEditCwos(param.getId(), unBindDeviceList, cloudwalkContext);
+            this.saveCwos(param.getId(), param.getName(), newDeviceList, param.getIncludeOrganizations(), cloudwalkContext);
+            return CloudwalkResult.success((Object)true);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u7f16\u8f91\u8003\u52e4\u89c4\u5219\u5931\u8d25\uff0c\u67e5\u8be2\u8003\u52e4\u89c4\u5219\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private void addRuleInfo(AttendRuleAddParam param, String ruleId, CloudwalkCallContext cloudwalkContext) throws DataAccessException {
+        AttendRuleDTO dto = new AttendRuleDTO();
+        dto.setId(ruleId);
+        dto.setOrgId("");
+        dto.setOrgName("");
+        dto.setName(param.getName());
+        dto.setType(param.getType());
+        dto.setStatus(YesNoTypeEnum.Y.getCode());
+        dto.setMinOvertime(param.getMinOvertime());
+        dto.setMaxOvertime(param.getMaxOvertime());
+        dto.setAllowDayoffOvertime(param.getAllowDayoffOvertime());
+        dto.setDayoffMinOvertime(param.getDayoffMinOvertime());
+        dto.setAllowWorkingOvertime(param.getAllowWorkingOvertime());
+        dto.setStartOvertime(param.getStartOvertime());
+        dto.setCreateTime(param.getNowTime());
+        dto.setCreateUserId(param.getUserId());
+        dto.setLastUpdateTime(param.getNowTime());
+        dto.setLastUpdateUserId(param.getUserId());
+        dto.setBusinessId(param.getBusinessId());
+        dto.setRemark(param.getRemark());
+        this.attendRuleManager.add(dto);
+    }
+
+    private void editRuleInfo(AttendRuleEditParam param) throws DataAccessException {
+        AttendRuleDTO dto = new AttendRuleDTO();
+        dto.setId(param.getId());
+        dto.setName(param.getName());
+        dto.setType(param.getType());
+        dto.setRemark(param.getRemark());
+        dto.setLastUpdateTime(param.getNowTime());
+        dto.setLastUpdateUserId(param.getUserId());
+        dto.setMinOvertime(param.getMinOvertime());
+        dto.setMaxOvertime(param.getMaxOvertime());
+        dto.setAllowDayoffOvertime(param.getAllowDayoffOvertime());
+        dto.setDayoffMinOvertime(param.getDayoffMinOvertime());
+        dto.setAllowWorkingOvertime(param.getAllowWorkingOvertime());
+        dto.setStartOvertime(param.getStartOvertime());
+        this.attendRuleManager.edit(dto);
+    }
+
+    private List<AttendRulePageResult> convertPageResult(Collection<AttendRuleQueryResultDTO> datas, CloudwalkCallContext cloudwalkContext) throws DataAccessException, ServiceException {
+        List ruleIds = datas.stream().map(AttendRuleQueryResultDTO::getId).collect(Collectors.toList());
+        AttendRuleSchedulingQueryDTO schedulingQueryDTO = new AttendRuleSchedulingQueryDTO();
+        schedulingQueryDTO.setRuleIds(ruleIds);
+        List schedulingResultList = this.attendRuleSchedulingManager.query(schedulingQueryDTO);
+        this.setSchedulingTimeDesc(schedulingResultList);
+        ArrayList<AttendRulePageResult> resultList = new ArrayList<AttendRulePageResult>(datas.size());
+        Map<String, List<AttendRuleSchedulingQueryResultDTO>> schedulingTmpMap = schedulingResultList.stream().collect(Collectors.groupingBy(AttendRuleSchedulingQueryResultDTO::getRuleId));
+        AttendRuleDeviceQueryDTO deviceQueryDTO = new AttendRuleDeviceQueryDTO();
+        deviceQueryDTO.setRuleIds(ruleIds);
+        List deviceResultList = this.attendRuleDeviceManager.query(deviceQueryDTO);
+        Map<String, List<AttendRuleDeviceQueryResultDTO>> deviceTmpMap = deviceResultList.stream().collect(Collectors.groupingBy(AttendRuleDeviceQueryResultDTO::getRuleId));
+        AttendRuleOrgQueryDTO orgQueryDTO = new AttendRuleOrgQueryDTO();
+        orgQueryDTO.setRuleIds(ruleIds);
+        List orgResultList = this.attendRuleOrgManager.query(orgQueryDTO);
+        Map<String, List<AttendRuleOrgQueryResultDTO>> orgTmpMap = orgResultList.stream().collect(Collectors.groupingBy(AttendRuleOrgQueryResultDTO::getRuleId));
+        List<String> deviceIds = deviceResultList.stream().map(AttendRuleDeviceQueryResultDTO::getDeviceId).collect(Collectors.toList());
+        Map<String, List<DeviceResult>> cwosDeviceMap = this.getDeviceList(deviceIds, cloudwalkContext);
+        List<String> orgIds = orgResultList.stream().map(AttendRuleOrgQueryResultDTO::getOrgId).collect(Collectors.toList());
+        Map<String, List<OrganizationResult>> cwosOrgMap = this.getOrgList(orgIds, cloudwalkContext);
+        for (AttendRuleQueryResultDTO resultDTO : datas) {
+            AttendRulePageResult result = (AttendRulePageResult)BeanCopyUtils.copyProperties((Object)resultDTO, AttendRulePageResult.class);
+            if (CollectionUtils.isNotEmpty((Collection)schedulingTmpMap.get(resultDTO.getId()))) {
+                result.setSchedulingList(BeanCopyUtils.copy((Collection)schedulingTmpMap.get(resultDTO.getId()), AttendRuleScheduleQueryResult.class));
+            }
+            if (CollectionUtils.isNotEmpty((Collection)deviceTmpMap.get(resultDTO.getId()))) {
+                List<AttendRuleDeviceQueryResult> deviceResult = this.getDeviceResultList(deviceTmpMap.get(resultDTO.getId()), cwosDeviceMap);
+                result.setDeviceList(deviceResult);
+            }
+            if (CollectionUtils.isNotEmpty((Collection)orgTmpMap.get(resultDTO.getId()))) {
+                List<AttendRuleOrgQueryResult> orgResult = this.getOrgResultList(orgTmpMap.get(resultDTO.getId()), cwosOrgMap);
+                result.setOrgList(orgResult);
+            }
+            resultList.add(result);
+        }
+        return resultList;
+    }
+
+    private void setSchedulingTimeDesc(List<AttendRuleSchedulingQueryResultDTO> schedulingResultList) {
+        for (AttendRuleSchedulingQueryResultDTO dto : schedulingResultList) {
+            dto.setStartworkTime(AttendUtil.getTimeFormatDesc((String)dto.getStartworkTime()));
+            dto.setEndworkTime(AttendUtil.getTimeFormatDesc((String)dto.getEndworkTime()));
+            dto.setStartAdaptTime(AttendUtil.getTimeFormatDesc((String)dto.getStartAdaptTime()));
+            dto.setEndAdaptTime(AttendUtil.getTimeFormatDesc((String)dto.getEndAdaptTime()));
+        }
+    }
+
+    private List<AttendRuleOrgQueryResult> getOrgResultList(List<AttendRuleOrgQueryResultDTO> resultList, Map<String, List<OrganizationResult>> cwosOrgMap) {
+        ArrayList<AttendRuleOrgQueryResult> returnResultList = new ArrayList<AttendRuleOrgQueryResult>(resultList.size());
+        for (AttendRuleOrgQueryResultDTO dto : resultList) {
+            AttendRuleOrgQueryResult result = (AttendRuleOrgQueryResult)BeanCopyUtils.copyProperties((Object)dto, AttendRuleOrgQueryResult.class);
+            if (cwosOrgMap != null && CollectionUtils.isNotEmpty((Collection)cwosOrgMap.get(dto.getOrgId()))) {
+                OrganizationResult orgResult = cwosOrgMap.get(dto.getOrgId()).get(0);
+                result.setOrgName(orgResult.getName());
+            }
+            returnResultList.add(result);
+        }
+        return returnResultList;
+    }
+
+    private Map<String, List<OrganizationResult>> getOrgList(List<String> orgIds, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        OrganizationListParam queryParam = new OrganizationListParam();
+        queryParam.setIds(orgIds);
+        CloudwalkResult orgResult = this.organizationService.list(queryParam, cloudwalkContext);
+        if (orgResult.isSuccess() && CollectionUtils.isNotEmpty((Collection)((Collection)orgResult.getData()))) {
+            return ((List)orgResult.getData()).stream().collect(Collectors.groupingBy(OrganizationResult::getId));
+        }
+        return null;
+    }
+
+    private List<AttendRuleDeviceQueryResult> getDeviceResultList(List<AttendRuleDeviceQueryResultDTO> resultList, Map<String, List<DeviceResult>> cwosDeviceMap) {
+        ArrayList<AttendRuleDeviceQueryResult> returnResultList = new ArrayList<AttendRuleDeviceQueryResult>(resultList.size());
+        for (AttendRuleDeviceQueryResultDTO dto : resultList) {
+            AttendRuleDeviceQueryResult result = (AttendRuleDeviceQueryResult)BeanCopyUtils.copyProperties((Object)dto, AttendRuleDeviceQueryResult.class);
+            if (cwosDeviceMap != null && CollectionUtils.isNotEmpty((Collection)cwosDeviceMap.get(dto.getDeviceId()))) {
+                result.setDeviceName(cwosDeviceMap.get(dto.getDeviceId()).get(0).getDeviceName());
+            }
+            returnResultList.add(result);
+        }
+        return returnResultList;
+    }
+
+    private Map<String, List<DeviceResult>> getDeviceList(List<String> deviceIds, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        DeviceQueryParam deviceQueryParam = new DeviceQueryParam();
+        deviceQueryParam.setIds(deviceIds);
+        CloudwalkResult deviceResult = this.deviceService.list(deviceQueryParam, cloudwalkContext);
+        if (deviceResult.isSuccess() && CollectionUtils.isNotEmpty((Collection)((Collection)deviceResult.getData()))) {
+            return ((List)deviceResult.getData()).stream().collect(Collectors.groupingBy(DeviceResult::getId));
+        }
+        return null;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/rule/AttendRuleShotServiceImpl.java

@@ -0,0 +1,172 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleDeviceManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleHolidayManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleImagestoreManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleLabelManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleOrgManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleOrgShotManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleSchedulingManager
+ *  cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleShotManager
+ *  cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleShotService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceShotAddDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleHolidayQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleHolidayShotAddDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleLabelQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleLabelShotAddDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgShotAddDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryResultDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleSchedulingQueryDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleSchedulingShotAddDTO
+ *  cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleShotAddDTO
+ *  cn.cloudwalk.common.ninca.attendance.util.CollectionUtils
+ *  javax.annotation.Resource
+ *  org.springframework.stereotype.Service
+ *  org.springframework.transaction.annotation.Transactional
+ */
+package cn.cloudwalk.service.ninca.attendance.rule;
+
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleDeviceManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleHolidayManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleImagestoreManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleLabelManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleOrgManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleOrgShotManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleSchedulingManager;
+import cn.cloudwalk.biz.intelligent.ninca.rule.AttendRuleShotManager;
+import cn.cloudwalk.client.ninca.attendance.rule.service.AttendRuleShotService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.DataAccessException;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleDeviceShotAddDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleHolidayQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleHolidayShotAddDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleLabelQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleLabelShotAddDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleOrgShotAddDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleQueryResultDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleSchedulingQueryDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleSchedulingShotAddDTO;
+import cn.cloudwalk.common.ninca.attendance.bean.rule.AttendRuleShotAddDTO;
+import cn.cloudwalk.common.ninca.attendance.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import javax.annotation.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class AttendRuleShotServiceImpl
+extends AbstractCloudwalkService
+implements AttendRuleShotService {
+    @Resource
+    private AttendRuleManager attendRuleManager;
+    @Resource
+    private AttendRuleShotManager attendRuleShotManager;
+    @Resource
+    private AttendRuleHolidayManager attendRuleHolidayManager;
+    @Resource
+    private AttendRuleSchedulingManager attendRuleSchedulingManager;
+    @Resource
+    private AttendRuleDeviceManager attendRuleDeviceManager;
+    @Resource
+    private AttendRuleImagestoreManager attendRuleImagestoreManager;
+    @Resource
+    private AttendRuleOrgManager attendRuleOrgManager;
+    @Resource
+    private AttendRuleOrgShotManager attendRuleOrgShotManager;
+    @Resource
+    private AttendRuleLabelManager attendRuleLabelManager;
+
+    @Transactional(rollbackFor={Exception.class})
+    public CloudwalkResult<String> addShot(String ruleId, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            String shotId = this.genUUID();
+            this.addRuleShot(ruleId, shotId, cloudwalkContext);
+            AttendRuleHolidayQueryDTO holidayQueryDTO = new AttendRuleHolidayQueryDTO();
+            holidayQueryDTO.setRuleIds(Collections.singletonList(ruleId));
+            List holidayList = this.attendRuleHolidayManager.query(holidayQueryDTO);
+            if (CollectionUtils.isNotEmpty((Collection)holidayList)) {
+                List ruleHolidayList = BeanCopyUtils.copy((Collection)holidayList, AttendRuleHolidayShotAddDTO.class);
+                for (AttendRuleHolidayShotAddDTO dto : ruleHolidayList) {
+                    dto.setShotId(shotId);
+                }
+                this.attendRuleShotManager.addHoliday(ruleHolidayList);
+            }
+            AttendRuleSchedulingQueryDTO schedulingQueryDTO = new AttendRuleSchedulingQueryDTO();
+            schedulingQueryDTO.setRuleIds(Collections.singletonList(ruleId));
+            List schedulingList = this.attendRuleSchedulingManager.query(schedulingQueryDTO);
+            List schedulingAddList = BeanCopyUtils.copy((Collection)schedulingList, AttendRuleSchedulingShotAddDTO.class);
+            for (AttendRuleSchedulingShotAddDTO schedulingDTO : schedulingAddList) {
+                schedulingDTO.setShotId(shotId);
+                this.attendRuleShotManager.addSchedule(schedulingDTO);
+            }
+            AttendRuleDeviceQueryDTO deviceQueryDTO = new AttendRuleDeviceQueryDTO();
+            deviceQueryDTO.setRuleId(ruleId);
+            List deviceList = this.attendRuleDeviceManager.query(deviceQueryDTO);
+            List deviceShotAddList = BeanCopyUtils.copy((Collection)deviceList, AttendRuleDeviceShotAddDTO.class);
+            for (AttendRuleDeviceShotAddDTO deviceShotAddDTO : deviceShotAddList) {
+                deviceShotAddDTO.setShotId(shotId);
+                this.attendRuleShotManager.addDevice(deviceShotAddDTO);
+            }
+            AttendRuleOrgQueryDTO orgQueryDTO = new AttendRuleOrgQueryDTO();
+            orgQueryDTO.setRuleIds(Collections.singletonList(ruleId));
+            List orgList = this.attendRuleOrgManager.query(orgQueryDTO);
+            if (CollectionUtils.isNotEmpty((Collection)orgList)) {
+                List orgShotAddList = BeanCopyUtils.copy((Collection)orgList, AttendRuleOrgShotAddDTO.class);
+                for (AttendRuleOrgShotAddDTO attendRuleOrgShotAddDTO : orgShotAddList) {
+                    attendRuleOrgShotAddDTO.setShotId(shotId);
+                    this.attendRuleOrgShotManager.add(attendRuleOrgShotAddDTO);
+                }
+            }
+            AttendRuleLabelQueryDTO labelQueryDTO = new AttendRuleLabelQueryDTO();
+            labelQueryDTO.setRuleId(ruleId);
+            List labelList = this.attendRuleLabelManager.query(labelQueryDTO);
+            if (CollectionUtils.isNotEmpty((Collection)labelList)) {
+                List labelShotAddList = BeanCopyUtils.copy((Collection)labelList, AttendRuleLabelShotAddDTO.class);
+                for (AttendRuleLabelShotAddDTO labelShotAddDTO : labelShotAddList) {
+                    labelShotAddDTO.setShotId(shotId);
+                    this.attendRuleShotManager.addLabel(labelShotAddDTO);
+                }
+            }
+            return CloudwalkResult.success((Object)shotId);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u8003\u52e4\u7f16\u8f91\uff0c\u4fdd\u5b58\u5feb\u7167\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private void addRuleShot(String ruleId, String shotId, CloudwalkCallContext cloudwalkContext) throws DataAccessException {
+        AttendRuleQueryDTO ruleQueryDTO = new AttendRuleQueryDTO();
+        ruleQueryDTO.setRuleId(ruleId);
+        ruleQueryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+        AttendRuleQueryResultDTO resultDTO = this.attendRuleManager.query(ruleQueryDTO);
+        AttendRuleShotAddDTO addDTO = (AttendRuleShotAddDTO)BeanCopyUtils.copyProperties((Object)resultDTO, AttendRuleShotAddDTO.class);
+        addDTO.setRuleId(ruleId);
+        addDTO.setId(shotId);
+        addDTO.setCreateTime(Long.valueOf(System.currentTimeMillis()));
+        addDTO.setLastUpdateTime(Long.valueOf(System.currentTimeMillis()));
+        this.attendRuleShotManager.add(addDTO);
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/cn/cloudwalk/service/ninca/attendance/storage/AttendanceFileStorageServiceImpl.java

@@ -0,0 +1,133 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.davinci.portal.file.param.part.FilePartAppendParam
+ *  cn.cloudwalk.client.davinci.portal.file.param.part.FilePartFinishParam
+ *  cn.cloudwalk.client.davinci.portal.file.param.part.FilePartInitParam
+ *  cn.cloudwalk.client.davinci.portal.file.result.FilePartResult
+ *  cn.cloudwalk.client.ninca.attendance.storage.service.AttendFileStorageService
+ *  cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.intelligent.davinci.common.exception.DavinciServiceException
+ *  cn.cloudwalk.intelligent.davinci.storage.bean.part.dto.PartFinishDTO
+ *  cn.cloudwalk.intelligent.davinci.storage.bean.part.dto.PartInitDTO
+ *  cn.cloudwalk.intelligent.davinci.storage.bean.part.dto.PartInitResultDTO
+ *  cn.cloudwalk.intelligent.davinci.storage.manager.FilePartManager
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Component
+ *  org.springframework.util.FileCopyUtils
+ *  org.springframework.web.multipart.MultipartFile
+ */
+package cn.cloudwalk.service.ninca.attendance.storage;
+
+import cn.cloudwalk.client.davinci.portal.file.param.part.FilePartAppendParam;
+import cn.cloudwalk.client.davinci.portal.file.param.part.FilePartFinishParam;
+import cn.cloudwalk.client.davinci.portal.file.param.part.FilePartInitParam;
+import cn.cloudwalk.client.davinci.portal.file.result.FilePartResult;
+import cn.cloudwalk.client.ninca.attendance.storage.service.AttendFileStorageService;
+import cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.intelligent.davinci.common.exception.DavinciServiceException;
+import cn.cloudwalk.intelligent.davinci.storage.bean.part.dto.PartFinishDTO;
+import cn.cloudwalk.intelligent.davinci.storage.bean.part.dto.PartInitDTO;
+import cn.cloudwalk.intelligent.davinci.storage.bean.part.dto.PartInitResultDTO;
+import cn.cloudwalk.intelligent.davinci.storage.manager.FilePartManager;
+import cn.cloudwalk.service.ninca.attendance.common.AbstractCloudwalkService;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.util.FileCopyUtils;
+import org.springframework.web.multipart.MultipartFile;
+
+@Component
+public class AttendanceFileStorageServiceImpl
+extends AbstractCloudwalkService
+implements AttendFileStorageService {
+    @Autowired
+    private FilePartManager filePartManager;
+
+    @CloudwalkParamsValidate
+    public CloudwalkResult<FilePartResult> filePartInit(FilePartInitParam param) throws ServiceException {
+        PartInitDTO dto = (PartInitDTO)BeanCopyUtils.copyProperties((Object)param, PartInitDTO.class);
+        try {
+            PartInitResultDTO partInitResultDTO = this.filePartManager.init(dto);
+            return CloudwalkResult.success((Object)BeanCopyUtils.copyProperties((Object)partInitResultDTO, FilePartResult.class));
+        }
+        catch (DavinciServiceException e) {
+            this.logger.error("\u5206\u7247\u4e0a\u4f20\u6587\u4ef6\u521d\u59cb\u5316\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @CloudwalkParamsValidate
+    public CloudwalkResult<FilePartResult> filePartAppend(FilePartAppendParam param) throws ServiceException {
+        try {
+            String filePrefix = "partFile";
+            PartInitResultDTO partInitResultDTO = this.filePartManager.append(param.getFilePath(), param.getPartNumber(), param.getUploadId(), this.buildMultipartFile("partFile" + param.getPartNumber(), (byte[])param.getContent()));
+            return CloudwalkResult.success((Object)BeanCopyUtils.copyProperties((Object)partInitResultDTO, FilePartResult.class));
+        }
+        catch (DavinciServiceException e) {
+            this.logger.error("\u5206\u7247\u4e0a\u4f20\u6587\u4ef6\u8ffd\u52a0\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @CloudwalkParamsValidate
+    public CloudwalkResult<String> filePartFinish(FilePartFinishParam param) throws ServiceException {
+        PartFinishDTO dto = (PartFinishDTO)BeanCopyUtils.copyProperties((Object)param, PartFinishDTO.class);
+        try {
+            return CloudwalkResult.success((Object)this.filePartManager.finish(dto));
+        }
+        catch (DavinciServiceException e) {
+            this.logger.error("\u5206\u7247\u4e0a\u4f20\u6587\u4ef6\u7ed3\u675f\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private MultipartFile buildMultipartFile(final String fileName, final byte[] bytes) {
+        MultipartFile file = new MultipartFile(){
+
+            public String getName() {
+                return "file";
+            }
+
+            public String getOriginalFilename() {
+                return fileName;
+            }
+
+            public String getContentType() {
+                return null;
+            }
+
+            public boolean isEmpty() {
+                return bytes.length == 0;
+            }
+
+            public long getSize() {
+                return bytes.length;
+            }
+
+            public byte[] getBytes() throws IOException {
+                return bytes;
+            }
+
+            public InputStream getInputStream() throws IOException {
+                return new ByteArrayInputStream(bytes);
+            }
+
+            public void transferTo(File dest) throws IOException, IllegalStateException {
+                FileCopyUtils.copy((byte[])bytes, (File)dest);
+            }
+        };
+        return file;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-smart-attendance-service/src/main/java/summary.txt

@@ -0,0 +1,2 @@
+Summary for /tmp/crk_lib_extract_6o_f40r3/ninca-crk-smart-attendance-service-2.9.1_210630-SNAPSHOT.jar
+Decompiled with CFR 0.152