feat: add service config templates and extraction script

Former-commit-id: 1de24b7eb79676d1aba9d799a58c5a753290cf52

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/pom.xml

@@ -0,0 +1,97 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>cn.cloudwalk.ninca</groupId>
+        <artifactId>ninca-crk-from-lib-reactor</artifactId>
+        <version>2.9.1_210630-SNAPSHOT</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <artifactId>ninca-crk-visitor-management-service</artifactId>
+    <name>ninca-crk-visitor-management-service</name>
+    <description>CFR from ninca-crk-visitor-management-service-2.9.1_210630-SNAPSHOT.jar (embedded pom: none)</description>
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>cn.cloudwalk.ninca</groupId>
+            <artifactId>ninca-crk-visitor-management-interface</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>cn.cloudwalk.ninca</groupId>
+            <artifactId>ninca-crk-visitor-management-biz</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>cn.cloudwalk.ninca</groupId>
+            <artifactId>ninca-crk-visitor-management-common</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>cn.cloudwalk.intelligent</groupId>
+            <artifactId>intelligent-cwoscomponent-interface</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>cn.cloudwalk.cloud</groupId>
+            <artifactId>cloudwalk-common-result</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-tx</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>fastjson</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.poi</groupId>
+            <artifactId>poi</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.poi</groupId>
+            <artifactId>poi-ooxml</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>javax.annotation</groupId>
+            <artifactId>javax.annotation-api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>cn.cloudwalk.ninca</groupId>
+            <artifactId>ninca-crk-portal-resource-stubs</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-redis</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>redis.clients</groupId>
+            <artifactId>jedis</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.github.openfeign</groupId>
+            <artifactId>feign-core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>commons-codec</groupId>
+            <artifactId>commons-codec</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>cn.cloudwalk.intelligent</groupId>
+            <artifactId>davinci-manager-storage</artifactId>
+        </dependency>
+    </dependencies>
+</project>

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/VisitorFeignConfiguration.java

@@ -0,0 +1,87 @@
+/*
+ * 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.visitor.config.VisitorFeignThreadLocalUtil
+ *  cn.cloudwalk.common.ninca.visitor.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.visitor;
+
+import cn.cloudwalk.cloud.context.CloudwalkSessionContextHolder;
+import cn.cloudwalk.cloud.context.CloudwalkSessionObject;
+import cn.cloudwalk.common.ninca.visitor.config.VisitorFeignThreadLocalUtil;
+import cn.cloudwalk.common.ninca.visitor.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 VisitorFeignConfiguration
+implements RequestInterceptor {
+    protected final Logger logger = LoggerFactory.getLogger(VisitorFeignConfiguration.class);
+    @Autowired
+    private CloudwalkSessionContextHolder cloudwalkSessionContextHolder;
+
+    public void apply(RequestTemplate requestTemplate) {
+        Map map = VisitorFeignThreadLocalUtil.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")});
+            this.logger.info("feign\u8c03\u7528\u914d\u7f6eheader\u53c2\u6570\uff0cbusinessId={},threadId={}\uff0cplatformuserid={}", new Object[]{requestTemplate.headers().get("businessid"), Thread.currentThread().getId(), requestTemplate.headers().get("platformuserid")});
+        } 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-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/anonymous/AnonymousVerifyServiceImpl.java

@@ -0,0 +1,81 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.visitor.anonymous.service.AnonymousVerifyService
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.AnonymousAddSignParam
+ *  cn.cloudwalk.client.ninca.visitor.visitor.result.AnonymousAddSignResult
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.common.ninca.visitor.util.AesUtil
+ *  org.apache.commons.codec.binary.Hex
+ *  org.apache.commons.codec.digest.HmacAlgorithms
+ *  org.apache.commons.codec.digest.HmacUtils
+ *  org.apache.commons.lang3.StringUtils
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.visitor.anonymous;
+
+import cn.cloudwalk.client.ninca.visitor.anonymous.service.AnonymousVerifyService;
+import cn.cloudwalk.client.ninca.visitor.visitor.param.AnonymousAddSignParam;
+import cn.cloudwalk.client.ninca.visitor.visitor.result.AnonymousAddSignResult;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.common.ninca.visitor.util.AesUtil;
+import cn.cloudwalk.service.ninca.visitor.common.AbstractCloudwalkService;
+import java.io.UnsupportedEncodingException;
+import org.apache.commons.codec.binary.Hex;
+import org.apache.commons.codec.digest.HmacAlgorithms;
+import org.apache.commons.codec.digest.HmacUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AnonymousVerifyServiceImpl
+extends AbstractCloudwalkService
+implements AnonymousVerifyService {
+    public CloudwalkResult<AnonymousAddSignResult> sign(CloudwalkCallContext context) throws ServiceException {
+        try {
+            long timestamp = System.currentTimeMillis();
+            AnonymousAddSignResult result = new AnonymousAddSignResult();
+            String bid = AesUtil.encryptUrlSafe((String)context.getCompany().getCompanyId(), (String)"www.cloudwalk.cn", (String)"otJe9ywLJ6#LLtgC");
+            String personId = super.gerCurrentUserPersonId(context);
+            String pid = null;
+            if (StringUtils.isNotBlank((CharSequence)personId)) {
+                pid = AesUtil.encryptUrlSafe((String)personId, (String)"www.cloudwalk.cn", (String)"otJe9ywLJ6#LLtgC");
+            }
+            result.setBid(bid);
+            result.setCt(Long.valueOf(timestamp));
+            result.setPid(pid);
+            result.setSign(this.sign(bid, timestamp, pid));
+            return CloudwalkResult.success((Object)result);
+        }
+        catch (Exception e) {
+            this.logger.error("\u751f\u6210\u7b7e\u540d\u5bf9\u8c61\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<String> verify(AnonymousAddSignParam param) throws ServiceException {
+        try {
+            String signResult = this.sign(param.getBid(), param.getCt(), param.getPid());
+            if (signResult.equals(param.getSign())) {
+                String businessId = AesUtil.decrypt((String)param.getBid(), (String)"www.cloudwalk.cn", (String)"otJe9ywLJ6#LLtgC");
+                return CloudwalkResult.success((Object)businessId);
+            }
+            return CloudwalkResult.fail((String)"76250005", (String)this.getMessage("76250005"));
+        }
+        catch (Exception e) {
+            this.logger.error("\u9a8c\u8bc1\u7b7e\u540d\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private String sign(String bid, Long ct, String pid) throws UnsupportedEncodingException {
+        byte[] bytes = HmacUtils.getInitializedMac((HmacAlgorithms)HmacAlgorithms.HMAC_MD5, (byte[])"intelligent_@FASaf@F21".getBytes("UTF-8")).doFinal((bid + ct + pid).getBytes());
+        return Hex.encodeHexString((byte[])bytes);
+    }
+}
+

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

@@ -0,0 +1,284 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.biology.param.FeatureExtractParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.biology.result.FeatureExtractResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.biology.service.BiologyToolService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.sysetting.param.DeviceAreaTreeParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.sysetting.result.AreaTreeResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.sysetting.service.SysettingAreaService
+ *  cn.cloudwalk.client.ninca.visitor.config.param.VisitorConfigQueryParam
+ *  cn.cloudwalk.client.ninca.visitor.config.result.VisitorConfigQueryResult
+ *  cn.cloudwalk.client.ninca.visitor.config.service.VisitorConfigService
+ *  cn.cloudwalk.client.ninca.visitor.device.param.DeviceImageStoreGetParam
+ *  cn.cloudwalk.client.ninca.visitor.device.service.VisitorDeviceImageStoreService
+ *  cn.cloudwalk.client.ninca.visitor.photo.param.PhotoAddParam
+ *  cn.cloudwalk.client.ninca.visitor.photo.service.PhotoService
+ *  cn.cloudwalk.client.resource.role.param.RoleGetsParam
+ *  cn.cloudwalk.client.resource.role.result.RoleInfoResult
+ *  cn.cloudwalk.client.resource.role.service.RoleService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.serial.UUIDSerial
+ *  cn.cloudwalk.cloud.session.extend.DefaultExtendContext
+ *  cn.cloudwalk.cloud.utils.CloudwalkDateUtils
+ *  cn.cloudwalk.common.ninca.visitor.em.PersonRoleEnum
+ *  cn.cloudwalk.common.ninca.visitor.em.VisitorConfigKeyEnum
+ *  cn.cloudwalk.common.ninca.visitor.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.visitor.util.StringUtils
+ *  cn.cloudwalk.common.ninca.visitor.util.ThumbnailUtils
+ *  cn.cloudwalk.serial.code.AbstractGeneralCode
+ *  javax.annotation.Resource
+ *  org.apache.commons.codec.binary.Base64
+ *  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.visitor.common;
+
+import cn.cloudwalk.client.cwoscomponent.intelligent.biology.param.FeatureExtractParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.biology.result.FeatureExtractResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.biology.service.BiologyToolService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.sysetting.param.DeviceAreaTreeParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.sysetting.result.AreaTreeResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.sysetting.service.SysettingAreaService;
+import cn.cloudwalk.client.ninca.visitor.config.param.VisitorConfigQueryParam;
+import cn.cloudwalk.client.ninca.visitor.config.result.VisitorConfigQueryResult;
+import cn.cloudwalk.client.ninca.visitor.config.service.VisitorConfigService;
+import cn.cloudwalk.client.ninca.visitor.device.param.DeviceImageStoreGetParam;
+import cn.cloudwalk.client.ninca.visitor.device.service.VisitorDeviceImageStoreService;
+import cn.cloudwalk.client.ninca.visitor.photo.param.PhotoAddParam;
+import cn.cloudwalk.client.ninca.visitor.photo.service.PhotoService;
+import cn.cloudwalk.client.resource.role.param.RoleGetsParam;
+import cn.cloudwalk.client.resource.role.result.RoleInfoResult;
+import cn.cloudwalk.client.resource.role.service.RoleService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.serial.UUIDSerial;
+import cn.cloudwalk.cloud.session.extend.DefaultExtendContext;
+import cn.cloudwalk.cloud.utils.CloudwalkDateUtils;
+import cn.cloudwalk.common.ninca.visitor.em.PersonRoleEnum;
+import cn.cloudwalk.common.ninca.visitor.em.VisitorConfigKeyEnum;
+import cn.cloudwalk.common.ninca.visitor.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.visitor.util.StringUtils;
+import cn.cloudwalk.common.ninca.visitor.util.ThumbnailUtils;
+import cn.cloudwalk.serial.code.AbstractGeneralCode;
+import cn.cloudwalk.service.ninca.visitor.common.thumbnail.VisitorThumbnailFaceProperties;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Resource;
+import org.apache.commons.codec.binary.Base64;
+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;
+    @Autowired
+    private VisitorThumbnailFaceProperties visitorThumbnailFaceProperties;
+    @Resource
+    private BiologyToolService biologyToolService;
+    @Autowired
+    private PhotoService photoService;
+    @Autowired
+    private VisitorDeviceImageStoreService visitorDeviceImageStoreService;
+    private static ThreadLocal<List<String>> TEMP_PATHS = new ThreadLocal();
+    @Autowired
+    private RoleService roleService;
+    @Autowired
+    private VisitorConfigService visitorConfigService;
+    @Autowired
+    private SysettingAreaService sysettingAreaService;
+
+    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();
+    }
+
+    protected CloudwalkResult<Boolean> faceFeatureCheck(String image, CloudwalkCallContext context) throws ServiceException {
+        byte[] bytes = Base64.decodeBase64((String)image);
+        try {
+            bytes = this.resize(bytes);
+        }
+        catch (IOException e) {
+            this.logger.error("\u56fe\u7247\u538b\u7f29\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException("762508027", this.getMessage("762508027"));
+        }
+        FeatureExtractParam extractDTO = new FeatureExtractParam();
+        extractDTO.setImageBase64(Base64.encodeBase64String((byte[])bytes));
+        CloudwalkResult featureExtractResult = this.biologyToolService.extract(extractDTO, context);
+        if (featureExtractResult.isSuccess()) {
+            FeatureExtractResult extract = (FeatureExtractResult)featureExtractResult.getData();
+            if (extract.getQuality()[0] < 0.65) {
+                this.logger.info("\u4eba\u8138\u56fe\u7247\u4e0d\u7b26\u5408\u8d28\u91cf\u8981\u6c42");
+                throw new ServiceException("762597025", this.getMessage("762597025"));
+            }
+        } else {
+            this.logger.info("\u63d0\u53d6\u7279\u5f81\u5931\u8d25\uff0c\u539f\u56e0:{}", (Object)featureExtractResult.getMessage());
+            throw new ServiceException(featureExtractResult.getCode(), featureExtractResult.getMessage());
+        }
+        return CloudwalkResult.success((Object)true);
+    }
+
+    protected byte[] resize(byte[] bytes) throws IOException {
+        try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream();){
+            ThumbnailUtils.resize((byte[])bytes, (int)this.visitorThumbnailFaceProperties.getWidth(), (int)this.visitorThumbnailFaceProperties.getHeight(), (boolean)false, (OutputStream)outputStream);
+            byte[] byArray = outputStream.toByteArray();
+            return byArray;
+        }
+    }
+
+    protected String uploadImg(String base64, CloudwalkCallContext context) throws ServiceException {
+        if (StringUtils.isBlank((String)base64)) {
+            return null;
+        }
+        PhotoAddParam photoAddParam = new PhotoAddParam();
+        photoAddParam.setImg(base64);
+        photoAddParam.setResize(true);
+        photoAddParam.setFileName("visitor.jpg");
+        CloudwalkResult uploadResult = this.photoService.add(photoAddParam, context);
+        if (uploadResult.isSuccess()) {
+            this.addTempPath((String)uploadResult.getData());
+            return (String)uploadResult.getData();
+        }
+        throw new ServiceException(uploadResult.getCode(), uploadResult.getMessage());
+    }
+
+    protected void clearTempPath() {
+        TEMP_PATHS.remove();
+    }
+
+    protected void addTempPath(String path) {
+        if (StringUtils.isNotEmpty((String)path)) {
+            List<String> paths = TEMP_PATHS.get();
+            if (null == paths) {
+                paths = new ArrayList<String>();
+                paths.add(path);
+                TEMP_PATHS.set(paths);
+            } else {
+                paths.add(path);
+            }
+        }
+    }
+
+    protected void cleanTempPhoto(CloudwalkCallContext context) {
+    }
+
+    protected String getDeviceImageStore(String deviceId, CloudwalkCallContext context) throws ServiceException {
+        DeviceImageStoreGetParam imageStoreQueryDTO = new DeviceImageStoreGetParam();
+        imageStoreQueryDTO.setDeviceId(deviceId);
+        CloudwalkResult imageStoreIdResult = this.visitorDeviceImageStoreService.getDeviceImageStore(imageStoreQueryDTO, context);
+        return (String)imageStoreIdResult.getData();
+    }
+
+    protected List<String> getCurrentUserRoles(CloudwalkCallContext context) {
+        if (context.getExt() == null) {
+            return null;
+        }
+        Map ext = (Map)((DefaultExtendContext)context.getExt()).getValue();
+        return ext == null ? null : (List)ext.get("roleIds");
+    }
+
+    private List<RoleInfoResult> getCurrentUserRole(CloudwalkCallContext context) throws ServiceException {
+        List<String> reloIds = this.getCurrentUserRoles(context);
+        if (CollectionUtils.isEmpty(reloIds)) {
+            return null;
+        }
+        RoleGetsParam roleGetsParam = new RoleGetsParam();
+        roleGetsParam.setIds(reloIds);
+        CloudwalkResult roleInfoResult = this.roleService.gets(roleGetsParam, context);
+        if (roleInfoResult.isSuccess() && roleInfoResult.getData() != null) {
+            return (List)roleInfoResult.getData();
+        }
+        throw new ServiceException(roleInfoResult.getCode(), roleInfoResult.getMessage());
+    }
+
+    protected boolean validCurrentUserRole(CloudwalkCallContext context, PersonRoleEnum ... roles) throws ServiceException {
+        if (roles.length > 0) {
+            List<RoleInfoResult> userRoles = this.getCurrentUserRole(context);
+            if (CollectionUtils.isEmpty(userRoles)) {
+                return false;
+            }
+            for (PersonRoleEnum role : roles) {
+                for (RoleInfoResult userRole : userRoles) {
+                    if (!userRole.getCode().equals(role.getPlateRoleCode())) continue;
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    protected String gerCurrentUserPersonId(CloudwalkCallContext context) {
+        if (context.getExt() != null) {
+            Map ext = (Map)((DefaultExtendContext)context.getExt()).getValue();
+            Object o = ext.get("personId");
+            return o == null ? null : o.toString();
+        }
+        return null;
+    }
+
+    protected String getConifgVaule(String key, CloudwalkCallContext context) {
+        VisitorConfigQueryParam visitorConfigQueryParam = new VisitorConfigQueryParam();
+        visitorConfigQueryParam.setConfigKey(VisitorConfigKeyEnum.VISITOR_REGISTER_AUDIT.getCode());
+        try {
+            CloudwalkResult visiorConfigQueryResult = this.visitorConfigService.query(visitorConfigQueryParam, context);
+            if (visiorConfigQueryResult.isSuccess() && CollectionUtils.isNotEmpty((Collection)((Collection)visiorConfigQueryResult.getData()))) {
+                VisitorConfigQueryResult queryResult = (VisitorConfigQueryResult)((List)visiorConfigQueryResult.getData()).get(0);
+                return queryResult.getConfigValue();
+            }
+        }
+        catch (ServiceException e) {
+            this.logger.error("\u67e5\u8be2\u8bbf\u5ba2\u5ba1\u6838\u5f00\u5173\u53c2\u6570\u5931\u8d25\uff0c\u539f\u56e0\uff1a{}", (Throwable)e);
+        }
+        return null;
+    }
+
+    protected Map<String, String> getDeviceAreaMap(CloudwalkCallContext context) {
+        DeviceAreaTreeParam areaTreeParam = new DeviceAreaTreeParam();
+        areaTreeParam.setBusinessId(context.getCompany().getCompanyId());
+        CloudwalkResult areaTree = this.sysettingAreaService.tree(areaTreeParam, context);
+        HashMap<String, String> areaMap = new HashMap<String, String>();
+        this.getAreaMap((List)areaTree.getData(), areaMap);
+        return areaMap;
+    }
+
+    private void getAreaMap(List<AreaTreeResult> areaTreeResultList, Map<String, String> areaMap) {
+        for (AreaTreeResult areaTree : areaTreeResultList) {
+            areaMap.put(areaTree.getId(), areaTree.getName());
+            if (areaTree.getChildren() == null) continue;
+            this.getAreaMap(areaTree.getChildren(), areaMap);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/common/AbstractImportService.java

@@ -0,0 +1,141 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.visitor.batch.param.ImportData
+ *  cn.cloudwalk.client.ninca.visitor.batch.result.BatchImportResult
+ *  cn.cloudwalk.client.ninca.visitor.storage.service.FileStorageService
+ *  cn.cloudwalk.common.ninca.visitor.em.ImportExceptionEnum
+ *  cn.cloudwalk.common.ninca.visitor.util.ExcelUtil
+ *  cn.cloudwalk.common.ninca.visitor.util.StringUtils
+ *  cn.cloudwalk.common.ninca.visitor.util.ZipUtil
+ *  com.google.common.collect.Maps
+ *  javax.annotation.Resource
+ *  org.apache.commons.lang3.ArrayUtils
+ */
+package cn.cloudwalk.service.ninca.visitor.common;
+
+import cn.cloudwalk.client.ninca.visitor.batch.param.ImportData;
+import cn.cloudwalk.client.ninca.visitor.batch.result.BatchImportResult;
+import cn.cloudwalk.client.ninca.visitor.storage.service.FileStorageService;
+import cn.cloudwalk.common.ninca.visitor.em.ImportExceptionEnum;
+import cn.cloudwalk.common.ninca.visitor.util.ExcelUtil;
+import cn.cloudwalk.common.ninca.visitor.util.StringUtils;
+import cn.cloudwalk.common.ninca.visitor.util.ZipUtil;
+import cn.cloudwalk.service.ninca.visitor.common.AbstractCloudwalkService;
+import com.google.common.collect.Maps;
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Resource;
+import org.apache.commons.lang3.ArrayUtils;
+
+public abstract class AbstractImportService<T extends ImportData>
+extends AbstractCloudwalkService {
+    private static ThreadLocal<Map<String, Object>> imgMapHolder = ThreadLocal.withInitial(() -> Maps.newHashMap());
+    private static ThreadLocal<Map<String, String>> fileNameMapHolder = ThreadLocal.withInitial(() -> Maps.newHashMap());
+    private static final String[] EXCEL_SUFFIX = new String[]{"xls", "xlsx"};
+    private static final String[] IMAGE_SUFFIX = new String[]{"jpg", "jpeg", "png", "bmp"};
+    @Resource
+    private FileStorageService fileStorageService;
+
+    protected void putImg(String name, Object img) {
+        imgMapHolder.get().put(name, img);
+    }
+
+    protected void putFileName(String name, String fileName) {
+        fileNameMapHolder.get().put(name, fileName);
+    }
+
+    protected Object getImg(String name) {
+        return imgMapHolder.get().get(name);
+    }
+
+    protected String getFilename(String name) {
+        return fileNameMapHolder.get().get(name);
+    }
+
+    public BatchImportResult parseImportedFiles(String zipName, String zipPath, Class<T> dataClass) {
+        BatchImportResult result = new BatchImportResult();
+        result.setSuccess(true);
+        result.setFileName(zipName);
+        Map<String, Object> mapZip = this.getMapZip(zipPath, result);
+        if (!result.isSuccess()) {
+            return result;
+        }
+        boolean isHaveExcel = false;
+        for (Map.Entry<String, Object> entry : mapZip.entrySet()) {
+            String suffix = entry.getKey().substring(entry.getKey().lastIndexOf(".") + 1);
+            if (ArrayUtils.contains((Object[])EXCEL_SUFFIX, (Object)suffix)) {
+                isHaveExcel = true;
+                byte[] fileStream = (byte[])entry.getValue();
+                ByteArrayInputStream inputStream = new ByteArrayInputStream(fileStream);
+                try {
+                    List importDatas = ExcelUtil.getExcelToList(null, (Integer)2, (InputStream)inputStream, dataClass);
+                    result.setExecTotal(Integer.valueOf(importDatas.size()));
+                    result.setImportDatas(importDatas);
+                    continue;
+                }
+                catch (Exception e) {
+                    result.setRemark(ImportExceptionEnum.EXCEL_FAIL.getMessage());
+                    result.setSuccess(false);
+                    return result;
+                }
+            }
+            if (!ArrayUtils.contains((Object[])IMAGE_SUFFIX, (Object)suffix)) continue;
+            String[] filePath = entry.getKey().split("/");
+            String fileName = filePath[filePath.length - 1];
+            String name = fileName.replace("." + suffix, "");
+            this.putImg(name, entry.getValue());
+            this.putFileName(name, fileName);
+        }
+        if (!isHaveExcel) {
+            result.setRemark(ImportExceptionEnum.NO_EXCEL.getMessage());
+            result.setSuccess(false);
+            return result;
+        }
+        result.setSuccess(true);
+        return result;
+    }
+
+    protected Map<String, Object> getMapZip(String zipPath, BatchImportResult result) {
+        Map<String, Object> mapZip = new HashMap<String, Object>();
+        InputStream zipInputStream = null;
+        if (StringUtils.isBlank((String)zipPath)) {
+            result.setRemark(ImportExceptionEnum.ZIP_PATH_EMPTY.getMessage());
+            result.setSuccess(false);
+            return mapZip;
+        }
+        if (zipPath.startsWith("/")) {
+            zipPath = zipPath.replaceFirst("/", "");
+        }
+        try {
+            zipInputStream = this.fileStorageService.fileDownLoadWithAbsoluteUrl(zipPath);
+        }
+        catch (Exception e) {
+            this.logger.error("\u4e0b\u8f7d\u6587\u4ef6\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            result.setRemark(ImportExceptionEnum.ZIP_DOWNLOAD_FAIL.getMessage());
+            result.setSuccess(false);
+            return mapZip;
+        }
+        if (zipInputStream == null) {
+            result.setRemark(ImportExceptionEnum.NOT_ZIP.getMessage());
+            result.setSuccess(false);
+            return mapZip;
+        }
+        long startTime = System.currentTimeMillis();
+        try {
+            mapZip = ZipUtil.unZip((InputStream)zipInputStream);
+            this.logger.info("\u89e3\u6790zip\u5305\u8017\u65f6{}", (Object)(System.currentTimeMillis() - startTime));
+        }
+        catch (Exception e) {
+            this.logger.error("\u6279\u91cf\u5bfc\u5165\uff0c\u89e3\u538b\u538b\u7f29\u6587\u4ef6\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            result.setRemark(ImportExceptionEnum.ZIP_FAIL.getMessage());
+            result.setSuccess(false);
+        }
+        return mapZip;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/common/AbstractProtocolApplicationService.java

@@ -0,0 +1,83 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.visitor.record.param.VisitorRecordNewParam
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContextBuilder
+ *  cn.cloudwalk.cloud.context.CloudwalkSessionContextHolder
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.visitor.device.DeviceContext
+ *  org.springframework.beans.factory.annotation.Autowired
+ */
+package cn.cloudwalk.service.ninca.visitor.common;
+
+import cn.cloudwalk.client.ninca.visitor.record.param.VisitorRecordNewParam;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.context.CloudwalkCallContextBuilder;
+import cn.cloudwalk.cloud.context.CloudwalkSessionContextHolder;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.visitor.device.DeviceContext;
+import cn.cloudwalk.service.ninca.visitor.common.AbstractCloudwalkService;
+import java.lang.reflect.Method;
+import org.springframework.beans.factory.annotation.Autowired;
+
+public abstract class AbstractProtocolApplicationService
+extends AbstractCloudwalkService {
+    @Autowired
+    private CloudwalkSessionContextHolder cloudwalkSessionContextHolder;
+
+    public CloudwalkCallContext getCloudwalkContext() {
+        return CloudwalkCallContextBuilder.buildContext((CloudwalkSessionContextHolder)this.cloudwalkSessionContextHolder);
+    }
+
+    protected <T> CloudwalkResult<T> convertServiceResultToDevice(CloudwalkResult<?> result, Class<T> cls) {
+        if (result.isSuccess()) {
+            return CloudwalkResult.success((Object)BeanCopyUtils.copyProperties((Object)result.getData(), cls));
+        }
+        return CloudwalkResult.fail((String)result.getCode(), (String)result.getMessage());
+    }
+
+    protected <T> CloudwalkResult<T> successDefault(String logId, Class<T> cls) {
+        try {
+            Method setLogIdMethod = cls.getMethod("setLogId", String.class);
+            T data = cls.newInstance();
+            setLogIdMethod.invoke(data, logId);
+            return CloudwalkResult.success(data);
+        }
+        catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    protected <T> CloudwalkResult<T> fail(String logId, Class<T> cls, String code, String message) {
+        try {
+            Method setLogIdMethod = cls.getMethod("setLogId", String.class);
+            T data = cls.newInstance();
+            setLogIdMethod.invoke(data, logId);
+            return CloudwalkResult.fail((String)code, (String)message, data);
+        }
+        catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    protected VisitorRecordNewParam buildRecogRecordParamWithDeviceContext(DeviceContext deviceContext) {
+        VisitorRecordNewParam visitorRecordNewParam = new VisitorRecordNewParam();
+        visitorRecordNewParam.setDeviceId(deviceContext.getDeviceId());
+        visitorRecordNewParam.setDeviceCode(deviceContext.getDeviceCode());
+        visitorRecordNewParam.setDeviceName(deviceContext.getDeviceName());
+        visitorRecordNewParam.setDeviceTypeId(deviceContext.getDeviceTypeId());
+        visitorRecordNewParam.setDeviceTypeName(deviceContext.getDeviceTypeName());
+        visitorRecordNewParam.setDeviceAreaId(deviceContext.getDeviceAreaId());
+        visitorRecordNewParam.setDeviceAreaName(deviceContext.getDeviceAreaName());
+        visitorRecordNewParam.setDeviceDistrictId(deviceContext.getDeviceDistrictId());
+        visitorRecordNewParam.setDeviceDistrictName(deviceContext.getDeviceDistrictName());
+        visitorRecordNewParam.setDeviceDistrictPath(deviceContext.getDeviceDistrictPath());
+        visitorRecordNewParam.setDeviceDistrictMergeName(deviceContext.getDeviceDistrictMergeName());
+        return visitorRecordNewParam;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/common/VisitorApplicationServiceImpl.java

@@ -0,0 +1,59 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.visitor.common.VisitorApplicationService
+ *  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.visitor.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.visitor.common;
+
+import cn.cloudwalk.client.ninca.visitor.common.VisitorApplicationService;
+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.visitor.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 VisitorApplicationServiceImpl
+implements VisitorApplicationService {
+    private static final Logger logger = LoggerFactory.getLogger(VisitorApplicationServiceImpl.class);
+    @Resource
+    private ApplicationService applicationService;
+
+    @Cacheable(cacheNames={"VistiorManagementApplicationIdsCache"}, key="T(cn.cloudwalk.biz.ninca.visitor.cache.VisitorCacheOverrideConfig).CACHE_KEY_APPLICATION_IDS_PREFIX + #businessId")
+    public String getApplicationId(String businessId) throws ServiceException {
+        ApplicationQueryParam param = new ApplicationQueryParam();
+        param.setBusinessId(businessId);
+        param.setServiceCode("visitor-mgmt");
+        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("76250005", "\u672a\u67e5\u5230applicationId");
+        }
+        logger.info("\u67e5\u8be2applicationId\u5931\u8d25");
+        throw new ServiceException("76250006", "\u67e5\u8be2applicationId\u5931\u8d25");
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/common/VisitorCommonConfigProperties.java

@@ -0,0 +1,53 @@
+/*
+ * 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.visitor.common;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+@Component
+@ConfigurationProperties(prefix="cloudwalk.visitor-management.common")
+public class VisitorCommonConfigProperties {
+    private String cwosFilePath;
+    private double faceCaptureRecogThreshold = 80.0;
+    private boolean recordPush = false;
+    private String recordPushServicecode;
+
+    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 String getCwosFilePath() {
+        return this.cwosFilePath;
+    }
+
+    public void setCwosFilePath(String cwosFilePath) {
+        this.cwosFilePath = cwosFilePath;
+    }
+
+    public double getFaceCaptureRecogThreshold() {
+        return this.faceCaptureRecogThreshold;
+    }
+
+    public void setFaceCaptureRecogThreshold(double faceCaptureRecogThreshold) {
+        this.faceCaptureRecogThreshold = faceCaptureRecogThreshold;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/common/job/VisitorJobInit.java

@@ -0,0 +1,90 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.common.ninca.visitor.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.visitor.common.job;
+
+import cn.cloudwalk.common.ninca.visitor.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.visitor.common.job.config.JobSetting;
+import cn.cloudwalk.service.ninca.visitor.common.job.config.VisitorJobProperties;
+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 VisitorJobInit
+implements CommandLineRunner {
+    private final Logger logger = LoggerFactory.getLogger(this.getClass());
+    private static final String ERROR_STATE = "ERROR";
+    @Autowired
+    private TaskExecClient client;
+    @Autowired
+    private VisitorJobProperties visitorJobProperties;
+    @Autowired
+    private CommonJobListener jobListener;
+
+    public void run(String ... strings) throws Exception {
+        Map<String, JobSetting> jobs = this.visitorJobProperties.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.addListener(param);
+            }
+        }
+    }
+}
+

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

@@ -0,0 +1,82 @@
+/*
+ * Decompiled with CFR 0.152.
+ */
+package cn.cloudwalk.service.ninca.visitor.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-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/common/job/config/VisitorJobProperties.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.visitor.common.job.config;
+
+import cn.cloudwalk.service.ninca.visitor.common.job.config.JobSetting;
+import java.util.Map;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+@Component
+@ConfigurationProperties(prefix="cloudwalk.visitor-management.schedual")
+public class VisitorJobProperties {
+    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-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/common/job/executable/CleanGroupExpiredVisitorsJob.java

@@ -0,0 +1,278 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.ninca.visitor.deivce.DeviceDefaultManager
+ *  cn.cloudwalk.biz.ninca.visitor.deivce.DeviceImageStoreManager
+ *  cn.cloudwalk.biz.ninca.visitor.deivce.VisitorDeviceManager
+ *  cn.cloudwalk.biz.ninca.visitor.visitor.VisitorManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.application.param.ApplicationImageStoreDelParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.application.service.ApplicationImageStoreService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceApplicationParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceImageStoreParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceApplicationService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceImageStoreService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStoreDelParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStorePersonDelParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.service.ImageStorePersonService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.service.ImageStoreService
+ *  cn.cloudwalk.client.ninca.visitor.common.VisitorApplicationService
+ *  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.common.ninca.visitor.bean.device.dto.DeviceDefaultGetsDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreDeleteDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreQueryDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreResultDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceGetsDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceResultDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorEditDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorGetsDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorQueryDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorResultDTO
+ *  cn.cloudwalk.common.ninca.visitor.config.VisitorFeignThreadLocalUtil
+ *  cn.cloudwalk.common.ninca.visitor.em.ImageStoreStatusEnum
+ *  cn.cloudwalk.common.ninca.visitor.util.CollectionUtils
+ *  cn.cloudwalk.data.ninca.visitor.device.dao.DeviceImageStoreDao
+ *  cn.cloudwalk.task.sdk.starter.job.AbstractJob
+ *  com.google.common.base.Stopwatch
+ *  org.quartz.JobExecutionContext
+ *  org.quartz.JobExecutionException
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.beans.factory.annotation.Autowired
+ */
+package cn.cloudwalk.service.ninca.visitor.common.job.executable;
+
+import cn.cloudwalk.biz.ninca.visitor.deivce.DeviceDefaultManager;
+import cn.cloudwalk.biz.ninca.visitor.deivce.DeviceImageStoreManager;
+import cn.cloudwalk.biz.ninca.visitor.deivce.VisitorDeviceManager;
+import cn.cloudwalk.biz.ninca.visitor.visitor.VisitorManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.application.param.ApplicationImageStoreDelParam;
+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.DeviceImageStoreParam;
+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.ImageStoreDelParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStorePersonDelParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.service.ImageStorePersonService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.service.ImageStoreService;
+import cn.cloudwalk.client.ninca.visitor.common.VisitorApplicationService;
+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.common.ninca.visitor.bean.device.dto.DeviceDefaultGetsDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreDeleteDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreQueryDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreResultDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceGetsDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceResultDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorEditDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorGetsDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorQueryDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorResultDTO;
+import cn.cloudwalk.common.ninca.visitor.config.VisitorFeignThreadLocalUtil;
+import cn.cloudwalk.common.ninca.visitor.em.ImageStoreStatusEnum;
+import cn.cloudwalk.common.ninca.visitor.util.CollectionUtils;
+import cn.cloudwalk.data.ninca.visitor.device.dao.DeviceImageStoreDao;
+import cn.cloudwalk.task.sdk.starter.job.AbstractJob;
+import com.google.common.base.Stopwatch;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import org.quartz.JobExecutionContext;
+import org.quartz.JobExecutionException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+
+public class CleanGroupExpiredVisitorsJob
+extends AbstractJob {
+    private static final Logger LOGGER = LoggerFactory.getLogger(CleanGroupExpiredVisitorsJob.class);
+    private static final Long TIME_TOLERANCE = 300000L;
+    @Autowired
+    private VisitorManager visitorManager;
+    @Autowired
+    private VisitorDeviceManager visitorDeviceManager;
+    @Autowired
+    private DeviceImageStoreManager deviceImageStoreManager;
+    @Autowired
+    private ImageStorePersonService imageStorePersonService;
+    @Autowired
+    private DeviceDefaultManager deviceDefaultManager;
+    @Autowired
+    private DeviceApplicationService deviceApplicationService;
+    @Autowired
+    private VisitorApplicationService visitorApplicationService;
+    @Autowired
+    private DeviceImageStoreDao deviceImageStoreDao;
+    @Autowired
+    private DeviceImageStoreService deviceImageStoreService;
+    @Autowired
+    private ImageStoreService imageStoreService;
+    @Autowired
+    private ApplicationImageStoreService applicationImageStoreService;
+
+    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
+        Stopwatch stopwatch = Stopwatch.createStarted();
+        LOGGER.info("\u6e05\u7406\u8fc7\u671f\u7684\u8bbf\u5ba2\u56fe\u5e93\u4eba\u5458 [CleanGroupExpiredVisitorsJob] \u4efb\u52a1\u5f00\u59cb\u8fd0\u884c");
+        long currentTime = System.currentTimeMillis();
+        Integer count = this.clean(currentTime, 1);
+        LOGGER.info("\u6e05\u7406\u8fc7\u671f\u7684\u8bbf\u5ba2\u56fe\u5e93\u4eba\u5458 [CleanGroupExpiredVisitorsJob] \u4efb\u52a1\u7ed3\u675f\u8fd0\u884c\uff0c\u6e05\u7406{}\u6761\uff0c\u8017\u65f6{}\u6beb\u79d2", (Object)count, (Object)stopwatch.elapsed(TimeUnit.MILLISECONDS));
+    }
+
+    private Integer clean(long currentTime, int currentPage) throws JobExecutionException {
+        VisitorQueryDTO visitorQueryDTO = new VisitorQueryDTO();
+        visitorQueryDTO.setEndVisitorTime(Long.valueOf(currentTime - TIME_TOLERANCE));
+        visitorQueryDTO.setImageStoreStatus(ImageStoreStatusEnum.NORMAL.getCode());
+        CloudwalkPageInfo pageInfo = new CloudwalkPageInfo(currentPage, 100);
+        try {
+            CloudwalkPageAble visitorPageResult = this.visitorManager.expired(visitorQueryDTO, pageInfo);
+            long totalPages = visitorPageResult.getTotalPages();
+            Integer count = visitorPageResult.getDatas().size();
+            for (VisitorResultDTO visitorResult : visitorPageResult.getDatas()) {
+                try {
+                    HashMap<String, String> feignThreadLoaclMap = new HashMap<String, String>();
+                    feignThreadLoaclMap.put("businessid", visitorResult.getBusinessId());
+                    VisitorFeignThreadLocalUtil.set(feignThreadLoaclMap);
+                    String visitorId = visitorResult.getId();
+                    VisitorDeviceGetsDTO visitorDeviceGetsDTO = new VisitorDeviceGetsDTO();
+                    visitorDeviceGetsDTO.setVisitorId(visitorId);
+                    List visitorDeviceResults = this.visitorDeviceManager.gets(visitorDeviceGetsDTO);
+                    if (CollectionUtils.isNotEmpty((Collection)visitorDeviceResults)) {
+                        for (VisitorDeviceResultDTO visitorDevice : visitorDeviceResults) {
+                            DeviceImageStoreQueryDTO imageStoreQueryDTO = new DeviceImageStoreQueryDTO();
+                            imageStoreQueryDTO.setDeviceId(visitorDevice.getDeviceId());
+                            DeviceImageStoreResultDTO imageStoreResultDTO = this.deviceImageStoreManager.queryByDeviceId(imageStoreQueryDTO);
+                            ImageStorePersonDelParam imageStorePersonDelParam = new ImageStorePersonDelParam();
+                            imageStorePersonDelParam.setPersonId(visitorId);
+                            imageStorePersonDelParam.setImageStoreId(imageStoreResultDTO.getImageStoreId());
+                            this.imageStorePersonService.delete(imageStorePersonDelParam, null);
+                        }
+                    }
+                    VisitorEditDTO visitorEditDTO = new VisitorEditDTO();
+                    visitorEditDTO.setId(visitorResult.getId());
+                    visitorEditDTO.setBusinessId(visitorResult.getBusinessId());
+                    visitorEditDTO.setImageStoreStatus(ImageStoreStatusEnum.DELETED.getCode());
+                    this.visitorManager.edit(visitorEditDTO);
+                    this.deleteDevice(visitorDeviceResults, visitorResult.getBusinessId());
+                }
+                catch (Exception e) {
+                    LOGGER.error("\u6e05\u7406\u5e95\u5e93\u4eba\u5458\u51fa\u73b0\u5f02\u5e38\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+                }
+            }
+            if (totalPages > (long)currentPage) {
+                Thread.sleep(100L);
+                count = count + this.clean(currentTime, currentPage + 1);
+            }
+            return count;
+        }
+        catch (Exception e) {
+            LOGGER.error("\u6e05\u7406\u8fc7\u671f\u8bbf\u5ba2\u51fa\u73b0\u5f02\u5e38\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new JobExecutionException((Throwable)e);
+        }
+    }
+
+    private void deleteDevice(List<VisitorDeviceResultDTO> visitorDeviceResults, String businessId) {
+        LOGGER.info("\u5224\u65ad\u8bbe\u5907\u662f\u5426\u9700\u8981\u89e3\u7ed1");
+        try {
+            DeviceDefaultGetsDTO deviceDefaultGetsDTO = new DeviceDefaultGetsDTO();
+            deviceDefaultGetsDTO.setBusinessId(businessId);
+            List defaultDevices = this.deviceDefaultManager.gets(deviceDefaultGetsDTO);
+            HashSet defaultDeviceIds = new HashSet(defaultDevices.size());
+            defaultDevices.forEach(ele -> defaultDeviceIds.add(ele.getDeviceId()));
+            if (CollectionUtils.isNotEmpty(visitorDeviceResults)) {
+                for (VisitorDeviceResultDTO visitorDevice : visitorDeviceResults) {
+                    if (defaultDeviceIds.contains(visitorDevice.getDeviceId())) continue;
+                    LOGGER.info("{}\u4e0d\u662f\u9ed8\u8ba4\u8bbe\u5907", (Object)visitorDevice.getDeviceId());
+                    VisitorDeviceGetsDTO visitorDeviceGetsDTO = new VisitorDeviceGetsDTO();
+                    visitorDeviceGetsDTO.setBusinessId(businessId);
+                    visitorDeviceGetsDTO.setDeviceId(visitorDevice.getDeviceId());
+                    List deviceVistors = this.visitorDeviceManager.gets(visitorDeviceGetsDTO);
+                    LOGGER.info("\u8bbe\u5907{}\u4e0b\u7684\u8bbf\u5ba2\u6570\u91cf\u4e3a{}", (Object)visitorDevice.getDeviceId(), (Object)deviceVistors.size());
+                    if (!CollectionUtils.isEmpty((Collection)deviceVistors)) {
+                        ArrayList visitorIds = new ArrayList(deviceVistors.size());
+                        deviceVistors.forEach(ele -> visitorIds.add(ele.getVisitorId()));
+                        VisitorGetsDTO visitorGetsDTO = new VisitorGetsDTO();
+                        visitorGetsDTO.setBusinessId(businessId);
+                        visitorGetsDTO.setIds(visitorIds);
+                        List imgStoreNormal = this.visitorManager.gets(visitorGetsDTO);
+                        HashMap<String, Integer> imgStatus = new HashMap<String, Integer>(imgStoreNormal.size());
+                        imgStoreNormal.forEach(ele -> imgStatus.put(ele.getId(), ele.getImageStoreStatus()));
+                        VisitorDeviceGetsDTO visitorDeviceGetByDevice = new VisitorDeviceGetsDTO();
+                        visitorDeviceGetByDevice.setBusinessId(businessId);
+                        visitorDeviceGetByDevice.setDeviceId(visitorDevice.getDeviceId());
+                        if (!this.needDelBind(imgStatus, visitorDeviceGetByDevice)) {
+                            LOGGER.info("{}\u8bbe\u5907\u4e0d\u9700\u89e3\u7ed1\uff0c\u6709\u672a\u8fc7\u671f\u4eba\u5458", (Object)visitorDevice.getDeviceId());
+                            continue;
+                        }
+                    }
+                    LOGGER.info("{}\u8bbe\u5907\u9700\u89e3\u7ed1\u5e94\u7528", (Object)visitorDevice.getDeviceId());
+                    DeviceImageStoreQueryDTO dto = new DeviceImageStoreQueryDTO();
+                    dto.setBusinessId(businessId);
+                    dto.setDeviceId(visitorDevice.getDeviceId());
+                    DeviceImageStoreResultDTO deviceImageStoreResultDTO = this.deviceImageStoreDao.queryByDeviceId(dto);
+                    DeviceImageStoreParam param = new DeviceImageStoreParam();
+                    param.setDeviceId(visitorDevice.getDeviceId());
+                    param.setImageStoreId(deviceImageStoreResultDTO.getImageStoreId());
+                    CloudwalkResult isDeleteImg = this.deviceImageStoreService.delete(param, null);
+                    CloudwalkResult isDeleteApp = null;
+                    String applicationId = null;
+                    if ("00000000".equals(isDeleteImg.getCode())) {
+                        LOGGER.info("\u89e3\u9664\u8bbe\u5907\u5e94\u7528\u7ed1\u5b9a{}{}{}", new Object[]{isDeleteImg.getMessage(), visitorDevice.getDeviceId(), deviceImageStoreResultDTO.getImageStoreId()});
+                        applicationId = this.visitorApplicationService.getApplicationId(businessId);
+                        DeviceApplicationParam deviceImageStoreParam = new DeviceApplicationParam();
+                        deviceImageStoreParam.setDeviceId(visitorDevice.getDeviceId());
+                        deviceImageStoreParam.setApplicationId(applicationId);
+                        isDeleteApp = this.deviceApplicationService.delete(deviceImageStoreParam, null);
+                    }
+                    if (!"00000000".equals(isDeleteApp.getCode())) continue;
+                    LOGGER.info("\u89e3\u9664\u56fe\u5e93\u548c\u5e94\u7528\u7684\u5173\u7cfb");
+                    ApplicationImageStoreDelParam delParam = new ApplicationImageStoreDelParam();
+                    delParam.setApplicationId(applicationId);
+                    delParam.setImageStoreId(deviceImageStoreResultDTO.getImageStoreId());
+                    this.applicationImageStoreService.delete(delParam, null);
+                    LOGGER.info("\u5220\u9664\u56fe\u5e93");
+                    ImageStoreDelParam imageStoreDelParam = new ImageStoreDelParam();
+                    imageStoreDelParam.setId(deviceImageStoreResultDTO.getImageStoreId());
+                    CloudwalkResult delete = this.imageStoreService.delete(imageStoreDelParam, null);
+                    DeviceImageStoreDeleteDTO deviceImageStoreDeleteDTO = new DeviceImageStoreDeleteDTO();
+                    deviceImageStoreDeleteDTO.setBusinessId(businessId);
+                    deviceImageStoreDeleteDTO.setDeviceId(visitorDevice.getDeviceId());
+                    this.deviceImageStoreManager.deleteByDeviceId(deviceImageStoreDeleteDTO);
+                }
+            }
+        }
+        catch (DataAccessException | ServiceException e) {
+            LOGGER.error("\u8bbe\u5907\u89e3\u7ed1\u56fe\u5e93\u5f02\u5e38\uff0c\u539f\u56e0\uff1a", e);
+        }
+    }
+
+    private boolean needDelBind(Map<String, Integer> imgStatus, VisitorDeviceGetsDTO visitorDeviceGetByDevice) {
+        List visitorIds = null;
+        try {
+            visitorIds = this.visitorDeviceManager.gets(visitorDeviceGetByDevice);
+        }
+        catch (DataAccessException e) {
+            LOGGER.error("\u8bbf\u5ba2\u8bbe\u5907\u67e5\u8be2\u5f02\u5e38\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+        }
+        if (CollectionUtils.isNotEmpty((Collection)visitorIds)) {
+            for (VisitorDeviceResultDTO visitorDeviceResultDTO : visitorIds) {
+                if (!imgStatus.containsKey(visitorDeviceResultDTO.getVisitorId()) || !ImageStoreStatusEnum.NORMAL.getCode().equals(imgStatus.get(visitorDeviceResultDTO.getVisitorId()))) continue;
+                LOGGER.info("{}\u672a\u8fc7\u671f", (Object)visitorDeviceResultDTO.getVisitorId());
+                return false;
+            }
+        }
+        return true;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/common/label/VisitorLabelServiceImpl.java

@@ -0,0 +1,68 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.label.param.LabelAddParam
+ *  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.visitor.label.VisitorLabelService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.common.ninca.visitor.util.CollectionUtils
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.visitor.common.label;
+
+import cn.cloudwalk.client.cwoscomponent.intelligent.label.param.LabelAddParam;
+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.visitor.label.VisitorLabelService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.common.ninca.visitor.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.visitor.common.AbstractCloudwalkService;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class VisitorLabelServiceImpl
+extends AbstractCloudwalkService
+implements VisitorLabelService {
+    private static final String VISITOR_LABEL_CODE = "1";
+    private static final String VISITOR_LABEL_NAME = "\u8bbf\u5ba2";
+    @Autowired
+    private LabelService labelService;
+
+    public CloudwalkResult<String> getLabelId(CloudwalkCallContext context) throws ServiceException {
+        LabelQueryParam labelQueryParam = new LabelQueryParam();
+        labelQueryParam.setName(VISITOR_LABEL_NAME);
+        CloudwalkResult labelDetailResultCloudwalkResult = this.labelService.getAll(labelQueryParam, context);
+        if (labelDetailResultCloudwalkResult.isSuccess()) {
+            List labelDetailResults;
+            List labels = (List)labelDetailResultCloudwalkResult.getData();
+            if (CollectionUtils.isNotEmpty((Collection)labels) && CollectionUtils.isNotEmpty(labelDetailResults = labels.stream().filter(s -> VISITOR_LABEL_NAME.equals(s.getName())).collect(Collectors.toList()))) {
+                return CloudwalkResult.success((Object)((LabelDetailResult)labelDetailResults.get(0)).getId());
+            }
+        } else {
+            return CloudwalkResult.fail((String)labelDetailResultCloudwalkResult.getCode(), (String)labelDetailResultCloudwalkResult.getMessage());
+        }
+        LabelAddParam labelAddParam = new LabelAddParam();
+        labelAddParam.setCode(VISITOR_LABEL_CODE);
+        labelAddParam.setName(VISITOR_LABEL_NAME);
+        labelAddParam.setAddType(Integer.valueOf(2));
+        CloudwalkResult labelAddResult = this.labelService.add(labelAddParam, context);
+        if (labelAddResult.isSuccess()) {
+            return labelAddResult;
+        }
+        return CloudwalkResult.fail((String)labelAddResult.getCode(), (String)labelAddResult.getMessage());
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/common/thumbnail/VisitorThumbnailFaceProperties.java

@@ -0,0 +1,45 @@
+/*
+ * 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.visitor.common.thumbnail;
+
+import java.util.List;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+@Component
+@ConfigurationProperties(prefix="cloudwalk.visitor-management.thumbnail.face")
+public class VisitorThumbnailFaceProperties {
+    private Integer width;
+    private Integer height;
+    private List<String> types;
+
+    public Integer getWidth() {
+        return this.width;
+    }
+
+    public void setWidth(Integer width) {
+        this.width = width;
+    }
+
+    public Integer getHeight() {
+        return this.height;
+    }
+
+    public void setHeight(Integer height) {
+        this.height = height;
+    }
+
+    public List<String> getTypes() {
+        return this.types;
+    }
+
+    public void setTypes(List<String> types) {
+        this.types = types;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/config/VisitorConfigServiceImpl.java

@@ -0,0 +1,107 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.ninca.visitor.config.VisitorConfigManager
+ *  cn.cloudwalk.client.ninca.visitor.config.param.VisitorConfigEditParam
+ *  cn.cloudwalk.client.ninca.visitor.config.param.VisitorConfigQueryParam
+ *  cn.cloudwalk.client.ninca.visitor.config.result.VisitorConfigQueryResult
+ *  cn.cloudwalk.client.ninca.visitor.config.service.VisitorConfigService
+ *  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.visitor.bean.config.dto.VisitorConfigAddDto
+ *  cn.cloudwalk.common.ninca.visitor.bean.config.dto.VisitorConfigEditDto
+ *  cn.cloudwalk.common.ninca.visitor.bean.config.dto.VisitorConfigQueryDto
+ *  cn.cloudwalk.common.ninca.visitor.em.VisitorConfigKeyEnum
+ *  com.alibaba.fastjson.JSONObject
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Service
+ *  org.springframework.util.StringUtils
+ */
+package cn.cloudwalk.service.ninca.visitor.config;
+
+import cn.cloudwalk.biz.ninca.visitor.config.VisitorConfigManager;
+import cn.cloudwalk.client.ninca.visitor.config.param.VisitorConfigEditParam;
+import cn.cloudwalk.client.ninca.visitor.config.param.VisitorConfigQueryParam;
+import cn.cloudwalk.client.ninca.visitor.config.result.VisitorConfigQueryResult;
+import cn.cloudwalk.client.ninca.visitor.config.service.VisitorConfigService;
+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.visitor.bean.config.dto.VisitorConfigAddDto;
+import cn.cloudwalk.common.ninca.visitor.bean.config.dto.VisitorConfigEditDto;
+import cn.cloudwalk.common.ninca.visitor.bean.config.dto.VisitorConfigQueryDto;
+import cn.cloudwalk.common.ninca.visitor.em.VisitorConfigKeyEnum;
+import cn.cloudwalk.service.ninca.visitor.common.AbstractCloudwalkService;
+import cn.cloudwalk.service.ninca.visitor.common.VisitorCommonConfigProperties;
+import com.alibaba.fastjson.JSONObject;
+import java.util.Collection;
+import java.util.List;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+
+@Service
+public class VisitorConfigServiceImpl
+extends AbstractCloudwalkService
+implements VisitorConfigService {
+    @Autowired
+    private VisitorConfigManager visitorConfigManager;
+    @Autowired
+    private VisitorCommonConfigProperties visitorCommonConfigProperties;
+
+    @CloudwalkParamsValidate
+    public CloudwalkResult<Boolean> edit(VisitorConfigEditParam param, CloudwalkCallContext context) throws ServiceException {
+        try {
+            this.logger.debug("\u4fee\u6539\u8bbf\u5ba2\u914d\u7f6e\u5165\u53c2:VisitorConfigEditParam=[{}], CloudwalkCallContext=[{}]", (Object)JSONObject.toJSONString((Object)param), (Object)JSONObject.toJSONString((Object)context));
+            Integer count = 0;
+            if (StringUtils.isEmpty((Object)param.getId())) {
+                VisitorConfigAddDto addDto = new VisitorConfigAddDto();
+                BeanCopyUtils.copyProperties((Object)param, (CloudwalkCallContext)context, (Object)addDto);
+                addDto.setId(this.genUUID());
+                addDto.setBusinessId(context.getCompany().getCompanyId());
+                count = this.visitorConfigManager.insert(addDto);
+            } else {
+                VisitorConfigEditDto updateDto = new VisitorConfigEditDto();
+                BeanCopyUtils.copyProperties((Object)param, (CloudwalkCallContext)context, (Object)updateDto);
+                updateDto.setId(param.getId());
+                updateDto.setBusinessId(context.getCompany().getCompanyId());
+                count = this.visitorConfigManager.update(updateDto);
+            }
+            this.logger.debug("\u4fee\u6539\u8bbf\u5ba2\u914d\u7f6e\u51fa\u53c2:\u6dfb\u52a0/\u66f4\u65b0\u6761\u6570\u4e3a:[{}]", (Object)count);
+            return CloudwalkResult.success((Object)true);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u4fee\u6539\u8bbf\u5ba2\u914d\u7f6e\u5f02\u5e38\uff0c\u539f\u56e0\uff1a[{}]", (Object)e.getMessage(), (Object)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<List<VisitorConfigQueryResult>> query(VisitorConfigQueryParam param, CloudwalkCallContext context) throws ServiceException {
+        try {
+            this.logger.debug("\u67e5\u8be2\u8bbf\u5ba2\u914d\u7f6e\u5165\u53c2:VisitorConfigQueryParam=[{}], CloudwalkCallContext=[{}]", (Object)JSONObject.toJSONString((Object)param), (Object)JSONObject.toJSONString((Object)context));
+            VisitorConfigQueryDto queryDto = new VisitorConfigQueryDto();
+            BeanCopyUtils.copyProperties((Object)param, (Object)queryDto);
+            queryDto.setBusinessId(context.getCompany().getCompanyId());
+            List list = this.visitorConfigManager.query(queryDto);
+            list.stream().forEach(item -> {
+                if (item.getConfigKey().equals(VisitorConfigKeyEnum.YZT_WX_MINI_PROGRAM_QRCODE_PATH.getCode())) {
+                    item.setConfigValue(this.visitorCommonConfigProperties.getCwosFilePath() + item.getConfigValue());
+                }
+            });
+            return CloudwalkResult.success((Object)BeanCopyUtils.copy((Collection)list, VisitorConfigQueryResult.class));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u67e5\u8be2\u8bbf\u5ba2\u914d\u7f6e\u5f02\u5e38\uff0c\u539f\u56e0\uff1a[{}]", (Object)e.getMessage(), (Object)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/corp/CorpServiceImpl.java

@@ -0,0 +1,45 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.davinci.portal.enterprise.param.EnterpriseBasicParam
+ *  cn.cloudwalk.client.davinci.portal.enterprise.result.EnterpriseDetailResult
+ *  cn.cloudwalk.client.ninca.visitor.corp.CorpService
+ *  cn.cloudwalk.client.ninca.visitor.corp.result.CorpResult
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cwos.client.resource.ResourceClient
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.visitor.corp;
+
+import cn.cloudwalk.client.davinci.portal.enterprise.param.EnterpriseBasicParam;
+import cn.cloudwalk.client.davinci.portal.enterprise.result.EnterpriseDetailResult;
+import cn.cloudwalk.client.ninca.visitor.corp.CorpService;
+import cn.cloudwalk.client.ninca.visitor.corp.result.CorpResult;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cwos.client.resource.ResourceClient;
+import cn.cloudwalk.service.ninca.visitor.common.AbstractCloudwalkService;
+import org.springframework.stereotype.Service;
+
+@Service
+public class CorpServiceImpl
+extends AbstractCloudwalkService
+implements CorpService {
+    public CloudwalkResult<CorpResult> get(CloudwalkCallContext context) throws ServiceException {
+        CorpResult corpResult = new CorpResult();
+        EnterpriseBasicParam remoteParam = new EnterpriseBasicParam();
+        remoteParam.setId(context.getCompany().getCompanyId());
+        CloudwalkResult remoteResult = ResourceClient.getInstance().getPortalEnterpriseService().detail(remoteParam, context);
+        if (remoteResult.isSuccess() && remoteResult.getData() != null) {
+            corpResult.setCorpCode(((EnterpriseDetailResult)remoteResult.getData()).getCorpCode());
+            corpResult.setCorpName(((EnterpriseDetailResult)remoteResult.getData()).getCorpName());
+            return CloudwalkResult.success((Object)corpResult);
+        }
+        return CloudwalkResult.fail((String)remoteResult.getCode(), (String)remoteResult.getMessage());
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/device/DeviceContextServiceImpl.java

@@ -0,0 +1,78 @@
+/*
+ * 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.result.DeviceResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceService
+ *  cn.cloudwalk.client.ninca.visitor.device.service.DeviceContextService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.common.ninca.visitor.device.DeviceContext
+ *  cn.cloudwalk.common.ninca.visitor.util.CollectionUtils
+ *  org.apache.commons.lang3.StringUtils
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.visitor.device;
+
+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.visitor.device.service.DeviceContextService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.common.ninca.visitor.device.DeviceContext;
+import cn.cloudwalk.common.ninca.visitor.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.visitor.common.AbstractCloudwalkService;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class DeviceContextServiceImpl
+extends AbstractCloudwalkService
+implements DeviceContextService {
+    protected static final Logger LOGGER = LoggerFactory.getLogger(DeviceContextServiceImpl.class);
+    @Autowired
+    private DeviceService deviceService;
+
+    public CloudwalkResult<DeviceContext> get(CloudwalkCallContext context, String deviceCode) throws ServiceException {
+        if (StringUtils.isBlank((CharSequence)deviceCode)) {
+            LOGGER.error("\u8bf7\u6c42\u53c2\u6570\u7f3a\u5c11[device_id]");
+            throw new ServiceException("762598001", "\u8bbe\u5907\u7f16\u53f7\u4e0d\u80fd\u4e3a\u7a7a");
+        }
+        DeviceQueryParam deviceQueryParam = new DeviceQueryParam();
+        deviceQueryParam.setDeviceCode(deviceCode);
+        Map<String, String> areaMap = this.getDeviceAreaMap(context);
+        CloudwalkResult deviceResult = this.deviceService.list(deviceQueryParam, context);
+        if (deviceResult.isSuccess() && CollectionUtils.isNotEmpty((Collection)((Collection)deviceResult.getData()))) {
+            DeviceContext deviceContext = new DeviceContext();
+            DeviceResult device = (DeviceResult)((List)deviceResult.getData()).get(0);
+            deviceContext.setDeviceTypeId(device.getDeviceTypeId());
+            deviceContext.setDeviceTypeName(device.getDeviceTypeName());
+            deviceContext.setDeviceId(device.getId());
+            deviceContext.setDeviceCode(device.getDeviceCode());
+            deviceContext.setDeviceName(device.getDeviceName());
+            deviceContext.setDeviceDistrictId(device.getDistrictId());
+            deviceContext.setDeviceDistrictName(device.getDistrictName());
+            deviceContext.setDeviceDistrictPath(device.getDistrictPath());
+            deviceContext.setDeviceDistrictMergeName(device.getDistrictMergeName());
+            deviceContext.setDeviceAreaId(device.getAreaId());
+            deviceContext.setDeviceAreaName(areaMap.get(device.getAreaId()));
+            return CloudwalkResult.success((Object)deviceContext);
+        }
+        LOGGER.error("\u67e5\u8be2\u8bbe\u5907\u5931\u8d25\uff0c\u9519\u8bef\u7801\uff1a{}\uff0c\u539f\u56e0\uff1a{}", (Object)deviceResult.getCode(), (Object)deviceResult.getMessage());
+        throw new ServiceException("762598006", "\u6ca1\u6709\u627e\u5230\u8be5\u8bbe\u5907");
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/device/DeviceDefaultServiceImpl.java

@@ -0,0 +1,317 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.ninca.visitor.deivce.DeviceDefaultManager
+ *  cn.cloudwalk.biz.ninca.visitor.deivce.DeviceImageStoreManager
+ *  cn.cloudwalk.biz.ninca.visitor.deivce.VisitorDeviceManager
+ *  cn.cloudwalk.biz.ninca.visitor.visitor.VisitorManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.application.param.ApplicationImageStoreDelParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.application.service.ApplicationImageStoreService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceApplicationParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceImageStoreParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.result.DeviceResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceApplicationService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceImageStoreService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStoreDelParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.service.ImageStoreService
+ *  cn.cloudwalk.client.ninca.visitor.device.param.DeviceDefaultEditParam
+ *  cn.cloudwalk.client.ninca.visitor.device.param.DeviceDefaultGetsParam
+ *  cn.cloudwalk.client.ninca.visitor.device.param.VisitorDeviceNewPageParam
+ *  cn.cloudwalk.client.ninca.visitor.device.result.DeviceDefaultResult
+ *  cn.cloudwalk.client.ninca.visitor.device.result.VisitorDeviceResult
+ *  cn.cloudwalk.client.ninca.visitor.device.service.DeviceDefaultService
+ *  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.accesscontrol.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceDefaultDeleteDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceDefaultGetsDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceDefaultNewDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceDefaultResultDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreDeleteDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreQueryDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreResultDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceGetsDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceResultDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorGetsDTO
+ *  cn.cloudwalk.common.ninca.visitor.em.ImageStoreStatusEnum
+ *  cn.cloudwalk.common.ninca.visitor.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.visitor.util.StringUtils
+ *  cn.cloudwalk.data.ninca.visitor.device.dao.DeviceImageStoreDao
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.cache.annotation.CacheEvict
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.visitor.device;
+
+import cn.cloudwalk.biz.ninca.visitor.deivce.DeviceDefaultManager;
+import cn.cloudwalk.biz.ninca.visitor.deivce.DeviceImageStoreManager;
+import cn.cloudwalk.biz.ninca.visitor.deivce.VisitorDeviceManager;
+import cn.cloudwalk.biz.ninca.visitor.visitor.VisitorManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.application.param.ApplicationImageStoreDelParam;
+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.DeviceImageStoreParam;
+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.DeviceApplicationService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceImageStoreService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStoreDelParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.service.ImageStoreService;
+import cn.cloudwalk.client.ninca.visitor.device.param.DeviceDefaultEditParam;
+import cn.cloudwalk.client.ninca.visitor.device.param.DeviceDefaultGetsParam;
+import cn.cloudwalk.client.ninca.visitor.device.param.VisitorDeviceNewPageParam;
+import cn.cloudwalk.client.ninca.visitor.device.result.DeviceDefaultResult;
+import cn.cloudwalk.client.ninca.visitor.device.result.VisitorDeviceResult;
+import cn.cloudwalk.client.ninca.visitor.device.service.DeviceDefaultService;
+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.visitor.bean.device.dto.DeviceDefaultDeleteDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceDefaultGetsDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceDefaultNewDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceDefaultResultDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreDeleteDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreQueryDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreResultDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceGetsDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceResultDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorGetsDTO;
+import cn.cloudwalk.common.ninca.visitor.em.ImageStoreStatusEnum;
+import cn.cloudwalk.common.ninca.visitor.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.visitor.util.StringUtils;
+import cn.cloudwalk.data.ninca.visitor.device.dao.DeviceImageStoreDao;
+import cn.cloudwalk.service.ninca.visitor.common.AbstractCloudwalkService;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.stereotype.Service;
+
+@Service
+public class DeviceDefaultServiceImpl
+extends AbstractCloudwalkService
+implements DeviceDefaultService {
+    private static final Logger log = LoggerFactory.getLogger(DeviceDefaultServiceImpl.class);
+    @Autowired
+    private DeviceDefaultManager deviceDefaultManager;
+    @Autowired
+    private DeviceService deviceService;
+    @Autowired
+    private DeviceApplicationService deviceApplicationService;
+    @Autowired
+    private DeviceImageStoreManager deviceImageStoreManager;
+    @Autowired
+    private VisitorDeviceManager visitorDeviceManager;
+    @Autowired
+    private VisitorManager visitorManager;
+    @Autowired
+    private DeviceImageStoreDao deviceImageStoreDao;
+    @Autowired
+    private DeviceImageStoreService deviceImageStoreService;
+    @Autowired
+    private ImageStoreService imageStoreService;
+    @Autowired
+    private ApplicationImageStoreService applicationImageStoreService;
+
+    @CacheEvict(cacheNames={"VistiorManagementDeviceDefaultCache"}, key="T(cn.cloudwalk.biz.ninca.visitor.cache.VisitorCacheOverrideConfig).CACHE_KEY_DEVICE_DEFAULT_PREFIX + #context.company.companyId")
+    public CloudwalkResult<Boolean> edit(DeviceDefaultEditParam param, CloudwalkCallContext context) throws ServiceException, DataAccessException {
+        DeviceDefaultDeleteDTO deleteDTO = new DeviceDefaultDeleteDTO();
+        deleteDTO.setBusinessId(context.getCompany().getCompanyId());
+        DeviceDefaultGetsDTO deviceDefaultGetsDTO = new DeviceDefaultGetsDTO();
+        deviceDefaultGetsDTO.setBusinessId(context.getCompany().getCompanyId());
+        List deviceIds = this.deviceDefaultManager.gets(deviceDefaultGetsDTO);
+        this.deviceDefaultManager.delete(deleteDTO);
+        log.info("\u5220\u9664\u8bbe\u5907{}\u4e2a", (Object)deviceIds.size());
+        if (CollectionUtils.isNotEmpty((Collection)deviceIds)) {
+            deviceIds.forEach(element -> this.delBind(element.getDeviceId(), element.getBusinessId(), context));
+        }
+        if (CollectionUtils.isNotEmpty((Collection)param.getDeviceIds())) {
+            ArrayList<DeviceDefaultNewDTO> deviceDefaultList = new ArrayList<DeviceDefaultNewDTO>(param.getDeviceIds().size());
+            for (String deviceId : param.getDeviceIds()) {
+                DeviceDefaultNewDTO newDTO = new DeviceDefaultNewDTO();
+                newDTO.setId(this.genUUID());
+                newDTO.setBusinessId(context.getCompany().getCompanyId());
+                newDTO.setDeviceId(deviceId);
+                deviceDefaultList.add(newDTO);
+            }
+            this.deviceDefaultManager.batchInsert(deviceDefaultList);
+            deviceDefaultList.forEach(ele -> this.bindApp(ele.getDeviceId(), context));
+        }
+        return CloudwalkResult.success((Object)true);
+    }
+
+    public CloudwalkResult<List<DeviceDefaultResult>> gets(DeviceDefaultGetsParam param, CloudwalkCallContext context) throws ServiceException, DataAccessException {
+        ArrayList<DeviceDefaultResult> results = new ArrayList<DeviceDefaultResult>();
+        DeviceDefaultGetsDTO defaultGetsDTO = new DeviceDefaultGetsDTO();
+        defaultGetsDTO.setBusinessId(context.getCompany().getCompanyId());
+        List deviceDefaultList = this.deviceDefaultManager.gets(defaultGetsDTO);
+        if (CollectionUtils.isNotEmpty((Collection)deviceDefaultList)) {
+            DeviceQueryParam deviceQueryParam = new DeviceQueryParam();
+            List deviceIds = deviceDefaultList.stream().map(DeviceDefaultResultDTO::getDeviceId).collect(Collectors.toList());
+            deviceQueryParam.setIds(deviceIds);
+            CloudwalkResult deviceResult = this.deviceService.list(deviceQueryParam, context);
+            if (deviceResult.isSuccess()) {
+                for (DeviceResult device : (List)deviceResult.getData()) {
+                    DeviceDefaultResult deviceDefaultResult = new DeviceDefaultResult();
+                    deviceDefaultResult.setDeviceId(device.getId());
+                    deviceDefaultResult.setDeviceCode(device.getDeviceCode());
+                    deviceDefaultResult.setDeviceName(device.getDeviceName());
+                    results.add(deviceDefaultResult);
+                }
+            } else {
+                return CloudwalkResult.fail((String)deviceResult.getCode(), (String)deviceResult.getMessage());
+            }
+            return CloudwalkResult.success(results);
+        }
+        return CloudwalkResult.success(null);
+    }
+
+    public CloudwalkResult<CloudwalkPageAble<VisitorDeviceResult>> page(VisitorDeviceNewPageParam param, CloudwalkPageInfo pageInfo, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        ArrayList<VisitorDeviceResult> 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() || cn.cloudwalk.common.ninca.accesscontrol.util.CollectionUtils.isEmpty((Collection)((Collection)deviceResult.getData()))) {
+            return CloudwalkResult.success((Object)new CloudwalkPageAble(result, pageInfo, 0L));
+        }
+        result = ((List)deviceResult.getData()).stream().map(s -> (VisitorDeviceResult)BeanCopyUtils.copyProperties((Object)s, VisitorDeviceResult.class)).collect(Collectors.toList());
+        return CloudwalkResult.success((Object)new CloudwalkPageAble(this.page(result, pageInfo.getPageSize(), pageInfo.getCurrentPage()), pageInfo, (long)result.size()));
+    }
+
+    private List<VisitorDeviceResult> page(List<VisitorDeviceResult> dataList, int pageSize, int currentPage) {
+        ArrayList<VisitorDeviceResult> currentPageList = new ArrayList<VisitorDeviceResult>();
+        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) {
+                VisitorDeviceResult data = dataList.get(currIdx + i);
+                currentPageList.add(data);
+            }
+        }
+        return currentPageList;
+    }
+
+    private void delBind(String deviceId, String businessId, CloudwalkCallContext context) {
+        log.info("\u5224\u65ad\u662f\u5426\u9700\u8981\u89e3\u7ed1\u8bbe\u5907{}", (Object)deviceId);
+        try {
+            VisitorDeviceGetsDTO visitorDeviceGetsDTO = new VisitorDeviceGetsDTO();
+            visitorDeviceGetsDTO.setBusinessId(businessId);
+            visitorDeviceGetsDTO.setDeviceId(deviceId);
+            List deviceVistors = this.visitorDeviceManager.gets(visitorDeviceGetsDTO);
+            log.info("\u8bbe\u5907{}\u4e0b\u7684\u8bbf\u5ba2\u6570\u91cf\u4e3a{}", (Object)deviceId, (Object)deviceVistors.size());
+            if (CollectionUtils.isEmpty((Collection)deviceVistors)) {
+                log.info("\u8bbe\u5907{}\u4e0b\u7684\u8bbf\u5ba2\u6570\u91cf\u4e3a0\uff0c\u89e3\u9664\u7ed1\u5b9a\u8bbe\u5907\u4e0e\u5e94\u7528{}", (Object)deviceId, (Object)context.getApplicationId());
+                this.delBindDeviceApp(deviceId, context);
+            }
+            ArrayList visitorIds = new ArrayList();
+            deviceVistors.forEach(visit -> visitorIds.add(visit.getVisitorId()));
+            VisitorGetsDTO visitorGetsDTO = new VisitorGetsDTO();
+            visitorGetsDTO.setBusinessId(businessId);
+            visitorGetsDTO.setIds(visitorIds);
+            List visitors = this.visitorManager.gets(visitorGetsDTO);
+            HashMap<String, Integer> visitorToImgStatus = new HashMap<String, Integer>(visitors.size());
+            visitors.forEach(vistor -> visitorToImgStatus.put(vistor.getId(), vistor.getImageStoreStatus()));
+            if (this.needDelBind(deviceVistors, visitorToImgStatus)) {
+                this.delBindDeviceApp(deviceId, context);
+            }
+        }
+        catch (DataAccessException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void delBindDeviceApp(String deviceId, CloudwalkCallContext context) {
+        log.info("{}\u8bbe\u5907\u9700\u5220\u9664\u4e0e\u5e94\u7528{}\u7684\u5173\u7cfb", (Object)deviceId, (Object)context.getApplicationId());
+        try {
+            DeviceImageStoreQueryDTO dto = new DeviceImageStoreQueryDTO();
+            dto.setBusinessId(context.getCompany().getCompanyId());
+            dto.setDeviceId(deviceId);
+            DeviceImageStoreResultDTO deviceImageStoreResultDTO = this.deviceImageStoreDao.queryByDeviceId(dto);
+            DeviceImageStoreParam param = new DeviceImageStoreParam();
+            param.setDeviceId(deviceId);
+            param.setImageStoreId(deviceImageStoreResultDTO.getImageStoreId());
+            CloudwalkResult isDeleteImg = this.deviceImageStoreService.delete(param, null);
+            CloudwalkResult isDeleteApp = null;
+            String applicationId = null;
+            if ("00000000".equals(isDeleteImg.getCode())) {
+                this.logger.info("\u89e3\u9664\u8bbe\u5907\u5e94\u7528\u7ed1\u5b9a{}{}{}", new Object[]{isDeleteImg.getMessage(), deviceId, deviceImageStoreResultDTO.getImageStoreId()});
+                DeviceApplicationParam deviceImageStoreParam = new DeviceApplicationParam();
+                deviceImageStoreParam.setDeviceId(deviceId);
+                deviceImageStoreParam.setApplicationId(context.getApplicationId());
+                isDeleteApp = this.deviceApplicationService.delete(deviceImageStoreParam, context);
+            }
+            if ("00000000".equals(isDeleteApp.getCode())) {
+                this.logger.info("\u89e3\u9664\u56fe\u5e93\u548c\u5e94\u7528\u7684\u5173\u7cfb");
+                ApplicationImageStoreDelParam delParam = new ApplicationImageStoreDelParam();
+                delParam.setApplicationId(applicationId);
+                delParam.setImageStoreId(deviceImageStoreResultDTO.getImageStoreId());
+                this.applicationImageStoreService.delete(delParam, context);
+                this.logger.info("\u5220\u9664\u56fe\u5e93");
+                ImageStoreDelParam imageStoreDelParam = new ImageStoreDelParam();
+                imageStoreDelParam.setId(deviceImageStoreResultDTO.getImageStoreId());
+                CloudwalkResult delete = this.imageStoreService.delete(imageStoreDelParam, context);
+                DeviceImageStoreDeleteDTO deviceImageStoreDeleteDTO = new DeviceImageStoreDeleteDTO();
+                deviceImageStoreDeleteDTO.setBusinessId(context.getCompany().getCompanyId());
+                deviceImageStoreDeleteDTO.setDeviceId(deviceId);
+                this.deviceImageStoreManager.deleteByDeviceId(deviceImageStoreDeleteDTO);
+            }
+        }
+        catch (ServiceException e) {
+            log.info("\u89e3\u9664\u7ed1\u5b9a\u5931\u8d25", (Throwable)e);
+        }
+        catch (DataAccessException e) {
+            log.info("\u5220\u9664\u8bbe\u5907\u4e0e\u56fe\u5e93\u4fe1\u606f\u5931\u8d25", (Throwable)e);
+        }
+    }
+
+    private boolean needDelBind(List<VisitorDeviceResultDTO> deviceVistors, Map<String, Integer> visitorToImgStatus) {
+        log.info("\u5224\u65ad\u8bbe\u5907\u662f\u5426\u9700\u8981\u89e3\u7ed1");
+        for (VisitorDeviceResultDTO deviceVistor : deviceVistors) {
+            log.info("\u4eba\u5458\u72b6\u6001{},{}", (Object)deviceVistor.getVisitorId(), (Object)visitorToImgStatus.get(deviceVistor.getVisitorId()));
+            if (!CollectionUtils.isNotEmpty(visitorToImgStatus) || !visitorToImgStatus.containsKey(deviceVistor.getVisitorId()) || !ImageStoreStatusEnum.NORMAL.getCode().equals(visitorToImgStatus.get(deviceVistor.getVisitorId()))) continue;
+            log.info("{}\u672a\u8fc7\u671f", (Object)deviceVistor.getVisitorId());
+            return false;
+        }
+        return true;
+    }
+
+    private void bindApp(String deviceId, CloudwalkCallContext context) {
+        log.info("\u7ed1\u5b9a\u8bbe\u5907{}\u4e0e\u5e94\u7528{}", (Object)deviceId, (Object)context.getApplicationId());
+        try {
+            DeviceApplicationParam deviceApplicationParam = new DeviceApplicationParam();
+            deviceApplicationParam.setDeviceId(deviceId);
+            deviceApplicationParam.setApplicationId(context.getApplicationId());
+            this.deviceApplicationService.add(deviceApplicationParam, context);
+        }
+        catch (ServiceException e) {
+            log.info("\u7ed1\u5b9a\u8bbe\u5907{}\u4e0e\u5e94\u7528{}\u51fa\u73b0\u5f02\u5e38", new Object[]{deviceId, context.getApplicationId(), e});
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/device/VisitorDeviceImageStoreServiceImpl.java

@@ -0,0 +1,205 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.ninca.visitor.deivce.DeviceImageStoreManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.application.param.ApplicationImageStoreAddParam
+ *  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.DeviceQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.result.DeviceResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceApplicationService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceImageStoreService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStoreAddParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.service.ImageStoreService
+ *  cn.cloudwalk.client.ninca.visitor.common.VisitorApplicationService
+ *  cn.cloudwalk.client.ninca.visitor.device.param.DeviceImageStoreAddParam
+ *  cn.cloudwalk.client.ninca.visitor.device.param.DeviceImageStoreGetParam
+ *  cn.cloudwalk.client.ninca.visitor.device.service.VisitorDeviceImageStoreService
+ *  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.visitor.bean.device.dto.DeviceImageStoreNewDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreQueryDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreResultDTO
+ *  cn.cloudwalk.common.ninca.visitor.util.CollectionUtils
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.visitor.device;
+
+import cn.cloudwalk.biz.ninca.visitor.deivce.DeviceImageStoreManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.application.param.ApplicationImageStoreAddParam;
+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.DeviceQueryParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.result.DeviceResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceApplicationService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceImageStoreService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStoreAddParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.service.ImageStoreService;
+import cn.cloudwalk.client.ninca.visitor.common.VisitorApplicationService;
+import cn.cloudwalk.client.ninca.visitor.device.param.DeviceImageStoreAddParam;
+import cn.cloudwalk.client.ninca.visitor.device.param.DeviceImageStoreGetParam;
+import cn.cloudwalk.client.ninca.visitor.device.service.VisitorDeviceImageStoreService;
+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.visitor.bean.device.dto.DeviceImageStoreNewDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreQueryDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreResultDTO;
+import cn.cloudwalk.common.ninca.visitor.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.visitor.common.AbstractCloudwalkService;
+import java.util.Collection;
+import java.util.List;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class VisitorDeviceImageStoreServiceImpl
+extends AbstractCloudwalkService
+implements VisitorDeviceImageStoreService {
+    @Autowired
+    private DeviceImageStoreManager deviceImageStoreManager;
+    @Autowired
+    private ImageStoreService imageStoreService;
+    @Autowired
+    private DeviceImageStoreService deviceImageStoreService;
+    @Autowired
+    private DeviceApplicationService deviceApplicationService;
+    @Autowired
+    private VisitorApplicationService visitorApplicationService;
+    @Autowired
+    private DeviceService deviceService;
+    @Autowired
+    private ApplicationImageStoreService applicationImageStoreService;
+
+    public CloudwalkResult<String> add(DeviceImageStoreAddParam param, CloudwalkCallContext context) throws ServiceException {
+        this.deviceApplicationBind(param.getDeviceId(), context);
+        String imageStoreId = this.deviceImageStoreAdd(param.getDeviceId(), context);
+        try {
+            DeviceImageStoreNewDTO newDTO = new DeviceImageStoreNewDTO();
+            BeanCopyUtils.copyProperties((Object)param, (CloudwalkCallContext)context, (Object)newDTO);
+            newDTO.setId(this.genUUID());
+            newDTO.setBusinessId(context.getCompany().getCompanyId());
+            newDTO.setDeviceId(param.getDeviceId());
+            newDTO.setImageStoreId(imageStoreId);
+            this.deviceImageStoreManager.add(newDTO);
+            this.deviceImageStoreBind(param.getDeviceId(), imageStoreId, context);
+            return CloudwalkResult.success((Object)imageStoreId);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u4fdd\u5b58\u8bbe\u5907\u5bf9\u5e94\u56fe\u5e93\u5173\u7cfb\u5931\u8d25,\u539f\u56e0:{}", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<String> getDeviceImageStore(DeviceImageStoreGetParam param, CloudwalkCallContext context) throws ServiceException {
+        DeviceImageStoreQueryDTO queryDTO = new DeviceImageStoreQueryDTO();
+        queryDTO.setBusinessId(context.getCompany().getCompanyId());
+        queryDTO.setDeviceId(param.getDeviceId());
+        try {
+            DeviceImageStoreResultDTO resultDTO = this.deviceImageStoreManager.queryByDeviceId(queryDTO);
+            if (resultDTO != null) {
+                this.logger.info("\u67e5\u8be2\u8bbe\u5907{},\u56fe\u5e93{}", (Object)resultDTO.getDeviceId(), (Object)resultDTO.getImageStoreId());
+                return CloudwalkResult.success((Object)resultDTO.getImageStoreId());
+            }
+            DeviceImageStoreAddParam deviceImageStoreAddParam = new DeviceImageStoreAddParam();
+            deviceImageStoreAddParam.setDeviceId(param.getDeviceId());
+            return this.add(deviceImageStoreAddParam, context);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u67e5\u8be2\u8bbe\u5907\u5bf9\u5e94\u56fe\u5e93\u5931\u8d25,\u539f\u56e0:{}", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private String deviceImageStoreAdd(String deviceId, CloudwalkCallContext context) throws ServiceException {
+        String deviceCode = this.getDeviceCode(deviceId, context);
+        ImageStoreAddParam imageStoreAddParam = new ImageStoreAddParam();
+        imageStoreAddParam.setName("\u8bbf\u5ba2\u56fe\u5e93[" + deviceCode + "]");
+        imageStoreAddParam.setType(Short.valueOf((short)1));
+        imageStoreAddParam.setSourceApplicationId(this.getApplicationId(context));
+        CloudwalkResult imageStoreAddResult = this.imageStoreService.add(imageStoreAddParam, context);
+        if (imageStoreAddResult.isSuccess()) {
+            String imageStoreId = (String)imageStoreAddResult.getData();
+            this.imageStoreApplicationBind(imageStoreId, context);
+            return imageStoreId;
+        }
+        throw new ServiceException("\u521b\u5efa\u8bbe\u5907\u5bf9\u5e94\u56fe\u5e93\u5931\u8d25{}", imageStoreAddResult.getMessage());
+    }
+
+    private void imageStoreApplicationBind(String imagestoreId, CloudwalkCallContext context) throws ServiceException {
+        String applicationId = this.getApplicationId(context);
+        ApplicationImageStoreAddParam appImageStoreAddParam = new ApplicationImageStoreAddParam();
+        appImageStoreAddParam.setApplicationId(applicationId);
+        appImageStoreAddParam.setImageStoreId(imagestoreId);
+        CloudwalkResult result = this.applicationImageStoreService.add(appImageStoreAddParam, context);
+        if (!result.isSuccess()) {
+            throw new ServiceException("\u65b0\u589e\u5e94\u7528\u4e0e\u56fe\u5e93\u5173\u7cfb\u5931\u8d25");
+        }
+    }
+
+    private void deviceApplicationBind(String deviceId, CloudwalkCallContext context) throws ServiceException {
+        String applicationId = this.getApplicationId(context);
+        DeviceApplicationQueryParam deviceApplicationQueryParam = new DeviceApplicationQueryParam();
+        deviceApplicationQueryParam.setApplicationId(applicationId);
+        deviceApplicationQueryParam.setDeviceId(deviceId);
+        CloudwalkResult deviceApplicationQueryResult = this.deviceApplicationService.list(deviceApplicationQueryParam, context);
+        if (deviceApplicationQueryResult.isSuccess()) {
+            if (CollectionUtils.isNotEmpty((Collection)((Collection)deviceApplicationQueryResult.getData()))) {
+                this.logger.info("\u5df2\u6709\u7ed1\u5b9a");
+                return;
+            }
+            DeviceApplicationParam deviceApplicationParam = new DeviceApplicationParam();
+            deviceApplicationParam.setDeviceId(deviceId);
+            deviceApplicationParam.setApplicationId(applicationId);
+            this.logger.info("\u9700\u8981\u65b0\u589e\u7ed1\u5b9a");
+            CloudwalkResult deviceApplicationResult = this.deviceApplicationService.add(deviceApplicationParam, context);
+            if (!deviceApplicationResult.isSuccess()) {
+                this.logger.error("\u8bbe\u5907\u7ed1\u5b9a\u5e94\u7528\u5931\u8d25,\u8bbe\u5907id={},\u5e94\u7528id={}\uff0c\u539f\u56e0={}", new Object[]{deviceId, applicationId, deviceApplicationResult.getMessage()});
+                throw new ServiceException("\u8bbe\u5907\u7ed1\u5b9a\u5e94\u7528\u5931\u8d25");
+            }
+        } else {
+            this.logger.error("\u67e5\u8be2\u8bbe\u5907\u5e94\u7528\u7ed1\u5b9a\u5173\u7cfb\u5931\u8d25,\u8bbe\u5907id={},\u5e94\u7528id={}\uff0c\u539f\u56e0={}", new Object[]{deviceId, applicationId, deviceApplicationQueryResult.getMessage()});
+            throw new ServiceException("\u67e5\u8be2\u8bbe\u5907\u5e94\u7528\u7ed1\u5b9a\u5173\u7cfb\u5931\u8d25");
+        }
+    }
+
+    private void deviceImageStoreBind(String deviceId, String imageStoreId, CloudwalkCallContext context) throws ServiceException {
+        DeviceImageStoreParam deviceImageStoreParam = new DeviceImageStoreParam();
+        deviceImageStoreParam.setDeviceId(deviceId);
+        deviceImageStoreParam.setImageStoreId(imageStoreId);
+        CloudwalkResult deviceImageStoreResult = this.deviceImageStoreService.add(deviceImageStoreParam, context);
+        if (!deviceImageStoreResult.isSuccess()) {
+            this.logger.error("\u8bbe\u5907\u7ed1\u5b9a\u56fe\u5e93\u5931\u8d25,\u8bbe\u5907id={},\u56fe\u5e93id={}\uff0c\u539f\u56e0={}", new Object[]{deviceId, imageStoreId, deviceImageStoreResult.getMessage()});
+            throw new ServiceException("\u8bbe\u5907\u7ed1\u5b9a\u56fe\u5e93\u5931\u8d25");
+        }
+    }
+
+    private String getDeviceCode(String deviceId, CloudwalkCallContext context) throws ServiceException {
+        DeviceQueryParam deviceQueryParam = new DeviceQueryParam();
+        deviceQueryParam.setId(deviceId);
+        CloudwalkResult deviceResult = null;
+        deviceResult = this.deviceService.list(deviceQueryParam, context);
+        if (deviceResult.isSuccess() && CollectionUtils.isNotEmpty((Collection)((Collection)deviceResult.getData()))) {
+            return ((DeviceResult)((List)deviceResult.getData()).get(0)).getDeviceCode();
+        }
+        throw new ServiceException("\u672a\u67e5\u5230\u8be5\u8bbe\u5907,\u8bbe\u5907id=" + deviceId);
+    }
+
+    private String getApplicationId(CloudwalkCallContext context) throws ServiceException {
+        return this.visitorApplicationService.getApplicationId(context.getCompany().getCompanyId());
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/device/VisitorDeviceServiceImpl.java

@@ -0,0 +1,131 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.ninca.visitor.deivce.VisitorDeviceManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStorePersonBindParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStorePersonDelParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.service.ImageStorePersonService
+ *  cn.cloudwalk.client.ninca.visitor.device.service.VisitorDeviceService
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorDeviceAddParam
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorDeviceDelParam
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorDeviceEditParam
+ *  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.visitor.bean.device.dto.VisitorDeviceDeleteDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceNewDTO
+ *  cn.cloudwalk.common.ninca.visitor.util.CollectionUtils
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.visitor.device;
+
+import cn.cloudwalk.biz.ninca.visitor.deivce.VisitorDeviceManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStorePersonBindParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStorePersonDelParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.service.ImageStorePersonService;
+import cn.cloudwalk.client.ninca.visitor.device.service.VisitorDeviceService;
+import cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorDeviceAddParam;
+import cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorDeviceDelParam;
+import cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorDeviceEditParam;
+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.visitor.bean.device.dto.VisitorDeviceDeleteDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceNewDTO;
+import cn.cloudwalk.common.ninca.visitor.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.visitor.common.AbstractCloudwalkService;
+import java.util.Collection;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class VisitorDeviceServiceImpl
+extends AbstractCloudwalkService
+implements VisitorDeviceService {
+    @Autowired
+    private VisitorDeviceManager visitorDeviceManager;
+    @Autowired
+    private ImageStorePersonService imageStorePersonService;
+
+    public CloudwalkResult<Boolean> add(VisitorDeviceAddParam param, CloudwalkCallContext context) throws ServiceException {
+        VisitorDeviceNewDTO newDTO = new VisitorDeviceNewDTO();
+        BeanCopyUtils.copyProperties((Object)param, (CloudwalkCallContext)context, (Object)newDTO);
+        newDTO.setId(this.genUUID());
+        newDTO.setBusinessId(context.getCompany().getCompanyId());
+        try {
+            String imageStoeId = this.getDeviceImageStore(param.getDeviceId(), context);
+            this.visitorDeviceManager.add(newDTO);
+            ImageStorePersonBindParam imageStorePersonBindParam = new ImageStorePersonBindParam();
+            imageStorePersonBindParam.setImageStoreId(imageStoeId);
+            imageStorePersonBindParam.setPersonId(param.getVisitorId());
+            imageStorePersonBindParam.setExpiryBeginDate(param.getExpiryBeginDate());
+            imageStorePersonBindParam.setExpiryEndDate(param.getExpiryEndDate());
+            CloudwalkResult imageStorePersonResult = this.imageStorePersonService.bind(imageStorePersonBindParam, context);
+            if (imageStorePersonResult.isSuccess()) {
+                return CloudwalkResult.success((Object)true);
+            }
+            throw new ServiceException(imageStorePersonResult.getCode(), imageStorePersonResult.getMessage());
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u65b0\u589e\u8bbf\u5ba2\u8bbe\u5907\u5173\u8054\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<Boolean> edit(VisitorDeviceEditParam param, CloudwalkCallContext context) throws ServiceException {
+        for (String deviceId : param.getDeviceIds()) {
+            String imageStoreId = this.getDeviceImageStore(deviceId, context);
+            ImageStorePersonDelParam delParam = new ImageStorePersonDelParam();
+            delParam.setImageStoreId(imageStoreId);
+            delParam.setPersonId(param.getVisitorId());
+            CloudwalkResult deleteResult = this.imageStorePersonService.delete(delParam, context);
+            if (!deleteResult.isSuccess()) {
+                this.logger.error("\u56fe\u5e93\u4eba\u5458\u66f4\u65b0\u4e4b\u524d\u5148\u89e3\u7ed1\u5931\u8d25\uff0c\u539f\u56e0\uff1a[{}]", (Object)deleteResult.getMessage());
+                return CloudwalkResult.fail((String)"76260406", (String)(this.getMessage("76260406") + " " + deleteResult.getMessage()));
+            }
+            ImageStorePersonBindParam imageStorePersonBindParam = new ImageStorePersonBindParam();
+            imageStorePersonBindParam.setImageStoreId(imageStoreId);
+            imageStorePersonBindParam.setPersonId(param.getVisitorId());
+            imageStorePersonBindParam.setExpiryBeginDate(param.getExpiryBeginDate());
+            imageStorePersonBindParam.setExpiryEndDate(param.getExpiryEndDate());
+            CloudwalkResult bindResultCloudwalkResult = this.imageStorePersonService.bind(imageStorePersonBindParam, context);
+            if (bindResultCloudwalkResult.isSuccess()) continue;
+            this.logger.error("\u56fe\u5e93\u4eba\u5458\u66f4\u65b0\u5931\u8d25,imageStoreId=[{}],personId=[{}],\u539f\u56e0\uff1a[{}]", new Object[]{imageStoreId, param.getVisitorId(), bindResultCloudwalkResult.getMessage()});
+            return CloudwalkResult.fail((String)bindResultCloudwalkResult.getCode(), (String)bindResultCloudwalkResult.getMessage());
+        }
+        return CloudwalkResult.success((Object)true);
+    }
+
+    public CloudwalkResult<Boolean> delete(VisitorDeviceDelParam param, CloudwalkCallContext context) throws ServiceException {
+        if (CollectionUtils.isNotEmpty((Collection)param.getDeviceIds())) {
+            VisitorDeviceDeleteDTO deviceDeleteDTO = new VisitorDeviceDeleteDTO();
+            BeanCopyUtils.copyProperties((Object)param, (CloudwalkCallContext)context, (Object)deviceDeleteDTO);
+            deviceDeleteDTO.setBusinessId(context.getCompany().getCompanyId());
+            try {
+                this.visitorDeviceManager.delete(deviceDeleteDTO);
+                for (String deviceId : param.getDeviceIds()) {
+                    ImageStorePersonDelParam imageStorePersonDelParam = new ImageStorePersonDelParam();
+                    String imageStoreId = super.getDeviceImageStore(deviceId, context);
+                    imageStorePersonDelParam.setImageStoreId(imageStoreId);
+                    imageStorePersonDelParam.setPersonId(param.getVisitorId());
+                    CloudwalkResult imageStorePersonDeleteResult = this.imageStorePersonService.delete(imageStorePersonDelParam, context);
+                    if (imageStorePersonDeleteResult.isSuccess()) continue;
+                    this.logger.error("\u5220\u9664\u56fe\u5e93\u4eba\u5458\u5931\u8d25,\u56fe\u5e93id={},\u4eba\u5458id={},\u539f\u56e0\uff1a{}", new Object[]{imageStoreId, param.getVisitorId(), imageStorePersonDeleteResult.getMessage()});
+                }
+                return CloudwalkResult.success((Object)true);
+            }
+            catch (DataAccessException e) {
+                this.logger.error("\u65b0\u589e\u8bbf\u5ba2\u8bbe\u5907\u5173\u8054\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+                throw new ServiceException((Throwable)e);
+            }
+        }
+        return CloudwalkResult.success((Object)true);
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/downloadcenter/VisitorDownloadCenterServiceImpl.java

@@ -0,0 +1,111 @@
+/*
+ * 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.visitor.downloadcenter.VisitorDownloadCenterService
+ *  cn.cloudwalk.client.ninca.visitor.downloadcenter.param.VisitorFileFinishParam
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.visitor.config.VisitorFeignThreadLocalUtil
+ *  cn.cloudwalk.common.ninca.visitor.em.VisitorFileStatusEnum
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.visitor.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.visitor.downloadcenter.VisitorDownloadCenterService;
+import cn.cloudwalk.client.ninca.visitor.downloadcenter.param.VisitorFileFinishParam;
+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.visitor.config.VisitorFeignThreadLocalUtil;
+import cn.cloudwalk.common.ninca.visitor.em.VisitorFileStatusEnum;
+import cn.cloudwalk.service.ninca.visitor.common.AbstractCloudwalkService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class VisitorDownloadCenterServiceImpl
+extends AbstractCloudwalkService
+implements VisitorDownloadCenterService {
+    @Autowired
+    private FileService fileService;
+
+    public String createDownload(String fileName, CloudwalkCallContext context) {
+        try {
+            FileInitParam fileInitParam = new FileInitParam();
+            fileInitParam.setFileName(fileName);
+            fileInitParam.setApplicationId(context.getApplicationId());
+            VisitorFeignThreadLocalUtil.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 {
+            VisitorFeignThreadLocalUtil.remove();
+        }
+    }
+
+    /*
+     * WARNING - Removed try catching itself - possible behaviour change.
+     */
+    public boolean finishDownload(VisitorFileFinishParam param, CloudwalkCallContext context) {
+        try {
+            VisitorFeignThreadLocalUtil.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 {
+            VisitorFeignThreadLocalUtil.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 VisitorFileStatusEnum.PRODUCING.getCode();
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/export/VisitorAbstractExportAsyncService.java

@@ -0,0 +1,500 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.ninca.visitor.export.VisitorParallelismDownloadManager
+ *  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.visitor.downloadcenter.VisitorDownloadCenterService
+ *  cn.cloudwalk.client.ninca.visitor.downloadcenter.param.VisitorFileFinishParam
+ *  cn.cloudwalk.client.ninca.visitor.storage.service.FileStorageService
+ *  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.accesscontrol.common.ExcelCallback
+ *  cn.cloudwalk.common.ninca.accesscontrol.config.FeignThreadLocalUtil
+ *  cn.cloudwalk.common.ninca.accesscontrol.em.AcsFileStatusEnum
+ *  cn.cloudwalk.common.ninca.accesscontrol.util.StringUtils
+ *  cn.cloudwalk.common.ninca.visitor.annotation.ExcelAttribute
+ *  cn.cloudwalk.common.ninca.visitor.config.VisitorFeignThreadLocalUtil
+ *  cn.cloudwalk.common.ninca.visitor.em.VisitorFileStatusEnum
+ *  cn.cloudwalk.common.ninca.visitor.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.visitor.util.DateUtils
+ *  cn.cloudwalk.common.ninca.visitor.util.ExcelUtil
+ *  cn.cloudwalk.common.ninca.visitor.util.StringUtils
+ *  cn.cloudwalk.intelligent.davinci.common.exception.DavinciServiceException
+ *  cn.cloudwalk.intelligent.davinci.storage.bean.file.dto.FileRemoveDTO
+ *  cn.cloudwalk.intelligent.davinci.storage.manager.FileStorageManager
+ *  cn.cloudwalk.intelligent.lock.annotation.RequiredLock
+ *  com.github.pagehelper.PageInfo
+ *  com.google.common.collect.Lists
+ *  javax.annotation.Resource
+ *  org.apache.poi.hssf.usermodel.HSSFCell
+ *  org.apache.poi.hssf.usermodel.HSSFClientAnchor
+ *  org.apache.poi.hssf.usermodel.HSSFPatriarch
+ *  org.apache.poi.hssf.usermodel.HSSFRow
+ *  org.apache.poi.hssf.usermodel.HSSFSheet
+ *  org.apache.poi.hssf.usermodel.HSSFWorkbook
+ *  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.visitor.export;
+
+import cn.cloudwalk.biz.ninca.visitor.export.VisitorParallelismDownloadManager;
+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.visitor.downloadcenter.VisitorDownloadCenterService;
+import cn.cloudwalk.client.ninca.visitor.downloadcenter.param.VisitorFileFinishParam;
+import cn.cloudwalk.client.ninca.visitor.storage.service.FileStorageService;
+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.accesscontrol.common.ExcelCallback;
+import cn.cloudwalk.common.ninca.accesscontrol.config.FeignThreadLocalUtil;
+import cn.cloudwalk.common.ninca.accesscontrol.em.AcsFileStatusEnum;
+import cn.cloudwalk.common.ninca.visitor.annotation.ExcelAttribute;
+import cn.cloudwalk.common.ninca.visitor.config.VisitorFeignThreadLocalUtil;
+import cn.cloudwalk.common.ninca.visitor.em.VisitorFileStatusEnum;
+import cn.cloudwalk.common.ninca.visitor.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.visitor.util.DateUtils;
+import cn.cloudwalk.common.ninca.visitor.util.ExcelUtil;
+import cn.cloudwalk.common.ninca.visitor.util.StringUtils;
+import cn.cloudwalk.intelligent.davinci.common.exception.DavinciServiceException;
+import cn.cloudwalk.intelligent.davinci.storage.bean.file.dto.FileRemoveDTO;
+import cn.cloudwalk.intelligent.davinci.storage.manager.FileStorageManager;
+import cn.cloudwalk.intelligent.lock.annotation.RequiredLock;
+import cn.cloudwalk.service.ninca.visitor.common.AbstractCloudwalkService;
+import com.github.pagehelper.PageInfo;
+import com.google.common.collect.Lists;
+import java.io.ByteArrayOutputStream;
+import java.io.OutputStream;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+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.poi.hssf.usermodel.HSSFCell;
+import org.apache.poi.hssf.usermodel.HSSFClientAnchor;
+import org.apache.poi.hssf.usermodel.HSSFPatriarch;
+import org.apache.poi.hssf.usermodel.HSSFRow;
+import org.apache.poi.hssf.usermodel.HSSFSheet;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
+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 VisitorAbstractExportAsyncService<T, R>
+extends AbstractCloudwalkService {
+    protected static final Logger LOGGER = LoggerFactory.getLogger(VisitorAbstractExportAsyncService.class);
+    private static final Integer FILE_PART_BATCH_SIZE = 0x500001;
+    @Value(value="${cloudwalk.visitor-management.export-max-record:1000}")
+    private long EXPORT_MAX_RECORD;
+    @Autowired
+    private VisitorParallelismDownloadManager visitorParallelismDownloadManager;
+    @Autowired
+    private FileStorageService fileStorageService;
+    @Autowired
+    private VisitorDownloadCenterService visitorDownloadCenterService;
+    @Resource
+    private RedisTemplate<String, Object> redisTemplate;
+    @Autowired
+    private FileStorageManager fileStorageManager;
+
+    @RequiredLock(name="T(cn.cloudwalk.common.ninca.visitor.config.VisitorLockConstants).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 = "vistiorManagementExportCache:#" + context.getCompany().getCompanyId();
+        try {
+            String taskId = (String)this.redisTemplate.opsForValue().get((Object)cacheKey);
+            if (StringUtils.isNotBlank((String)taskId)) {
+                return CloudwalkResult.fail((String)"76251998", (String)"\u76ee\u524d\u5df2\u6709\u4e00\u4e2a\u6b63\u5728\u6267\u884c\u7684\u5bfc\u51fa\u4efb\u52a1\uff0c\u8bf7\u7a0d\u540e\u518d\u8bd5");
+            }
+            String exportFileName = StringUtils.isNotBlank((String)fileName) ? fileName : this.getDefaultFileName();
+            ExportRecordContext.Builder builder = new ExportRecordContext.Builder();
+            ExportRecordContext exportRecordContext = builder.withFileName(exportFileName).withTaskStatus(VisitorFileStatusEnum.PRODUCING.getCode()).build();
+            ((CompletableFuture)CompletableFuture.runAsync(() -> {
+                try {
+                    String fileId = this.visitorDownloadCenterService.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, exportRecordContext, null, context);
+                }
+                catch (Exception e) {
+                    ServiceException serviceException = (ServiceException)e.getCause();
+                    LOGGER.info("\u5bfc\u51fa\u65f6\u5f02\u5e38\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+                    VisitorFileFinishParam fileFinishParam = new VisitorFileFinishParam();
+                    fileFinishParam.setFileId(exportRecordContext.getFileId());
+                    fileFinishParam.setErrorCode("76251999");
+                    fileFinishParam.setFileStatus(VisitorFileStatusEnum.FAIL.getCode());
+                    fileFinishParam.setErrorMessage(serviceException.getMessage());
+                    this.visitorDownloadCenterService.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);
+                    VisitorFileFinishParam fileFinishParam = new VisitorFileFinishParam();
+                    fileFinishParam.setFileId(exportRecordContext.getFileId());
+                    fileFinishParam.setErrorCode(serviceException.getCode());
+                    fileFinishParam.setErrorMessage(serviceException.getMessage());
+                    fileFinishParam.setFileStatus(VisitorFileStatusEnum.FAIL.getCode());
+                    this.visitorDownloadCenterService.finishDownload(fileFinishParam, context);
+                } else if (VisitorFileStatusEnum.CANCELED.getCode().intValue() != exportRecordContext.getTaskStatus()) {
+                    LOGGER.info("\u5f02\u6b65\u5bfc\u51fa\u6210\u529f\u3002[{}]", (Object)exportRecordContext.toString());
+                    VisitorFileFinishParam fileFinishParam = new VisitorFileFinishParam();
+                    fileFinishParam.setFileId(exportRecordContext.getFileId());
+                    fileFinishParam.setFilePath(exportRecordContext.getFilePath());
+                    fileFinishParam.setFileSize(exportRecordContext.getFileSize());
+                    fileFinishParam.setFileStatus(VisitorFileStatusEnum.FINISH.getCode());
+                    this.visitorDownloadCenterService.finishDownload(fileFinishParam, context);
+                } else if (cn.cloudwalk.common.ninca.accesscontrol.util.StringUtils.isNotBlank((String)exportRecordContext.getFilePath())) {
+                    FileRemoveDTO fileRemoveDTO = new FileRemoveDTO();
+                    fileRemoveDTO.setFileList((List)Lists.newArrayList((Object[])new String[]{exportRecordContext.getFilePath()}));
+                    try {
+                        this.fileStorageManager.remove(fileRemoveDTO);
+                    }
+                    catch (DavinciServiceException e1) {
+                        this.logger.error("\u5220\u9664\u6587\u4ef6\u5931\u8d25\uff0cfileId=[{}]\uff0c\u539f\u56e0\uff1a", (Object)exportRecordContext.getFileId(), (Object)e1);
+                    }
+                }
+            });
+            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, ExportRecordContext exportRecordContext, ExcelCallback callback, CloudwalkCallContext context) throws Exception {
+        ByteArrayOutputStream output = new ByteArrayOutputStream();
+        String sheetName = exportRecordContext.getFileName();
+        VisitorFeignThreadLocalUtil.setRequestHeader((CloudwalkCallContext)context);
+        int startPage = 1;
+        int pageSize = 100;
+        long maxPageSize = this.EXPORT_MAX_RECORD / 100L;
+        PageInfo pageInfo = new PageInfo();
+        ArrayList<Object> list = this.getList(param, context, startPage, 100, pageInfo);
+        Long totalRows = pageInfo.getTotal();
+        Long totalPages = pageInfo.getPages();
+        try (HSSFWorkbook workbook = new HSSFWorkbook();){
+            int sheetSize = 65536;
+            Field[] allFields = clazz.getDeclaredFields();
+            ArrayList<Field> fields = new ArrayList<Field>();
+            for (Field field : allFields) {
+                ExcelAttribute attr = field.getAnnotation(ExcelAttribute.class);
+                if (attr == null || !attr.isExport()) continue;
+                fields.add(field);
+            }
+            long listSize = this.EXPORT_MAX_RECORD < totalRows ? this.EXPORT_MAX_RECORD : totalRows;
+            int startRow = 0;
+            int sheetNo = (int)listSize / sheetSize;
+            block15: for (int index = 0; index <= sheetNo; ++index) {
+                HSSFSheet sheet = workbook.createSheet();
+                workbook.setSheetName(index, sheetName + index);
+                ExcelUtil.createRowHeard((HSSFSheet)sheet, fields, (HSSFWorkbook)workbook, (int)startRow);
+                int startNo = (startPage - 1) * 100;
+                while (true) {
+                    if (this.isCancelDownload(exportRecordContext, context)) {
+                        output.close();
+                        return;
+                    }
+                    if (CollectionUtils.isEmpty(list)) {
+                        list = this.getList(param, context, startPage, 100, pageInfo);
+                    }
+                    this.visitorParallelismDownloadManager.parallelResolve(list, clazz);
+                    int endNo = startNo + list.size();
+                    this.createRowContent(sheet, fields, workbook, list, startNo, endNo, startRow + 1);
+                    if (null != callback) {
+                        callback.call(workbook, sheet);
+                    }
+                    if ((long)(++startPage) > totalPages || (long)startPage > maxPageSize) continue block15;
+                    startNo = endNo;
+                    list = new ArrayList();
+                }
+            }
+            output.flush();
+            workbook.write((OutputStream)output);
+            output.close();
+            byte[] fileByte = output.toByteArray();
+            exportRecordContext.setFileSize(Long.valueOf(fileByte.length));
+            String filePath = this.fileStore(exportRecordContext.getFileName() + ".xls", fileByte, exportRecordContext, context);
+            exportRecordContext.setFilePath(filePath);
+        }
+        catch (Exception e) {
+            this.logger.error("\u5c06list\u6570\u636e\u6e90\u7684\u6570\u636e\u5bfc\u5165\u5230excel\u8868\u5355\u5f02\u5e38", (Throwable)e);
+            throw new Exception("\u5c06list\u6570\u636e\u6e90\u7684\u6570\u636e\u5bfc\u5165\u5230excel\u8868\u5355\u5f02\u5e38!", e);
+        }
+    }
+
+    private boolean isCancelDownload(ExportRecordContext exportRecordContext, CloudwalkCallContext context) {
+        int taskStatus = this.visitorDownloadCenterService.queryDownloadStatus(exportRecordContext.getFileId(), context);
+        if (AcsFileStatusEnum.CANCELED.getCode() == taskStatus) {
+            this.logger.info("\u5bfc\u51fa\u4efb\u52a1\u5df2\u53d6\u6d88\uff0cfileID=[{}]", (Object)exportRecordContext.getFileId());
+            exportRecordContext.setTaskStatus(taskStatus);
+            return true;
+        }
+        return false;
+    }
+
+    private ArrayList<R> getList(T param, CloudwalkCallContext context, int startPage, int pageSize, PageInfo pageInfo) throws ServiceException {
+        CloudwalkPageInfo cloudwalkPageInfo = new CloudwalkPageInfo(startPage, pageSize);
+        CloudwalkPageAble<R> dataPage = this.queryPage(param, cloudwalkPageInfo, context);
+        pageInfo.setTotal(dataPage.getTotalRows());
+        pageInfo.setPages((int)dataPage.getTotalPages());
+        return Lists.newArrayList((Iterable)dataPage.getDatas());
+    }
+
+    private String fileStore(String fileName, byte[] bytes, ExportRecordContext exportRecordContext, CloudwalkCallContext context) 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.fileStorageService.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;
+                if (this.isCancelDownload(exportRecordContext, context)) {
+                    return ((FilePartResult)result.getData()).getFilePath();
+                }
+                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.fileStorageService.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.fileStorageService.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 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;
+    }
+
+    private <T> void createRowContent(HSSFSheet sheet, List<Field> fields, HSSFWorkbook workbook, List<T> list, int startNo, int endNo, int rowIndex) throws Exception {
+        String value = null;
+        int hwPicType = 0;
+        byte[] picByte = null;
+        int listIndex = 0;
+        for (int i = startNo; i < endNo; ++i) {
+            HSSFRow row = sheet.createRow(i + 1);
+            T vo = list.get(listIndex);
+            ++listIndex;
+            for (int j = 0; j < fields.size(); ++j) {
+                Field field = fields.get(j);
+                field.setAccessible(true);
+                ExcelAttribute attr = field.getAnnotation(ExcelAttribute.class);
+                int col = j;
+                if (StringUtils.isNotBlank((String)attr.column())) {
+                    col = ExcelUtil.getExcelCol((String)attr.column());
+                }
+                if (!attr.isExport()) continue;
+                HSSFCell cell = row.createCell(col);
+                Class<?> classType = field.getType();
+                if (field.get(vo) == null) continue;
+                value = null;
+                if (classType.isAssignableFrom(Date.class)) {
+                    value = DateUtils.formatDate((Date)((Date)field.get(vo)), (String)"yyyy-MM-dd HH:mm:ss");
+                }
+                if (classType.isAssignableFrom(Long.class) && attr.isDate()) {
+                    value = DateUtils.formatDate((Date)new Date((Long)field.get(vo)), (String)"yyyy-MM-dd HH:mm:ss");
+                }
+                if (attr.isPic()) {
+                    try {
+                        if (field.getType().equals(String.class)) {
+                            picByte = ExcelUtil.getBytesByUrl((String)((String)field.get(vo)));
+                        }
+                        picByte = (byte[])field.get(vo);
+                    }
+                    catch (Exception exception) {
+                        // empty catch block
+                    }
+                    hwPicType = 5;
+                    HSSFPatriarch patriarch = sheet.createDrawingPatriarch();
+                    HSSFClientAnchor anchor = new HSSFClientAnchor(0, 0, 1020, 250, (short)col, row.getRowNum(), (short)col, row.getRowNum());
+                    patriarch.createPicture(anchor, workbook.addPicture(picByte, hwPicType));
+                    row.setHeight((short)1000);
+                    continue;
+                }
+                cell.setCellValue(field.get(vo) == null ? "" : (value == null ? String.valueOf(field.get(vo)) : value));
+            }
+        }
+    }
+
+    public CloudwalkResult<Long> exportMaxRecord() throws ServiceException {
+        try {
+            return CloudwalkResult.success((Object)this.EXPORT_MAX_RECORD);
+        }
+        catch (Exception e) {
+            this.logger.error("\u83b7\u53d6\u6700\u5927\u5bfc\u51fa\u8bb0\u5f55\u5931\u8d25", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    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-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/export/VisitorExportAsyncService.java

@@ -0,0 +1,59 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorComplexQueryParam
+ *  cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorResultExcel
+ *  cn.cloudwalk.client.ninca.visitor.visitor.service.VisitorService
+ *  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.visitor.util.DateUtils
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.visitor.export;
+
+import cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorComplexQueryParam;
+import cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorResultExcel;
+import cn.cloudwalk.client.ninca.visitor.visitor.service.VisitorService;
+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.visitor.util.DateUtils;
+import cn.cloudwalk.service.ninca.visitor.export.VisitorAbstractExportAsyncService;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class VisitorExportAsyncService
+extends VisitorAbstractExportAsyncService<VisitorComplexQueryParam, VisitorResultExcel> {
+    private static final String DEFAULT_EXPORT_FILE_NAME = "\u8bbf\u5ba2\u4eba\u5458";
+    @Autowired
+    private VisitorService visitorService;
+
+    @Override
+    protected CloudwalkPageAble<VisitorResultExcel> queryPage(VisitorComplexQueryParam param, CloudwalkPageInfo pageInfo, CloudwalkCallContext context) throws ServiceException {
+        CloudwalkResult result = this.visitorService.page(param, pageInfo, context);
+        if (result.isSuccess()) {
+            List resultList = BeanCopyUtils.copy((Collection)((CloudwalkPageAble)result.getData()).getDatas(), VisitorResultExcel.class);
+            return new CloudwalkPageAble((Collection)resultList, 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");
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/export/VisitorRecordExportAsyncService.java

@@ -0,0 +1,76 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.ninca.visitor.visitor.VisitorManager
+ *  cn.cloudwalk.client.ninca.visitor.record.param.VisitorRecordPageParam
+ *  cn.cloudwalk.client.ninca.visitor.record.result.VisitorRecordResult
+ *  cn.cloudwalk.client.ninca.visitor.record.result.VisitorRecordResultExcel
+ *  cn.cloudwalk.client.ninca.visitor.record.service.VisitorRecordService
+ *  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.visitor.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.visitor.util.DateUtils
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.visitor.export;
+
+import cn.cloudwalk.biz.ninca.visitor.visitor.VisitorManager;
+import cn.cloudwalk.client.ninca.visitor.record.param.VisitorRecordPageParam;
+import cn.cloudwalk.client.ninca.visitor.record.result.VisitorRecordResult;
+import cn.cloudwalk.client.ninca.visitor.record.result.VisitorRecordResultExcel;
+import cn.cloudwalk.client.ninca.visitor.record.service.VisitorRecordService;
+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.visitor.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.visitor.util.DateUtils;
+import cn.cloudwalk.service.ninca.visitor.export.VisitorAbstractExportAsyncService;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class VisitorRecordExportAsyncService
+extends VisitorAbstractExportAsyncService<VisitorRecordPageParam, VisitorRecordResultExcel> {
+    private static final String DEFAULT_EXPORT_FILE_NAME = "\u8bbf\u5ba2\u5230\u8bbf\u8bb0\u5f55";
+    @Autowired
+    private VisitorRecordService visitorRecordService;
+    @Autowired
+    private VisitorManager visitorManager;
+
+    @Override
+    protected CloudwalkPageAble<VisitorRecordResultExcel> queryPage(VisitorRecordPageParam param, CloudwalkPageInfo pageInfo, CloudwalkCallContext context) throws ServiceException {
+        List visitorRecordResultList;
+        ArrayList<VisitorRecordResultExcel> resultList = new ArrayList<VisitorRecordResultExcel>();
+        CloudwalkResult visitorRecordResult = this.visitorRecordService.page(param, pageInfo, context);
+        if (visitorRecordResult.isSuccess() && CollectionUtils.isNotEmpty((Collection)(visitorRecordResultList = (List)((CloudwalkPageAble)visitorRecordResult.getData()).getDatas()))) {
+            for (VisitorRecordResult visitorRecord : ((CloudwalkPageAble)visitorRecordResult.getData()).getDatas()) {
+                VisitorRecordResultExcel visitorRecordResultExcel = new VisitorRecordResultExcel();
+                visitorRecordResultExcel.setSignTime(visitorRecord.getSignTime());
+                visitorRecordResultExcel.setDeviceAreaName(visitorRecord.getDeviceDistrictMergeName() + "-" + visitorRecord.getDeviceAreaName());
+                visitorRecordResultExcel.setDeviceName(visitorRecord.getDeviceName());
+                visitorRecordResultExcel.setVisitorName(visitorRecord.getVisitorName());
+                visitorRecordResultExcel.setSpotImgPath(visitorRecord.getSpotImgPath());
+                visitorRecordResultExcel.setRegisterImagePath(visitorRecord.getFacePath());
+                resultList.add(visitorRecordResultExcel);
+            }
+        }
+        return new CloudwalkPageAble(resultList, pageInfo, ((CloudwalkPageAble)visitorRecordResult.getData()).getTotalRows());
+    }
+
+    @Override
+    protected String getDefaultFileName() {
+        return DEFAULT_EXPORT_FILE_NAME + DateUtils.formatDate((Date)new Date(), (String)"yyyyMMddHHmmss");
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/importrecord/ImportRecordServiceImpl.java

@@ -0,0 +1,137 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.ninca.visitor.importrecord.ImportManager
+ *  cn.cloudwalk.biz.ninca.visitor.importrecord.ImportRecordManager
+ *  cn.cloudwalk.client.ninca.visitor.importrecord.param.ImportExportQueryParam
+ *  cn.cloudwalk.client.ninca.visitor.importrecord.param.ImportNewParam
+ *  cn.cloudwalk.client.ninca.visitor.importrecord.param.ImportQueryParam
+ *  cn.cloudwalk.client.ninca.visitor.importrecord.param.ImportRecordParam
+ *  cn.cloudwalk.client.ninca.visitor.importrecord.result.ImportRecordExcelResult
+ *  cn.cloudwalk.client.ninca.visitor.importrecord.result.ImportResult
+ *  cn.cloudwalk.client.ninca.visitor.importrecord.serivce.ImportRecordService
+ *  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.visitor.bean.importrecord.dto.ImportDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.importrecord.dto.ImportQueryDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.importrecord.dto.ImportRecordDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.importrecord.dto.ImportRecordQueryDTO
+ *  cn.cloudwalk.common.ninca.visitor.em.PersonRoleEnum
+ *  cn.cloudwalk.common.ninca.visitor.util.CollectionUtils
+ *  com.alibaba.fastjson.JSONObject
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Service
+ *  org.springframework.transaction.annotation.Propagation
+ *  org.springframework.transaction.annotation.Transactional
+ */
+package cn.cloudwalk.service.ninca.visitor.importrecord;
+
+import cn.cloudwalk.biz.ninca.visitor.importrecord.ImportManager;
+import cn.cloudwalk.biz.ninca.visitor.importrecord.ImportRecordManager;
+import cn.cloudwalk.client.ninca.visitor.importrecord.param.ImportExportQueryParam;
+import cn.cloudwalk.client.ninca.visitor.importrecord.param.ImportNewParam;
+import cn.cloudwalk.client.ninca.visitor.importrecord.param.ImportQueryParam;
+import cn.cloudwalk.client.ninca.visitor.importrecord.param.ImportRecordParam;
+import cn.cloudwalk.client.ninca.visitor.importrecord.result.ImportRecordExcelResult;
+import cn.cloudwalk.client.ninca.visitor.importrecord.result.ImportResult;
+import cn.cloudwalk.client.ninca.visitor.importrecord.serivce.ImportRecordService;
+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.visitor.bean.importrecord.dto.ImportDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.importrecord.dto.ImportQueryDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.importrecord.dto.ImportRecordDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.importrecord.dto.ImportRecordQueryDTO;
+import cn.cloudwalk.common.ninca.visitor.em.PersonRoleEnum;
+import cn.cloudwalk.common.ninca.visitor.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.visitor.common.AbstractCloudwalkService;
+import com.alibaba.fastjson.JSONObject;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class ImportRecordServiceImpl
+extends AbstractCloudwalkService
+implements ImportRecordService {
+    @Autowired
+    private ImportManager importManager;
+    @Autowired
+    private ImportRecordManager importRecordManager;
+
+    @CloudwalkParamsValidate(argsIndexs={0, 1})
+    @Transactional(propagation=Propagation.REQUIRED, rollbackFor={Exception.class})
+    public CloudwalkResult<Boolean> add(ImportNewParam param, CloudwalkCallContext context) throws ServiceException, DataAccessException {
+        ImportDTO dto = new ImportDTO();
+        BeanCopyUtils.copyProperties((Object)param, (CloudwalkCallContext)context, (Object)dto);
+        dto.setBusinessId(context.getCompany().getCompanyId());
+        dto.setId(this.genUUID());
+        dto.setCreateUserName(context.getUser().getCallerName());
+        this.importManager.add(dto);
+        ArrayList<ImportRecordDTO> importRecordList = new ArrayList<ImportRecordDTO>();
+        List importRecordParams = param.getImportRecords();
+        if (CollectionUtils.isNotEmpty((Collection)importRecordParams)) {
+            for (ImportRecordParam recordParam : importRecordParams) {
+                ImportRecordDTO recordDTO = new ImportRecordDTO();
+                BeanCopyUtils.copyProperties((Object)recordParam, (CloudwalkCallContext)context, (Object)recordDTO);
+                recordDTO.setId(this.genUUID());
+                recordDTO.setImportId(dto.getId());
+                importRecordList.add(recordDTO);
+            }
+            this.importRecordManager.batchInsert(importRecordList);
+        }
+        return CloudwalkResult.success((Object)true);
+    }
+
+    public CloudwalkResult<CloudwalkPageAble<ImportResult>> page(ImportQueryParam param, CloudwalkPageInfo page, CloudwalkCallContext context) throws ServiceException {
+        this.logger.info("\u5206\u9875\u67e5\u8be2\u5bfc\u5165\u65e5\u5fd7\u4fe1\u606f\u5165\u53c2\uff1a{}", (Object)JSONObject.toJSONString((Object)param));
+        ImportQueryDTO dto = (ImportQueryDTO)BeanCopyUtils.copyProperties((Object)param, ImportQueryDTO.class);
+        dto.setBusinessId(context.getCompany().getCompanyId());
+        if (!super.validCurrentUserRole(context, PersonRoleEnum.CORP_ADMIN, PersonRoleEnum.BUSINESS_ADMIN)) {
+            dto.setCreateUserId(context.getUser().getCaller());
+        }
+        CloudwalkPageAble cloudwalkResult = null;
+        try {
+            cloudwalkResult = this.importManager.page(dto, page);
+            List results = BeanCopyUtils.copy((Collection)cloudwalkResult.getDatas(), ImportResult.class);
+            return CloudwalkResult.success((Object)new CloudwalkPageAble((Collection)results, page, cloudwalkResult.getTotalRows()));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u5206\u9875\u67e5\u8be2\u5bfc\u5165\u65e5\u5fd7\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public List<ImportRecordExcelResult> export(ImportExportQueryParam param, CloudwalkCallContext context) throws ServiceException {
+        ImportRecordQueryDTO dto = (ImportRecordQueryDTO)BeanCopyUtils.copyProperties((Object)param, ImportRecordQueryDTO.class);
+        dto.setImportId(param.getId());
+        dto.setBusinessId(context.getCompany().getCompanyId());
+        List importRecordList = null;
+        try {
+            importRecordList = this.importRecordManager.gets(dto);
+            List results = BeanCopyUtils.copy((Collection)importRecordList, ImportRecordExcelResult.class);
+            return results;
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u5bfc\u51fa\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/message/SmsServiceImpl.java

@@ -0,0 +1,46 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.visitor.message.param.GetShortUrlParam
+ *  cn.cloudwalk.client.ninca.visitor.message.param.SmsSendParam
+ *  cn.cloudwalk.client.ninca.visitor.message.result.ShotUrlResult
+ *  cn.cloudwalk.client.ninca.visitor.message.service.SmsService
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  com.alibaba.fastjson.JSONObject
+ *  javax.annotation.Resource
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.visitor.message;
+
+import cn.cloudwalk.client.ninca.visitor.message.param.GetShortUrlParam;
+import cn.cloudwalk.client.ninca.visitor.message.param.SmsSendParam;
+import cn.cloudwalk.client.ninca.visitor.message.result.ShotUrlResult;
+import cn.cloudwalk.client.ninca.visitor.message.service.SmsService;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.service.ninca.visitor.message.feign.SmsFeign;
+import com.alibaba.fastjson.JSONObject;
+import javax.annotation.Resource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+
+@Service
+public class SmsServiceImpl
+implements SmsService {
+    protected final Logger logger = LoggerFactory.getLogger(this.getClass());
+    @Resource
+    private SmsFeign smsFeign;
+
+    public CloudwalkResult<Boolean> send(SmsSendParam param) {
+        this.logger.info("\u5f00\u59cb\u53d1\u9001\u77ed\u4fe1,\u77ed\u4fe1\u53c2\u6570\uff1a{}", (Object)JSONObject.toJSONString((Object)param));
+        return this.smsFeign.send(param);
+    }
+
+    public CloudwalkResult<ShotUrlResult> getShortUrl(GetShortUrlParam param) {
+        return this.smsFeign.getShortUrl(param);
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/message/feign/SmsFeign.java

@@ -0,0 +1,33 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.visitor.message.param.GetShortUrlParam
+ *  cn.cloudwalk.client.ninca.visitor.message.param.SmsSendParam
+ *  cn.cloudwalk.client.ninca.visitor.message.result.ShotUrlResult
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  org.springframework.cloud.netflix.feign.FeignClient
+ *  org.springframework.web.bind.annotation.RequestBody
+ *  org.springframework.web.bind.annotation.RequestMapping
+ *  org.springframework.web.bind.annotation.RequestMethod
+ */
+package cn.cloudwalk.service.ninca.visitor.message.feign;
+
+import cn.cloudwalk.client.ninca.visitor.message.param.GetShortUrlParam;
+import cn.cloudwalk.client.ninca.visitor.message.param.SmsSendParam;
+import cn.cloudwalk.client.ninca.visitor.message.result.ShotUrlResult;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import org.springframework.cloud.netflix.feign.FeignClient;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+
+@FeignClient(name="${feign.portal.name:davinci-portal}", path="/portal/message")
+public interface SmsFeign {
+    @RequestMapping(value={"/send"}, method={RequestMethod.POST})
+    public CloudwalkResult<Boolean> send(@RequestBody SmsSendParam var1);
+
+    @RequestMapping(value={"/getShortUrl"}, method={RequestMethod.POST})
+    public CloudwalkResult<ShotUrlResult> getShortUrl(@RequestBody GetShortUrlParam var1);
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/photo/PhotoServiceImpl.java

@@ -0,0 +1,76 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.visitor.photo.param.PhotoAddParam
+ *  cn.cloudwalk.client.ninca.visitor.photo.param.PhotoDelParam
+ *  cn.cloudwalk.client.ninca.visitor.photo.service.PhotoService
+ *  cn.cloudwalk.cloud.annotation.CloudwalkParamsValidate
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  javax.annotation.Resource
+ *  org.apache.commons.codec.binary.Base64
+ *  org.apache.commons.io.FilenameUtils
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Service
+ *  org.springframework.transaction.annotation.Propagation
+ *  org.springframework.transaction.annotation.Transactional
+ */
+package cn.cloudwalk.service.ninca.visitor.photo;
+
+import cn.cloudwalk.client.ninca.visitor.photo.param.PhotoAddParam;
+import cn.cloudwalk.client.ninca.visitor.photo.param.PhotoDelParam;
+import cn.cloudwalk.client.ninca.visitor.photo.service.PhotoService;
+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.service.ninca.visitor.common.AbstractCloudwalkService;
+import cn.cloudwalk.service.ninca.visitor.common.thumbnail.VisitorThumbnailFaceProperties;
+import cn.cloudwalk.service.ninca.visitor.storage.FileStorageServiceImpl;
+import java.io.IOException;
+import java.util.List;
+import javax.annotation.Resource;
+import org.apache.commons.codec.binary.Base64;
+import org.apache.commons.io.FilenameUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class PhotoServiceImpl
+extends AbstractCloudwalkService
+implements PhotoService {
+    @Resource
+    private FileStorageServiceImpl fileStorageService;
+    @Autowired
+    private VisitorThumbnailFaceProperties visitorThumbnailFaceProperties;
+
+    @Transactional(propagation=Propagation.REQUIRED, rollbackFor={Exception.class})
+    @CloudwalkParamsValidate
+    public CloudwalkResult<String> add(PhotoAddParam param, CloudwalkCallContext context) throws ServiceException {
+        String extensionName = FilenameUtils.getExtension((String)param.getFileName());
+        if (!this.visitorThumbnailFaceProperties.getTypes().contains(extensionName)) {
+            return CloudwalkResult.fail((String)"762508027", (String)this.getMessage("762508027"));
+        }
+        byte[] bytes = Base64.decodeBase64((String)param.getImg());
+        if (param.isResize()) {
+            try {
+                bytes = super.resize(bytes);
+            }
+            catch (IOException e) {
+                this.logger.error("\u65b0\u589e\u7167\u7247\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+                return CloudwalkResult.fail((String)"762508027", (String)this.getMessage("762508027"));
+            }
+        }
+        return this.fileStorageService.fileUpload(param.getFileName(), bytes);
+    }
+
+    @CloudwalkParamsValidate
+    public CloudwalkResult<List<String>> delete(PhotoDelParam param, CloudwalkCallContext context) throws ServiceException {
+        return this.fileStorageService.delete(param);
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/record/ProtocolCaptureServiceImpl.java

@@ -0,0 +1,251 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.ninca.visitor.deivce.DeviceImageStoreManager
+ *  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.ninca.accesscontrol.setting.param.AcsDeviceAttrQueryParam
+ *  cn.cloudwalk.client.ninca.accesscontrol.setting.result.AcsDeviceSettingResult
+ *  cn.cloudwalk.client.ninca.accesscontrol.setting.service.AcsDeviceAttrService
+ *  cn.cloudwalk.client.ninca.visitor.record.param.VisitorRecordNewParam
+ *  cn.cloudwalk.client.ninca.visitor.record.service.ProtocolCaptureService
+ *  cn.cloudwalk.client.ninca.visitor.record.service.VisitorRecordService
+ *  cn.cloudwalk.client.ninca.visitor.storage.service.FileStorageService
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorGetsParam
+ *  cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorResult
+ *  cn.cloudwalk.client.ninca.visitor.visitor.service.VisitorService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.session.extend.DefaultExtendContext
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreQueryDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreResultDTO
+ *  cn.cloudwalk.common.ninca.visitor.config.VisitorDeviceConstants
+ *  cn.cloudwalk.common.ninca.visitor.device.DeviceContext
+ *  cn.cloudwalk.common.ninca.visitor.em.YesNoTypeEnum
+ *  cn.cloudwalk.common.ninca.visitor.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.visitor.util.DateUtil
+ *  cn.cloudwalk.cwos.client.event.event.BaseEvent
+ *  cn.cloudwalk.cwos.client.event.event.FaceCaptureEvent
+ *  cn.cloudwalk.cwos.client.event.event.app.OpendoorFaceCaptureRecordEvent
+ *  cn.cloudwalk.cwos.client.event.event.enums.OpenDoorTypeEnum
+ *  cn.cloudwalk.cwos.client.event.event.mode.FaceCapture
+ *  cn.cloudwalk.event.CloudwalkEventManager
+ *  com.alibaba.fastjson.JSONObject
+ *  com.google.common.collect.Lists
+ *  javax.annotation.Resource
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.visitor.record;
+
+import cn.cloudwalk.biz.ninca.visitor.deivce.DeviceImageStoreManager;
+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.ninca.accesscontrol.setting.param.AcsDeviceAttrQueryParam;
+import cn.cloudwalk.client.ninca.accesscontrol.setting.result.AcsDeviceSettingResult;
+import cn.cloudwalk.client.ninca.accesscontrol.setting.service.AcsDeviceAttrService;
+import cn.cloudwalk.client.ninca.visitor.record.param.VisitorRecordNewParam;
+import cn.cloudwalk.client.ninca.visitor.record.service.ProtocolCaptureService;
+import cn.cloudwalk.client.ninca.visitor.record.service.VisitorRecordService;
+import cn.cloudwalk.client.ninca.visitor.storage.service.FileStorageService;
+import cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorGetsParam;
+import cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorResult;
+import cn.cloudwalk.client.ninca.visitor.visitor.service.VisitorService;
+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.session.extend.DefaultExtendContext;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreQueryDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreResultDTO;
+import cn.cloudwalk.common.ninca.visitor.config.VisitorDeviceConstants;
+import cn.cloudwalk.common.ninca.visitor.device.DeviceContext;
+import cn.cloudwalk.common.ninca.visitor.em.YesNoTypeEnum;
+import cn.cloudwalk.common.ninca.visitor.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.visitor.util.DateUtil;
+import cn.cloudwalk.cwos.client.event.event.BaseEvent;
+import cn.cloudwalk.cwos.client.event.event.FaceCaptureEvent;
+import cn.cloudwalk.cwos.client.event.event.app.OpendoorFaceCaptureRecordEvent;
+import cn.cloudwalk.cwos.client.event.event.enums.OpenDoorTypeEnum;
+import cn.cloudwalk.cwos.client.event.event.mode.FaceCapture;
+import cn.cloudwalk.event.CloudwalkEventManager;
+import cn.cloudwalk.service.ninca.visitor.common.AbstractProtocolApplicationService;
+import cn.cloudwalk.service.ninca.visitor.common.VisitorCommonConfigProperties;
+import com.alibaba.fastjson.JSONObject;
+import com.google.common.collect.Lists;
+import java.math.BigDecimal;
+import java.util.List;
+import javax.annotation.Resource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class ProtocolCaptureServiceImpl
+extends AbstractProtocolApplicationService
+implements ProtocolCaptureService {
+    private final Logger logger = LoggerFactory.getLogger(this.getClass());
+    @Autowired
+    private FileStorageService fileStorageService;
+    @Autowired
+    private BiologyToolService biologyToolService;
+    @Autowired
+    private VisitorService visitorService;
+    @Autowired
+    private VisitorRecordService visitorRecordService;
+    @Resource
+    private DeviceImageStoreManager deviceImageStoreManager;
+    @Resource
+    private CloudwalkEventManager cloudwalkEventManager;
+    @Autowired
+    private VisitorCommonConfigProperties visitorAppConfigProperties;
+    private static final String ACS_FACE_REG_THRESHOLD_CODE = "ACS_FACE_REG_THRESHOLD";
+
+    public void upload(FaceCaptureEvent param, CloudwalkCallContext context) throws ServiceException {
+        for (FaceCapture face : param.getFace()) {
+            String imageStoreId = this.getImageStoreId(context);
+            List<FeatureQueryResult> featureQueryResultList = this.compareEngine(face.getImagePath(), imageStoreId, context);
+            this.compareVisitor(param, face, featureQueryResultList, imageStoreId, context);
+        }
+    }
+
+    private String getImageStoreId(CloudwalkCallContext context) throws ServiceException {
+        DeviceContext deviceContext = this.getDeviceContext(context);
+        DeviceImageStoreQueryDTO deviceImageStoreQueryDTO = new DeviceImageStoreQueryDTO();
+        deviceImageStoreQueryDTO.setDeviceId(deviceContext.getDeviceId());
+        deviceImageStoreQueryDTO.setBusinessId(context.getCompany().getCompanyId());
+        try {
+            DeviceImageStoreResultDTO resultDTO = this.deviceImageStoreManager.queryByDeviceId(deviceImageStoreQueryDTO);
+            if (resultDTO == null) {
+                this.logger.info("\u8bbe\u5907\u8bbf\u5ba2\u56fe\u5e93\u4e0d\u5b58\u5728\uff0c\u8bbe\u5907id:{},\u8bbe\u5907\u7f16\u53f7", (Object)deviceContext.getDeviceId(), (Object)deviceContext.getDeviceCode());
+                throw new ServiceException("\u8bbe\u5907\u8bbf\u5ba2\u56fe\u5e93\u4e0d\u5b58\u5728");
+            }
+            return resultDTO.getImageStoreId();
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u67e5\u8be2\u56fe\u5e93\u5931\u8d25\uff0c\u539f\u56e0:{}", (Object)e.getMessage());
+            throw new ServiceException(e.getMessage());
+        }
+    }
+
+    private List<FeatureQueryResult> compareEngine(String faceImagePath, String imageStoreId, CloudwalkCallContext context) throws ServiceException {
+        CloudwalkResult faceImageResult = this.fileStorageService.getFileBase64(faceImagePath);
+        if (faceImageResult.isSuccess()) {
+            String faceImage = (String)faceImageResult.getData();
+            FeatureQueryParam featureQueryParam = new FeatureQueryParam();
+            featureQueryParam.setImageBase64(faceImage);
+            featureQueryParam.setTopN(Integer.valueOf(1));
+            featureQueryParam.setImageStoreId(imageStoreId);
+            CloudwalkResult captureCompareResult = this.biologyToolService.query(featureQueryParam, context);
+            if (captureCompareResult.isSuccess()) {
+                return (List)captureCompareResult.getData();
+            }
+            throw new ServiceException(captureCompareResult.getCode(), captureCompareResult.getMessage());
+        }
+        throw new ServiceException(faceImageResult.getCode(), faceImageResult.getMessage());
+    }
+
+    private void compareVisitor(FaceCaptureEvent param, FaceCapture face, List<FeatureQueryResult> featureQueryResultList, String imageStoreId, CloudwalkCallContext context) throws ServiceException {
+        block7: {
+            DeviceContext deviceContext = this.getDeviceContext(context);
+            double threshold = this.getThreshold(deviceContext.getDeviceId(), context);
+            if (CollectionUtils.isNotEmpty(featureQueryResultList)) {
+                FeatureQueryResult compareResultDTO = featureQueryResultList.get(0);
+                Double score = compareResultDTO.getScore() * 100.0;
+                if (score.compareTo(threshold) >= 0) {
+                    String personId = compareResultDTO.getPersonId();
+                    VisitorGetsParam visitorGetsParam = new VisitorGetsParam();
+                    visitorGetsParam.setIds((List)Lists.newArrayList((Object[])new String[]{personId}));
+                    visitorGetsParam.setIsDelete(YesNoTypeEnum.N.getCode());
+                    try {
+                        CloudwalkResult visitorResult = this.visitorService.gets(visitorGetsParam, context);
+                        if (visitorResult != null && visitorResult.isSuccess() && ((List)visitorResult.getData()).size() > 0) {
+                            VisitorResult visitor = (VisitorResult)((List)visitorResult.getData()).get(0);
+                            Long now = DateUtil.getTimeMillis();
+                            if (visitor.getBegVisitorTime() <= now && visitor.getEndVisitorTime() >= now) {
+                                this.saveVisitorRecord(param, face, visitor, score, imageStoreId, compareResultDTO.getImageId(), threshold, context);
+                            }
+                            break block7;
+                        }
+                        this.logger.info("\u6ca1\u6709\u5339\u914d\u7684\u8bbf\u5ba2\u4eba\u5458\u6570\u636e");
+                    }
+                    catch (ServiceException e) {
+                        this.logger.info("\u67e5\u8be2\u8bbf\u5ba2\u5931\u8d25", (Object)e.getMessage());
+                    }
+                } else {
+                    this.logger.info("\u8bc6\u522b\u5206\u4e0d\u8db3,\u8bc6\u522b\u5206:{},\u9608\u503c:{}", (Object)score, (Object)threshold);
+                }
+            }
+        }
+    }
+
+    private DeviceContext getDeviceContext(CloudwalkCallContext context) {
+        return (DeviceContext)((DefaultExtendContext)context.getExt()).getValue();
+    }
+
+    private void saveVisitorRecord(FaceCaptureEvent param, FaceCapture face, VisitorResult visitorResult, double score, String imageStoreId, String imageId, double threshold, CloudwalkCallContext context) throws ServiceException {
+        DeviceContext deviceContext = this.getDeviceContext(context);
+        context.getUser().setCaller(visitorResult.getCreateUserId());
+        VisitorRecordNewParam visitorRecordNewParam = this.buildRecogRecordParamWithDeviceContext(deviceContext);
+        visitorRecordNewParam.setLogId(param.getLogId());
+        visitorRecordNewParam.setVisitorId(visitorResult.getId());
+        visitorRecordNewParam.setVisitorName(visitorResult.getName());
+        visitorRecordNewParam.setReceiverId(visitorResult.getPersonId());
+        visitorRecordNewParam.setReceiverName(visitorResult.getPersonName());
+        visitorRecordNewParam.setBusinessId(context.getCompany().getCompanyId());
+        visitorRecordNewParam.setSpotImgPath(face.getImagePath());
+        visitorRecordNewParam.setFacePath(visitorResult.getRegFaceUrl());
+        visitorRecordNewParam.setScore(BigDecimal.valueOf(score));
+        visitorRecordNewParam.setStatus(VisitorDeviceConstants.DEFAULT_RECOG_STATUS);
+        visitorRecordNewParam.setSignTime(Long.valueOf(face.getCaptureTime()));
+        visitorRecordNewParam.setThreshold(BigDecimal.valueOf(threshold));
+        visitorRecordNewParam.setPanoramaPath(param.getPanorama() != null ? param.getPanorama().getPanoramaImagePath() : null);
+        this.visitorRecordService.add(visitorRecordNewParam, context);
+        OpendoorFaceCaptureRecordEvent opendoorFaceCaptureRecordEvent = new OpendoorFaceCaptureRecordEvent();
+        opendoorFaceCaptureRecordEvent.setLogId(param.getLogId() == null ? this.genUUID() : param.getLogId());
+        opendoorFaceCaptureRecordEvent.setMessageId(String.valueOf(System.currentTimeMillis()));
+        opendoorFaceCaptureRecordEvent.setServiceCode("access-control");
+        opendoorFaceCaptureRecordEvent.setApplicationId(context.getApplicationId());
+        opendoorFaceCaptureRecordEvent.setBusinessId(context.getCompany().getCompanyId());
+        opendoorFaceCaptureRecordEvent.setAppServiceCode("visitor-mgmt");
+        opendoorFaceCaptureRecordEvent.setOpenDoorType(OpenDoorTypeEnum.FACE.getType());
+        opendoorFaceCaptureRecordEvent.setRecognitionTime(Long.valueOf(face.getCaptureTime()));
+        opendoorFaceCaptureRecordEvent.setFaceImagePath(face.getImagePath());
+        if (param.getPanorama() != null) {
+            opendoorFaceCaptureRecordEvent.setPanoramaImagePath(param.getPanorama().getPanoramaImagePath());
+        }
+        opendoorFaceCaptureRecordEvent.setThreshold((float)threshold);
+        opendoorFaceCaptureRecordEvent.setFaceId(imageId);
+        opendoorFaceCaptureRecordEvent.setScore(Float.valueOf((float)score));
+        opendoorFaceCaptureRecordEvent.setQualityScore(face.getFaceQuality() == null ? null : face.getFaceQuality().getQualityScore());
+        opendoorFaceCaptureRecordEvent.setGroupId(imageStoreId);
+        opendoorFaceCaptureRecordEvent.setDeviceId(param.getDeviceId());
+        opendoorFaceCaptureRecordEvent.setDeviceName(param.getDeviceName());
+        this.logger.info("\u5f00\u59cb\u53d1\u9001\u6d88\u606f\u7ed9\u95e8\u7981\u5e94\u7528\uff1a{}", (Object)JSONObject.toJSONString((Object)opendoorFaceCaptureRecordEvent));
+        this.cloudwalkEventManager.publish((BaseEvent)opendoorFaceCaptureRecordEvent);
+        this.logger.info("\u53d1\u9001\u6d88\u606f\u7ed9\u95e8\u7981\u5e94\u7528\u7ed3\u675f");
+    }
+
+    private double getThreshold(String deviceId, CloudwalkCallContext context) {
+        double thredshold = this.visitorAppConfigProperties.getFaceCaptureRecogThreshold();
+        AcsDeviceAttrQueryParam acsDeviceAttrQueryParam = new AcsDeviceAttrQueryParam();
+        acsDeviceAttrQueryParam.setDeviceId(deviceId);
+        return thredshold;
+    }
+
+    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-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/record/ProtocolRecordUploadServiceImpl.java

@@ -0,0 +1,144 @@
+/*
+ * 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.visitor.record.param.VisitorRecordNewParam
+ *  cn.cloudwalk.client.ninca.visitor.record.result.VisitorRecordResultEvent
+ *  cn.cloudwalk.client.ninca.visitor.record.service.ProtocolRecordUploadService
+ *  cn.cloudwalk.client.ninca.visitor.record.service.VisitorRecordService
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorGetsParam
+ *  cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorResult
+ *  cn.cloudwalk.client.ninca.visitor.visitor.service.VisitorService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.session.extend.DefaultExtendContext
+ *  cn.cloudwalk.common.ninca.visitor.config.VisitorDeviceConstants
+ *  cn.cloudwalk.common.ninca.visitor.device.DeviceContext
+ *  cn.cloudwalk.common.ninca.visitor.util.CollectionUtils
+ *  cn.cloudwalk.cwos.client.event.event.PersonRecordUploadEvent
+ *  cn.cloudwalk.cwos.client.event.event.mode.Face
+ *  com.google.common.collect.Lists
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.visitor.record;
+
+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.visitor.record.param.VisitorRecordNewParam;
+import cn.cloudwalk.client.ninca.visitor.record.result.VisitorRecordResultEvent;
+import cn.cloudwalk.client.ninca.visitor.record.service.ProtocolRecordUploadService;
+import cn.cloudwalk.client.ninca.visitor.record.service.VisitorRecordService;
+import cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorGetsParam;
+import cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorResult;
+import cn.cloudwalk.client.ninca.visitor.visitor.service.VisitorService;
+import cn.cloudwalk.cloud.context.CloudwalkCallContext;
+import cn.cloudwalk.cloud.exception.ServiceException;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.session.extend.DefaultExtendContext;
+import cn.cloudwalk.common.ninca.visitor.config.VisitorDeviceConstants;
+import cn.cloudwalk.common.ninca.visitor.device.DeviceContext;
+import cn.cloudwalk.common.ninca.visitor.util.CollectionUtils;
+import cn.cloudwalk.cwos.client.event.event.PersonRecordUploadEvent;
+import cn.cloudwalk.cwos.client.event.event.mode.Face;
+import cn.cloudwalk.service.ninca.visitor.common.AbstractProtocolApplicationService;
+import com.google.common.collect.Lists;
+import java.math.BigDecimal;
+import java.util.Collection;
+import java.util.List;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class ProtocolRecordUploadServiceImpl
+extends AbstractProtocolApplicationService
+implements ProtocolRecordUploadService {
+    @Autowired
+    private VisitorService visitorService;
+    @Autowired
+    private VisitorRecordService visitorRecordService;
+    @Autowired
+    private PersonService personService;
+
+    public CloudwalkResult<Boolean> upload(PersonRecordUploadEvent param, CloudwalkCallContext context) throws ServiceException {
+        List faces = param.getFaces();
+        for (Face face : faces) {
+            if (face.getRecognitionResult() != 1) continue;
+            this.saveRecogRecord(param, face, context);
+        }
+        return CloudwalkResult.success((Object)true);
+    }
+
+    public CloudwalkResult<Boolean> uploadVistor(VisitorRecordResultEvent visitorRecordResultEvent, CloudwalkCallContext context) throws ServiceException {
+        String personId = visitorRecordResultEvent.getRecognitionFaceId();
+        VisitorGetsParam visitorGetsParam = new VisitorGetsParam();
+        visitorGetsParam.setIds((List)Lists.newArrayList((Object[])new String[]{personId}));
+        CloudwalkResult visitorResult = this.visitorService.gets(visitorGetsParam, context);
+        if (visitorResult.isSuccess() && ((List)visitorResult.getData()).size() > 0) {
+            VisitorResult visitor = (VisitorResult)((List)visitorResult.getData()).get(0);
+            context.getUser().setCaller(visitor.getCreateUserId());
+            DeviceContext deviceContext = (DeviceContext)((DefaultExtendContext)context.getExt()).getValue();
+            VisitorRecordNewParam visitorRecordNewParam = this.buildRecogRecordParamWithDeviceContext(deviceContext);
+            visitorRecordNewParam.setVisitorId(visitor.getId());
+            visitorRecordNewParam.setVisitorName(visitor.getName());
+            visitorRecordNewParam.setReceiverId(visitor.getPersonId());
+            visitorRecordNewParam.setReceiverName(visitor.getPersonName());
+            visitorRecordNewParam.setBusinessId(context.getCompany().getCompanyId());
+            visitorRecordNewParam.setSpotImgPath(visitorRecordResultEvent.getFaceImagePath());
+            visitorRecordNewParam.setFacePath(visitor.getRegFaceUrl());
+            visitorRecordNewParam.setStatus(VisitorDeviceConstants.DEFAULT_RECOG_STATUS);
+            visitorRecordNewParam.setSignTime(visitorRecordResultEvent.getRecognitionTime());
+            visitorRecordNewParam.setPanoramaPath(visitorRecordResultEvent.getPanoramaImagePath());
+            visitorRecordNewParam.setOpenDoorType(visitorRecordResultEvent.getOpenDoorType());
+            visitorRecordNewParam.setSrcFloor(visitorRecordResultEvent.getSrcFloor());
+            visitorRecordNewParam.setDestFloor(visitorRecordResultEvent.getDestFloor());
+            visitorRecordNewParam.setDispatchElevatorNo(visitorRecordResultEvent.getDispatchElevatorNo());
+            this.visitorRecordService.add(visitorRecordNewParam, context);
+        }
+        return CloudwalkResult.success((Object)true);
+    }
+
+    public void saveRecogRecord(PersonRecordUploadEvent param, Face face, CloudwalkCallContext context) throws ServiceException {
+        BigDecimal thresholdBigDecimal = BigDecimal.valueOf(param.getThreshold());
+        String personId = this.getPersonId(face.getFaceId(), context);
+        VisitorGetsParam visitorGetsParam = new VisitorGetsParam();
+        visitorGetsParam.setIds((List)Lists.newArrayList((Object[])new String[]{personId}));
+        CloudwalkResult visitorResult = this.visitorService.gets(visitorGetsParam, context);
+        if (visitorResult.isSuccess() && ((List)visitorResult.getData()).size() > 0) {
+            VisitorResult visitor = (VisitorResult)((List)visitorResult.getData()).get(0);
+            context.getUser().setCaller(visitor.getCreateUserId());
+            DeviceContext deviceContext = (DeviceContext)((DefaultExtendContext)context.getExt()).getValue();
+            VisitorRecordNewParam visitorRecordNewParam = this.buildRecogRecordParamWithDeviceContext(deviceContext);
+            visitorRecordNewParam.setLogId(param.getLogId());
+            visitorRecordNewParam.setVisitorId(visitor.getId());
+            visitorRecordNewParam.setVisitorName(visitor.getName());
+            visitorRecordNewParam.setReceiverId(visitor.getPersonId());
+            visitorRecordNewParam.setReceiverName(visitor.getPersonName());
+            visitorRecordNewParam.setBusinessId(context.getCompany().getCompanyId());
+            visitorRecordNewParam.setSpotImgPath(face.getFaceImagePath());
+            visitorRecordNewParam.setFacePath(visitor.getRegFaceUrl());
+            visitorRecordNewParam.setScore(BigDecimal.valueOf(face.getScore().floatValue()));
+            visitorRecordNewParam.setStatus(VisitorDeviceConstants.DEFAULT_RECOG_STATUS);
+            visitorRecordNewParam.setSignTime(face.getRecognitionTime());
+            visitorRecordNewParam.setThreshold(thresholdBigDecimal);
+            visitorRecordNewParam.setPanoramaPath(param.getPanoramaData() != null ? param.getPanoramaData().getPanoramaImagePath() : null);
+            this.visitorRecordService.add(visitorRecordNewParam, context);
+        }
+    }
+
+    private String getPersonId(String imageId, CloudwalkCallContext context) throws ServiceException {
+        PersonQueryParam personQueryParam = new PersonQueryParam();
+        personQueryParam.setImageIds((List)Lists.newArrayList((Object[])new String[]{imageId}));
+        CloudwalkResult personResult = this.personService.list(personQueryParam, context);
+        if (personResult.isSuccess() && CollectionUtils.isNotEmpty((Collection)((Collection)personResult.getData()))) {
+            return ((PersonResult)((List)personResult.getData()).get(0)).getId();
+        }
+        return "";
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/record/VisitorRecordServiceImpl.java

@@ -0,0 +1,188 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.ninca.visitor.record.VisitorRecordManager
+ *  cn.cloudwalk.client.ninca.visitor.record.param.VisitorRecordNewParam
+ *  cn.cloudwalk.client.ninca.visitor.record.param.VisitorRecordPageParam
+ *  cn.cloudwalk.client.ninca.visitor.record.param.VisitorRecordQueryParam
+ *  cn.cloudwalk.client.ninca.visitor.record.result.VisitorOverviewResult
+ *  cn.cloudwalk.client.ninca.visitor.record.result.VisitorQueryResult
+ *  cn.cloudwalk.client.ninca.visitor.record.result.VisitorRecordResult
+ *  cn.cloudwalk.client.ninca.visitor.record.service.VisitorRecordService
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorGetsParam
+ *  cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorResult
+ *  cn.cloudwalk.client.ninca.visitor.visitor.service.VisitorService
+ *  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.session.company.CompanyContext
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.visitor.bean.record.VisitorRecordGetsDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.record.VisitorRecordNewDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.record.VisitorRecordQueryDTO
+ *  cn.cloudwalk.common.ninca.visitor.em.PersonRoleEnum
+ *  cn.cloudwalk.common.ninca.visitor.em.YesNoTypeEnum
+ *  cn.cloudwalk.common.ninca.visitor.util.CollectionUtils
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.visitor.record;
+
+import cn.cloudwalk.biz.ninca.visitor.record.VisitorRecordManager;
+import cn.cloudwalk.client.ninca.visitor.record.param.VisitorRecordNewParam;
+import cn.cloudwalk.client.ninca.visitor.record.param.VisitorRecordPageParam;
+import cn.cloudwalk.client.ninca.visitor.record.param.VisitorRecordQueryParam;
+import cn.cloudwalk.client.ninca.visitor.record.result.VisitorOverviewResult;
+import cn.cloudwalk.client.ninca.visitor.record.result.VisitorQueryResult;
+import cn.cloudwalk.client.ninca.visitor.record.result.VisitorRecordResult;
+import cn.cloudwalk.client.ninca.visitor.record.service.VisitorRecordService;
+import cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorGetsParam;
+import cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorResult;
+import cn.cloudwalk.client.ninca.visitor.visitor.service.VisitorService;
+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.session.company.CompanyContext;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.visitor.bean.record.VisitorRecordGetsDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.record.VisitorRecordNewDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.record.VisitorRecordQueryDTO;
+import cn.cloudwalk.common.ninca.visitor.em.PersonRoleEnum;
+import cn.cloudwalk.common.ninca.visitor.em.YesNoTypeEnum;
+import cn.cloudwalk.common.ninca.visitor.util.CollectionUtils;
+import cn.cloudwalk.service.ninca.visitor.common.AbstractCloudwalkService;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class VisitorRecordServiceImpl
+extends AbstractCloudwalkService
+implements VisitorRecordService {
+    @Autowired
+    private VisitorRecordManager visitorRecordManager;
+    @Autowired
+    private VisitorService visitorService;
+
+    public CloudwalkResult<String> add(VisitorRecordNewParam param, CloudwalkCallContext context) throws ServiceException {
+        VisitorRecordNewDTO dto = new VisitorRecordNewDTO();
+        VisitorRecordGetsDTO getsDTO = new VisitorRecordGetsDTO();
+        getsDTO.setBusinessId(context.getCompany().getCompanyId());
+        getsDTO.setVisitorIds(Collections.singletonList(param.getVisitorId()));
+        getsDTO.setFirstRecord(YesNoTypeEnum.Y.getCode());
+        List visitorRecordResultDTOS = null;
+        try {
+            visitorRecordResultDTOS = this.visitorRecordManager.gets(getsDTO);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u83b7\u53d6\u8bc6\u522b\u8bb0\u5f55\u5931\u8d25,\u9519\u8bef\u4fe1\u606f\uff1a{}", (Object)e.getMessage());
+            throw new ServiceException((Throwable)e);
+        }
+        dto.setFirstRecord(YesNoTypeEnum.N.getCode());
+        if (CollectionUtils.isEmpty((Collection)visitorRecordResultDTOS)) {
+            dto.setFirstRecord(YesNoTypeEnum.Y.getCode());
+        }
+        BeanCopyUtils.copyProperties((Object)param, (CloudwalkCallContext)context, (Object)dto);
+        dto.setBusinessId(context.getCompany().getCompanyId());
+        dto.setId(this.genUUID());
+        try {
+            this.visitorRecordManager.add(dto);
+        }
+        catch (Exception e) {
+            this.logger.error("\u65b0\u589e\u8bc6\u522b\u8bb0\u5f55\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+        return CloudwalkResult.success((Object)dto.getId());
+    }
+
+    public CloudwalkResult<VisitorQueryResult> query(VisitorRecordQueryParam param, CloudwalkCallContext context) throws ServiceException {
+        VisitorQueryResult result = new VisitorQueryResult();
+        VisitorGetsParam visitorGetsParam = new VisitorGetsParam();
+        visitorGetsParam.setIds(Collections.singletonList(param.getVisitorId()));
+        CloudwalkResult visitorCloudwalkResult = this.visitorService.gets(visitorGetsParam, context);
+        if (visitorCloudwalkResult.isSuccess() && CollectionUtils.isNotEmpty((Collection)((Collection)visitorCloudwalkResult.getData()))) {
+            result.setVisitorInfo((VisitorResult)((List)visitorCloudwalkResult.getData()).get(0));
+            List recordResults = new ArrayList();
+            VisitorRecordGetsDTO dto = new VisitorRecordGetsDTO();
+            dto.setBusinessId(context.getCompany().getCompanyId());
+            dto.setVisitorIds(Collections.singletonList(param.getVisitorId()));
+            List resultDtos = null;
+            try {
+                resultDtos = this.visitorRecordManager.gets(dto);
+                recordResults = BeanCopyUtils.copy((Collection)resultDtos, VisitorRecordResult.class);
+                result.setVisitorRecordList(recordResults);
+            }
+            catch (DataAccessException e) {
+                this.logger.error("\u83b7\u53d6\u8bc6\u522b\u8bb0\u5f55\u5931\u8d25,\u9519\u8bef\u4fe1\u606f\uff1a{}", (Object)e.getMessage());
+                throw new ServiceException((Throwable)e);
+            }
+        }
+        return CloudwalkResult.success((Object)result);
+    }
+
+    public CloudwalkResult<List<VisitorResult>> queryVisitor(VisitorRecordQueryParam param) throws ServiceException {
+        VisitorGetsParam visitorGetsParam = new VisitorGetsParam();
+        visitorGetsParam.setIds(Collections.singletonList(param.getVisitorId()));
+        CloudwalkCallContext context = new CloudwalkCallContext();
+        CompanyContext companyContext = new CompanyContext();
+        companyContext.setCompanyId(param.getBusinessId());
+        context.setCompany(companyContext);
+        return this.visitorService.gets(visitorGetsParam, context);
+    }
+
+    public CloudwalkResult<CloudwalkPageAble<VisitorRecordResult>> page(VisitorRecordPageParam param, CloudwalkPageInfo page, CloudwalkCallContext context) throws ServiceException {
+        VisitorRecordQueryDTO dto = (VisitorRecordQueryDTO)BeanCopyUtils.copyProperties((Object)param, VisitorRecordQueryDTO.class);
+        if (!param.isFromOpen() && !super.validCurrentUserRole(context, PersonRoleEnum.CORP_ADMIN, PersonRoleEnum.BUSINESS_ADMIN)) {
+            dto.setReceiverId(super.gerCurrentUserPersonId(context));
+            dto.setCreateUserId(context.getUser().getCaller());
+        }
+        dto.setBusinessId(context.getCompany().getCompanyId());
+        dto.setStartSignTime(param.getStartTime());
+        dto.setEndSignTime(param.getEndTime());
+        dto.setDeviceIds(param.getDeviceIds());
+        CloudwalkPageAble cloudwalkResult = null;
+        try {
+            cloudwalkResult = this.visitorRecordManager.page(dto, page);
+            List results = BeanCopyUtils.copy((Collection)cloudwalkResult.getDatas(), VisitorRecordResult.class);
+            return CloudwalkResult.success((Object)new CloudwalkPageAble((Collection)results, page, cloudwalkResult.getTotalRows()));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u5206\u9875\u67e5\u8be2\u8bc6\u522b\u8bb0\u5f55\u5931\u8d25,\u9519\u8bef\u4fe1\u606f\uff1a{}", (Object)e.getMessage());
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<VisitorOverviewResult> getOverview(VisitorRecordPageParam param, CloudwalkCallContext context) throws ServiceException {
+        VisitorOverviewResult result = new VisitorOverviewResult();
+        result.setAll(Integer.valueOf(0));
+        VisitorRecordQueryDTO dto = (VisitorRecordQueryDTO)BeanCopyUtils.copyProperties((Object)param, VisitorRecordQueryDTO.class);
+        dto.setBusinessId(context.getCompany().getCompanyId());
+        dto.setStartSignTime(param.getStartTime());
+        dto.setEndSignTime(param.getEndTime());
+        dto.setDeviceIds(param.getDeviceIds());
+        try {
+            List visitorIds = this.visitorService.listIdsByTime(dto);
+            if (!CollectionUtils.isEmpty((Collection)visitorIds)) {
+                dto.setVisitorIds(visitorIds);
+                Integer number = this.visitorRecordManager.getOverview(dto);
+                result.setAll(number);
+            }
+            return CloudwalkResult.success((Object)result);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u6839\u636e\u65f6\u95f4\u67e5\u8be2\u5230\u8bbf\u4eba\u6570\u5931\u8d25,\u9519\u8bef\u4fe1\u606f\uff1a{}", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/record/push/VisitorRecordPushEvent.java

@@ -0,0 +1,217 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.cwos.client.event.event.CustomEvent
+ */
+package cn.cloudwalk.service.ninca.visitor.record.push;
+
+import cn.cloudwalk.cwos.client.event.event.CustomEvent;
+import java.math.BigDecimal;
+
+public class VisitorRecordPushEvent
+extends CustomEvent {
+    private String id;
+    private String visitorId;
+    private String visitorName;
+    private String deviceCode;
+    private Long signTime;
+    private String deviceTypeId;
+    private String deviceTypeName;
+    private String facePath;
+    private String spotImgPath;
+    private String panoramaPath;
+    private BigDecimal score;
+    private Integer status;
+    private BigDecimal threshold;
+    private String remark;
+    private String receiverId;
+    private String receiverName;
+    private String deviceAreaId;
+    private String deviceAreaName;
+    private String deviceDistrictId;
+    private String deviceDistrictName;
+    private String deviceDistrictPath;
+    private String deviceDistrictMergeName;
+
+    public String getTopic() {
+        return "VISITOR_RECORD_TOPIC";
+    }
+
+    public String getId() {
+        return this.id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getDeviceDistrictId() {
+        return this.deviceDistrictId;
+    }
+
+    public void setDeviceDistrictId(String deviceDistrictId) {
+        this.deviceDistrictId = deviceDistrictId;
+    }
+
+    public String getDeviceDistrictName() {
+        return this.deviceDistrictName;
+    }
+
+    public void setDeviceDistrictName(String deviceDistrictName) {
+        this.deviceDistrictName = deviceDistrictName;
+    }
+
+    public String getDeviceDistrictPath() {
+        return this.deviceDistrictPath;
+    }
+
+    public void setDeviceDistrictPath(String deviceDistrictPath) {
+        this.deviceDistrictPath = deviceDistrictPath;
+    }
+
+    public String getDeviceDistrictMergeName() {
+        return this.deviceDistrictMergeName;
+    }
+
+    public void setDeviceDistrictMergeName(String deviceDistrictMergeName) {
+        this.deviceDistrictMergeName = deviceDistrictMergeName;
+    }
+
+    public String getVisitorId() {
+        return this.visitorId;
+    }
+
+    public void setVisitorId(String visitorId) {
+        this.visitorId = visitorId;
+    }
+
+    public String getVisitorName() {
+        return this.visitorName;
+    }
+
+    public void setVisitorName(String visitorName) {
+        this.visitorName = visitorName;
+    }
+
+    public String getDeviceCode() {
+        return this.deviceCode;
+    }
+
+    public void setDeviceCode(String deviceCode) {
+        this.deviceCode = deviceCode;
+    }
+
+    public Long getSignTime() {
+        return this.signTime;
+    }
+
+    public void setSignTime(Long signTime) {
+        this.signTime = signTime;
+    }
+
+    public String getDeviceTypeId() {
+        return this.deviceTypeId;
+    }
+
+    public void setDeviceTypeId(String deviceTypeId) {
+        this.deviceTypeId = deviceTypeId;
+    }
+
+    public String getDeviceTypeName() {
+        return this.deviceTypeName;
+    }
+
+    public void setDeviceTypeName(String deviceTypeName) {
+        this.deviceTypeName = deviceTypeName;
+    }
+
+    public String getFacePath() {
+        return this.facePath;
+    }
+
+    public void setFacePath(String facePath) {
+        this.facePath = facePath;
+    }
+
+    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;
+    }
+
+    public String getRemark() {
+        return this.remark;
+    }
+
+    public void setRemark(String remark) {
+        this.remark = remark;
+    }
+
+    public String getReceiverId() {
+        return this.receiverId;
+    }
+
+    public void setReceiverId(String receiverId) {
+        this.receiverId = receiverId;
+    }
+
+    public String getReceiverName() {
+        return this.receiverName;
+    }
+
+    public void setReceiverName(String receiverName) {
+        this.receiverName = receiverName;
+    }
+
+    public String getDeviceAreaId() {
+        return this.deviceAreaId;
+    }
+
+    public void setDeviceAreaId(String deviceAreaId) {
+        this.deviceAreaId = deviceAreaId;
+    }
+
+    public String getDeviceAreaName() {
+        return this.deviceAreaName;
+    }
+
+    public void setDeviceAreaName(String deviceAreaName) {
+        this.deviceAreaName = deviceAreaName;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/record/push/aspect/VisitorRecordAddAspect.java

@@ -0,0 +1,93 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.ninca.visitor.record.param.VisitorRecordNewParam
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.serial.UUIDSerial
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.visitor.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.visitor.record.push.aspect;
+
+import cn.cloudwalk.client.ninca.visitor.record.param.VisitorRecordNewParam;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.cloud.serial.UUIDSerial;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.visitor.util.StringUtils;
+import cn.cloudwalk.cwos.client.event.event.BaseEvent;
+import cn.cloudwalk.event.CloudwalkEventManager;
+import cn.cloudwalk.service.ninca.visitor.common.VisitorCommonConfigProperties;
+import cn.cloudwalk.service.ninca.visitor.record.push.VisitorRecordPushEvent;
+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 VisitorRecordAddAspect {
+    private static final Logger logger = LoggerFactory.getLogger(VisitorRecordAddAspect.class);
+    @Autowired
+    private VisitorCommonConfigProperties visitorCommonConfigProperties;
+    @Resource
+    private CloudwalkEventManager cloudwalkEventManager;
+    @Autowired
+    private UUIDSerial uuidSerial;
+
+    @Pointcut(value="execution(* cn.cloudwalk.service.ninca.visitor.record.VisitorRecordServiceImpl.add(..))")
+    public void recogRecordAddPointcat() {
+    }
+
+    @Around(value="recogRecordAddPointcat()")
+    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
+        Object[] args = joinPoint.getArgs();
+        VisitorRecordNewParam param = (VisitorRecordNewParam)args[0];
+        CloudwalkResult addResult = (CloudwalkResult)joinPoint.proceed();
+        try {
+            if (addResult.isSuccess() && this.visitorCommonConfigProperties.isRecordPush()) {
+                VisitorRecordPushEvent pushEvent = this.buildVisitorRecordPsuhEvent(param);
+                pushEvent.setId((String)addResult.getData());
+                this.cloudwalkEventManager.publish((BaseEvent)pushEvent);
+            }
+        }
+        catch (Exception e) {
+            logger.error("\u63a8\u9001\u5230\u8bbf\u8bb0\u5f55\u5f02\u5e38,\u539f\u56e0:{}", (Throwable)e);
+        }
+        return addResult;
+    }
+
+    private VisitorRecordPushEvent buildVisitorRecordPsuhEvent(VisitorRecordNewParam param) {
+        VisitorRecordPushEvent event = (VisitorRecordPushEvent)((Object)BeanCopyUtils.copyProperties((Object)param, VisitorRecordPushEvent.class));
+        event.setMessageId(this.uuidSerial.uuid());
+        event.setFacePath(this.genFullPath(param.getFacePath()));
+        event.setPanoramaPath(this.genFullPath(param.getPanoramaPath()));
+        event.setSpotImgPath(this.genFullPath(param.getSpotImgPath()));
+        event.setServiceCode("VISITOR_RECORD_TOPIC" + this.visitorCommonConfigProperties.getRecordPushServicecode());
+        return event;
+    }
+
+    private String genFullPath(String path) {
+        return StringUtils.isNotBlank((String)path) ? this.visitorCommonConfigProperties.getCwosFilePath() + path : null;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/register/VisitorRegisterServiceImpl.java

@@ -0,0 +1,946 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.ninca.visitor.deivce.DeviceDefaultManager
+ *  cn.cloudwalk.biz.ninca.visitor.deivce.VisitorDeviceManager
+ *  cn.cloudwalk.biz.ninca.visitor.register.VisitorRegisterManager
+ *  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.person.param.PersonDetailParam
+ *  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.davinci.portal.enterprise.param.EnterpriseBasicParam
+ *  cn.cloudwalk.client.davinci.portal.enterprise.result.EnterpriseDetailResult
+ *  cn.cloudwalk.client.ninca.visitor.anonymous.service.AnonymousVerifyService
+ *  cn.cloudwalk.client.ninca.visitor.config.param.VisitorConfigEditParam
+ *  cn.cloudwalk.client.ninca.visitor.config.param.VisitorConfigQueryParam
+ *  cn.cloudwalk.client.ninca.visitor.config.result.VisitorConfigQueryResult
+ *  cn.cloudwalk.client.ninca.visitor.config.service.VisitorConfigService
+ *  cn.cloudwalk.client.ninca.visitor.message.param.GetShortUrlParam
+ *  cn.cloudwalk.client.ninca.visitor.message.param.Parameter
+ *  cn.cloudwalk.client.ninca.visitor.message.param.SmsSendParam
+ *  cn.cloudwalk.client.ninca.visitor.message.result.ShotUrlResult
+ *  cn.cloudwalk.client.ninca.visitor.message.service.SmsService
+ *  cn.cloudwalk.client.ninca.visitor.register.param.VisitorRegisterAddParam
+ *  cn.cloudwalk.client.ninca.visitor.register.param.VisitorRegisterApproveParam
+ *  cn.cloudwalk.client.ninca.visitor.register.param.VisitorRegisterEditParam
+ *  cn.cloudwalk.client.ninca.visitor.register.param.VisitorRegisterGetPidInfoParam
+ *  cn.cloudwalk.client.ninca.visitor.register.param.VisitorRegisterGetsParam
+ *  cn.cloudwalk.client.ninca.visitor.register.param.VisitorRegisterIdentifyParam
+ *  cn.cloudwalk.client.ninca.visitor.register.param.VisitorRegisterPageParam
+ *  cn.cloudwalk.client.ninca.visitor.register.param.VisitorRegisterSyncParam
+ *  cn.cloudwalk.client.ninca.visitor.register.param.VisitorYZTQrcodeUploadParam
+ *  cn.cloudwalk.client.ninca.visitor.register.result.VisitorRegisterAddResult
+ *  cn.cloudwalk.client.ninca.visitor.register.result.VisitorRegisterCountResult
+ *  cn.cloudwalk.client.ninca.visitor.register.result.VisitorRegisterPageResult
+ *  cn.cloudwalk.client.ninca.visitor.register.result.VisitorRegisterPidInfoResult
+ *  cn.cloudwalk.client.ninca.visitor.register.result.VisitorRegisterQueryResult
+ *  cn.cloudwalk.client.ninca.visitor.register.service.VisitorRegisterService
+ *  cn.cloudwalk.client.ninca.visitor.storage.service.FileStorageService
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorNewParam
+ *  cn.cloudwalk.client.ninca.visitor.visitor.result.AnonymousAddSignResult
+ *  cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorDeviceInfoResult
+ *  cn.cloudwalk.client.ninca.visitor.visitor.service.VisitorService
+ *  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.session.extend.DefaultExtendContext
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceDefaultGetsDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceDefaultResultDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceDeleteDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceGetsDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceNewDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceResultDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.register.dto.VisitorRegisterAddDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.register.dto.VisitorRegisterEditDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.register.dto.VisitorRegisterGetsDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.register.dto.VisitorRegisterPageDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.register.dto.VisitorRegisterPageResultDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.register.dto.VisitorRegisterPendingCountDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.register.dto.VisitorRegisterPendingSyncDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.register.dto.VisitorRegisterQueryDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.register.dto.VisitorRegisterQueryResultDTO
+ *  cn.cloudwalk.common.ninca.visitor.em.ApproveStatusEnum
+ *  cn.cloudwalk.common.ninca.visitor.em.PersonRoleEnum
+ *  cn.cloudwalk.common.ninca.visitor.em.VisitorConfigKeyEnum
+ *  cn.cloudwalk.common.ninca.visitor.em.VisitorRegisterAddTypeEnum
+ *  cn.cloudwalk.common.ninca.visitor.em.VisitorRegisterTypeEnum
+ *  cn.cloudwalk.common.ninca.visitor.em.YesNoTypeEnum
+ *  cn.cloudwalk.common.ninca.visitor.util.AesUtil
+ *  cn.cloudwalk.common.ninca.visitor.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.visitor.util.DateUtils
+ *  cn.cloudwalk.common.ninca.visitor.util.MaskUtil
+ *  cn.cloudwalk.common.ninca.visitor.util.StringUtils
+ *  cn.cloudwalk.common.ninca.visitor.util.UrlUtil
+ *  cn.cloudwalk.cwos.client.resource.ResourceClient
+ *  com.alibaba.fastjson.JSONObject
+ *  javax.annotation.Resource
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Service
+ *  org.springframework.transaction.annotation.Transactional
+ *  org.springframework.util.ObjectUtils
+ */
+package cn.cloudwalk.service.ninca.visitor.register;
+
+import cn.cloudwalk.biz.ninca.visitor.deivce.DeviceDefaultManager;
+import cn.cloudwalk.biz.ninca.visitor.deivce.VisitorDeviceManager;
+import cn.cloudwalk.biz.ninca.visitor.register.VisitorRegisterManager;
+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.person.param.PersonDetailParam;
+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.davinci.portal.enterprise.param.EnterpriseBasicParam;
+import cn.cloudwalk.client.davinci.portal.enterprise.result.EnterpriseDetailResult;
+import cn.cloudwalk.client.ninca.visitor.anonymous.service.AnonymousVerifyService;
+import cn.cloudwalk.client.ninca.visitor.config.param.VisitorConfigEditParam;
+import cn.cloudwalk.client.ninca.visitor.config.param.VisitorConfigQueryParam;
+import cn.cloudwalk.client.ninca.visitor.config.result.VisitorConfigQueryResult;
+import cn.cloudwalk.client.ninca.visitor.config.service.VisitorConfigService;
+import cn.cloudwalk.client.ninca.visitor.message.param.GetShortUrlParam;
+import cn.cloudwalk.client.ninca.visitor.message.param.Parameter;
+import cn.cloudwalk.client.ninca.visitor.message.param.SmsSendParam;
+import cn.cloudwalk.client.ninca.visitor.message.result.ShotUrlResult;
+import cn.cloudwalk.client.ninca.visitor.message.service.SmsService;
+import cn.cloudwalk.client.ninca.visitor.register.param.VisitorRegisterAddParam;
+import cn.cloudwalk.client.ninca.visitor.register.param.VisitorRegisterApproveParam;
+import cn.cloudwalk.client.ninca.visitor.register.param.VisitorRegisterEditParam;
+import cn.cloudwalk.client.ninca.visitor.register.param.VisitorRegisterGetPidInfoParam;
+import cn.cloudwalk.client.ninca.visitor.register.param.VisitorRegisterGetsParam;
+import cn.cloudwalk.client.ninca.visitor.register.param.VisitorRegisterIdentifyParam;
+import cn.cloudwalk.client.ninca.visitor.register.param.VisitorRegisterPageParam;
+import cn.cloudwalk.client.ninca.visitor.register.param.VisitorRegisterSyncParam;
+import cn.cloudwalk.client.ninca.visitor.register.param.VisitorYZTQrcodeUploadParam;
+import cn.cloudwalk.client.ninca.visitor.register.result.VisitorRegisterAddResult;
+import cn.cloudwalk.client.ninca.visitor.register.result.VisitorRegisterCountResult;
+import cn.cloudwalk.client.ninca.visitor.register.result.VisitorRegisterPageResult;
+import cn.cloudwalk.client.ninca.visitor.register.result.VisitorRegisterPidInfoResult;
+import cn.cloudwalk.client.ninca.visitor.register.result.VisitorRegisterQueryResult;
+import cn.cloudwalk.client.ninca.visitor.register.service.VisitorRegisterService;
+import cn.cloudwalk.client.ninca.visitor.storage.service.FileStorageService;
+import cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorNewParam;
+import cn.cloudwalk.client.ninca.visitor.visitor.result.AnonymousAddSignResult;
+import cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorDeviceInfoResult;
+import cn.cloudwalk.client.ninca.visitor.visitor.service.VisitorService;
+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.session.extend.DefaultExtendContext;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceDefaultGetsDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceDefaultResultDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceDeleteDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceGetsDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceNewDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceResultDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.register.dto.VisitorRegisterAddDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.register.dto.VisitorRegisterEditDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.register.dto.VisitorRegisterGetsDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.register.dto.VisitorRegisterPageDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.register.dto.VisitorRegisterPageResultDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.register.dto.VisitorRegisterPendingCountDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.register.dto.VisitorRegisterPendingSyncDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.register.dto.VisitorRegisterQueryDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.register.dto.VisitorRegisterQueryResultDTO;
+import cn.cloudwalk.common.ninca.visitor.em.ApproveStatusEnum;
+import cn.cloudwalk.common.ninca.visitor.em.PersonRoleEnum;
+import cn.cloudwalk.common.ninca.visitor.em.VisitorConfigKeyEnum;
+import cn.cloudwalk.common.ninca.visitor.em.VisitorRegisterAddTypeEnum;
+import cn.cloudwalk.common.ninca.visitor.em.VisitorRegisterTypeEnum;
+import cn.cloudwalk.common.ninca.visitor.em.YesNoTypeEnum;
+import cn.cloudwalk.common.ninca.visitor.util.AesUtil;
+import cn.cloudwalk.common.ninca.visitor.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.visitor.util.DateUtils;
+import cn.cloudwalk.common.ninca.visitor.util.MaskUtil;
+import cn.cloudwalk.common.ninca.visitor.util.StringUtils;
+import cn.cloudwalk.common.ninca.visitor.util.UrlUtil;
+import cn.cloudwalk.cwos.client.resource.ResourceClient;
+import cn.cloudwalk.service.ninca.visitor.common.AbstractCloudwalkService;
+import cn.cloudwalk.service.ninca.visitor.common.job.executable.CleanGroupExpiredVisitorsJob;
+import com.alibaba.fastjson.JSONObject;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.ObjectUtils;
+
+@Service
+public class VisitorRegisterServiceImpl
+extends AbstractCloudwalkService
+implements VisitorRegisterService {
+    private static final Logger LOGGER = LoggerFactory.getLogger(CleanGroupExpiredVisitorsJob.class);
+    @Resource
+    private VisitorRegisterManager visitorRegisterManager;
+    @Autowired
+    private VisitorService visitorService;
+    @Resource
+    private FileStorageService fileStorageService;
+    @Resource
+    private SmsService smsService;
+    @Resource
+    private DeviceDefaultManager deviceDefaultManager;
+    @Resource
+    private AnonymousVerifyService anonymousVerifyService;
+    @Resource
+    private PersonService personService;
+    @Resource
+    private VisitorDeviceManager visitorDeviceManager;
+    @Resource
+    private DeviceService deviceService;
+    @Autowired
+    private VisitorConfigService visitorConfigService;
+
+    @CloudwalkParamsValidate
+    public CloudwalkResult<CloudwalkPageAble<VisitorRegisterPageResult>> page(VisitorRegisterPageParam param, CloudwalkPageInfo pageInfo, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            VisitorRegisterPageDTO pageDTO = (VisitorRegisterPageDTO)BeanCopyUtils.copyProperties((Object)param, VisitorRegisterPageDTO.class);
+            pageDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            if (!super.validCurrentUserRole(cloudwalkContext, PersonRoleEnum.CORP_ADMIN, PersonRoleEnum.BUSINESS_ADMIN)) {
+                pageDTO.setPersonId(super.gerCurrentUserPersonId(cloudwalkContext));
+            }
+            if (ApproveStatusEnum.WAITING.getCode().equals(param.getApproveStatus())) {
+                pageDTO.setIsValid(YesNoTypeEnum.Y.getCode());
+                pageDTO.setNowTime(Long.valueOf(System.currentTimeMillis()));
+            } else if (ApproveStatusEnum.EXPIRE.getCode().equals(param.getApproveStatus())) {
+                pageDTO.setApproveStatus(ApproveStatusEnum.WAITING.getCode());
+                pageDTO.setIsValid(YesNoTypeEnum.N.getCode());
+                pageDTO.setNowTime(Long.valueOf(System.currentTimeMillis()));
+            }
+            CloudwalkResult pageResult = this.visitorRegisterManager.page(pageDTO, pageInfo);
+            if (CollectionUtils.isEmpty((Collection)((CloudwalkPageAble)pageResult.getData()).getDatas())) {
+                return CloudwalkResult.success((Object)new CloudwalkPageAble(new ArrayList(), pageInfo, 0L));
+            }
+            List<VisitorRegisterPageResult> resultList = this.pageConvert(cloudwalkContext, (CloudwalkPageAble<VisitorRegisterPageResultDTO>)((CloudwalkPageAble)pageResult.getData()));
+            return CloudwalkResult.success((Object)new CloudwalkPageAble(resultList, pageInfo, ((CloudwalkPageAble)pageResult.getData()).getTotalRows()));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u5206\u9875\u67e5\u8be2\u8bbf\u5ba2\u6ce8\u518c\u8bb0\u5f55\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<CloudwalkPageAble<VisitorRegisterQueryResult>> pendingSync(VisitorRegisterSyncParam param, CloudwalkPageInfo pageInfo, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            VisitorRegisterPendingSyncDTO syncDTO = (VisitorRegisterPendingSyncDTO)BeanCopyUtils.copyProperties((Object)param, VisitorRegisterPendingSyncDTO.class);
+            syncDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            syncDTO.setNowTime(Long.valueOf(System.currentTimeMillis()));
+            CloudwalkPageAble pageResult = this.visitorRegisterManager.pendingSync(syncDTO, pageInfo);
+            List<VisitorRegisterQueryResult> registerQueryResultList = this.convertGetResult((List)pageResult.getDatas(), cloudwalkContext);
+            return CloudwalkResult.success((Object)new CloudwalkPageAble(registerQueryResultList, pageInfo, pageResult.getTotalRows()));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u5206\u9875\u67e5\u8be2\u8bbf\u5ba2\u6ce8\u518c\u8bb0\u5f55\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @Transactional(rollbackFor={Exception.class})
+    @CloudwalkParamsValidate
+    public CloudwalkResult<Boolean> approve(VisitorRegisterApproveParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            List dtoList;
+            VisitorRegisterQueryDTO queryDTO = new VisitorRegisterQueryDTO();
+            queryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            queryDTO.setIds(param.getIds());
+            if (!super.validCurrentUserRole(cloudwalkContext, PersonRoleEnum.CORP_ADMIN, PersonRoleEnum.BUSINESS_ADMIN)) {
+                queryDTO.setPersonId(super.gerCurrentUserPersonId(cloudwalkContext));
+            }
+            if (!param.isFromWx() && CollectionUtils.isEmpty((Collection)param.getDeviceIds())) {
+                DeviceDefaultGetsDTO defaultGetsDTO = new DeviceDefaultGetsDTO();
+                defaultGetsDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+                List deviceDefaultList = this.deviceDefaultManager.gets(defaultGetsDTO);
+                if (ApproveStatusEnum.APPROVED.getCode().equals(param.getApproveStatus())) {
+                    if (CollectionUtils.isEmpty((Collection)deviceDefaultList)) {
+                        this.logger.info("\u6ca1\u6709\u8bbe\u7f6e\u8bbf\u5ba2\u53ef\u7528\u8bbe\u5907\uff0c\u8bf7\u8054\u7cfb\u7ba1\u7406\u5458");
+                        return CloudwalkResult.fail((String)"762508023", (String)this.getMessage("762508023"));
+                    }
+                    param.setDeviceIds(deviceDefaultList.stream().map(DeviceDefaultResultDTO::getDeviceId).collect(Collectors.toList()));
+                }
+            }
+            if (CollectionUtils.isNotEmpty((Collection)(dtoList = this.visitorRegisterManager.query(queryDTO))) && dtoList.size() == 1 && param.isFromWx()) {
+                VisitorRegisterQueryResultDTO dto = (VisitorRegisterQueryResultDTO)dtoList.get(0);
+                if (!ApproveStatusEnum.WAITING.getCode().equals(dto.getApproveStatus()) || dto.getEndVisiterTime() < System.currentTimeMillis()) {
+                    return CloudwalkResult.fail((String)"762508024", (String)this.getMessage("762508024"));
+                }
+            }
+            ArrayList<VisitorRegisterQueryResultDTO> smsList = new ArrayList<VisitorRegisterQueryResultDTO>();
+            for (VisitorRegisterQueryResultDTO dto : dtoList) {
+                if (ApproveStatusEnum.WAITING.getCode().equals(dto.getApproveStatus()) && dto.getEndVisiterTime() > System.currentTimeMillis()) {
+                    if (ApproveStatusEnum.APPROVED.getCode().equals(param.getApproveStatus())) {
+                        VisitorDeviceDeleteDTO deviceDeleteDTO = new VisitorDeviceDeleteDTO();
+                        deviceDeleteDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+                        deviceDeleteDTO.setVisitorId(dto.getId());
+                        this.visitorDeviceManager.delete(deviceDeleteDTO);
+                        if (!CollectionUtils.isEmpty((Collection)param.getDeviceIds())) {
+                            this.deviceAdd(cloudwalkContext, param.getDeviceIds(), dto.getId());
+                        }
+                        if (VisitorRegisterAddTypeEnum.ONLINE.getCode().equals(dto.getAddType())) {
+                            PersonResult approvePersonDTO = this.queryPerson(cloudwalkContext, dto.getPersonId());
+                            VisitorNewParam visitorNewParam = (VisitorNewParam)BeanCopyUtils.copyProperties((Object)dto, VisitorNewParam.class);
+                            if (!ObjectUtils.isEmpty((Object)dto.getRegFaceUrl())) {
+                                CloudwalkResult downResult = this.fileStorageService.getFileBase64(dto.getRegFaceUrl());
+                                visitorNewParam.setRegFaceUrl((String)downResult.getData());
+                            }
+                            visitorNewParam.setBegVisitorTime(dto.getBegVisiterTime());
+                            visitorNewParam.setEndVisitorTime(dto.getEndVisiterTime());
+                            visitorNewParam.setDeviceIds(param.getDeviceIds());
+                            visitorNewParam.setRegisterId(dto.getId());
+                            visitorNewParam.setCardNo(dto.getCardNo());
+                            if (approvePersonDTO != null) {
+                                visitorNewParam.setPersonName(approvePersonDTO.getName());
+                            }
+                            visitorNewParam.setRegType(VisitorRegisterTypeEnum.getEnumByCode((Integer)dto.getRegType()));
+                            visitorNewParam.setId(dto.getId());
+                            LOGGER.info("\u65b0\u589e\u8bbf\u5ba2\u4eba\u5458\u5f00\u59cb\uff0cPersonAddParam={}, CloudwalkCallContext={}", (Object)JSONObject.toJSONString((Object)visitorNewParam), (Object)JSONObject.toJSONString((Object)cloudwalkContext));
+                            this.visitorService.add(visitorNewParam, cloudwalkContext);
+                        }
+                    }
+                    VisitorRegisterEditDTO editDTO = new VisitorRegisterEditDTO();
+                    editDTO.setId(dto.getId());
+                    editDTO.setApproveDesc(param.getApproveDesc());
+                    editDTO.setApproveStatus(param.getApproveStatus());
+                    editDTO.setApproveTime(Long.valueOf(System.currentTimeMillis()));
+                    editDTO.setApprovePersonId(cloudwalkContext.getUser().getCaller());
+                    editDTO.setApprovePersonName(cloudwalkContext.getUser().getCallerName());
+                    editDTO.setLastUpdateUserId(cloudwalkContext.getUser().getCaller());
+                    editDTO.setLastUpdateTime(Long.valueOf(System.currentTimeMillis()));
+                    this.visitorRegisterManager.edit(editDTO);
+                }
+                smsList.add(dto);
+            }
+            if (!param.isFromWx() && CollectionUtils.isNotEmpty(smsList)) {
+                try {
+                    this.sendApproved(smsList, cloudwalkContext);
+                }
+                catch (Exception e) {
+                    this.logger.error("\u53d1\u9001\u77ed\u4fe1\u901a\u77e5\u5ba1\u6838\u901a\u8fc7\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+                }
+            }
+            return CloudwalkResult.success((Object)true);
+        }
+        catch (Exception e) {
+            this.logger.error("\u5ba1\u6838\u8bbf\u5ba2\u6ce8\u518c\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @CloudwalkParamsValidate
+    public CloudwalkResult<Boolean> identify(VisitorRegisterIdentifyParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            VisitorRegisterQueryDTO queryDTO = new VisitorRegisterQueryDTO();
+            queryDTO.setCardNo(param.getCardNo());
+            queryDTO.setAddType(VisitorRegisterAddTypeEnum.OFFLINE.getCode());
+            queryDTO.setApproveStatus(ApproveStatusEnum.APPROVED.getCode());
+            List dtoList = this.visitorRegisterManager.query(queryDTO);
+            if (CollectionUtils.isEmpty((Collection)dtoList)) {
+                return CloudwalkResult.fail((String)"762510042", (String)this.getMessage("762510042"));
+            }
+            super.faceFeatureCheck(param.getRegFace(), cloudwalkContext);
+            CloudwalkResult uploadCloudwalkResult = this.fileStorageService.fileUpload("visitorReg.jpg", param.getRegFace());
+            if (!uploadCloudwalkResult.isSuccess() || uploadCloudwalkResult.getData() == null) {
+                this.logger.error("\u65b0\u589e\u8bbf\u5ba2\u6ce8\u518c\u7533\u8bf7\uff0c\u4e0a\u4f20\u6ce8\u518c\u7167\u7247\u5931\u8d25\uff0c\u539f\u56e0{}", (Object)uploadCloudwalkResult.getMessage());
+                throw new ServiceException("\u4e0a\u4f20\u7167\u7247\u5931\u8d25");
+            }
+            for (VisitorRegisterQueryResultDTO visitorRegister : dtoList) {
+                if (visitorRegister.getEndVisiterTime() > System.currentTimeMillis()) {
+                    VisitorDeviceGetsDTO visitorDeviceGetsDTO = new VisitorDeviceGetsDTO();
+                    visitorDeviceGetsDTO.setVisitorId(visitorRegister.getId());
+                    List gets = this.visitorDeviceManager.gets(visitorDeviceGetsDTO);
+                    List deviceIds = gets.stream().map(VisitorDeviceResultDTO::getDeviceId).collect(Collectors.toList());
+                    PersonResult approvePersonDTO = this.queryPerson(cloudwalkContext, visitorRegister.getPersonId());
+                    VisitorNewParam visitorNewParam = (VisitorNewParam)BeanCopyUtils.copyProperties((Object)visitorRegister, VisitorNewParam.class);
+                    visitorNewParam.setRegFaceUrl(param.getRegFace());
+                    visitorNewParam.setDisplayUrl(param.getDisplay());
+                    visitorNewParam.setBegVisitorTime(visitorRegister.getBegVisiterTime());
+                    visitorNewParam.setEndVisitorTime(visitorRegister.getEndVisiterTime());
+                    visitorNewParam.setDeviceIds(deviceIds);
+                    visitorNewParam.setRegisterId(visitorRegister.getId());
+                    visitorNewParam.setCardNo(visitorRegister.getCardNo());
+                    if (approvePersonDTO != null) {
+                        visitorNewParam.setPersonName(approvePersonDTO.getName());
+                    }
+                    visitorNewParam.setRegType(VisitorRegisterTypeEnum.MINI_PROGRAM);
+                    this.visitorService.add(visitorNewParam, cloudwalkContext);
+                }
+                VisitorRegisterEditDTO editDTO = new VisitorRegisterEditDTO();
+                editDTO.setId(visitorRegister.getId());
+                editDTO.setRegFaceUrl((String)uploadCloudwalkResult.getData());
+                this.visitorRegisterManager.edit(editDTO);
+            }
+            return CloudwalkResult.success((Object)Boolean.TRUE);
+        }
+        catch (Exception e) {
+            this.logger.error("\u6838\u9a8c\u8bbf\u5ba2\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    /*
+     * Enabled force condition propagation
+     * Lifted jumps to return sites
+     */
+    @Transactional(rollbackFor={Exception.class})
+    @CloudwalkParamsValidate
+    public CloudwalkResult<VisitorRegisterAddResult> add(VisitorRegisterAddParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            VisitorRegisterAddResult result = new VisitorRegisterAddResult();
+            PersonResult personInfo = null;
+            String pid = this.getPid(cloudwalkContext);
+            if (StringUtils.isNotBlank((String)pid) || StringUtils.isNotBlank((String)param.getPersonId())) {
+                String personId = param.getPersonId();
+                if (StringUtils.isNotBlank((String)pid)) {
+                    personId = this.getPersonIdByPid(pid);
+                }
+                PersonDetailParam personDetailParam = new PersonDetailParam();
+                personDetailParam.setId(personId);
+                CloudwalkResult personResult = this.personService.detail(personDetailParam, cloudwalkContext);
+                if (!personResult.isSuccess() || personResult.getData() == null) throw new ServiceException("\u67e5\u8be2\u4eba\u5458\u4fe1\u606f\u5931\u8d25");
+                personInfo = (PersonResult)personResult.getData();
+            } else {
+                PersonQueryParam personQueryParam = new PersonQueryParam();
+                personQueryParam.setPhone(param.getPersonTelephone());
+                CloudwalkResult personListResult = this.personService.list(personQueryParam, cloudwalkContext);
+                List personList = (List)personListResult.getData();
+                if (CollectionUtils.isEmpty((Collection)personList)) {
+                    this.logger.error("\u8bbf\u5ba2\u7533\u8bf7\u65b0\u589e\u5931\u8d25\uff0c\u539f\u56e0\uff1a\u88ab\u8bbf\u8005\u4e0d\u5b58\u5728");
+                    return CloudwalkResult.fail((String)"762510034", (String)"\u88ab\u8bbf\u4eba\u7535\u8bdd\u4e0d\u5b58\u5728");
+                }
+                for (PersonResult personResult : personList) {
+                    if (!StringUtils.equals((String)personResult.getName(), (String)param.getPersonName())) continue;
+                    personInfo = personResult;
+                    break;
+                }
+                if (personInfo == null) {
+                    return CloudwalkResult.fail((String)"762510034", (String)"\u88ab\u8bbf\u4eba\u4fe1\u606f\u4e0d\u6b63\u786e");
+                }
+            }
+            VisitorRegisterAddDTO addDTO = (VisitorRegisterAddDTO)BeanCopyUtils.copyProperties((Object)param, (CloudwalkCallContext)cloudwalkContext, (Object)new VisitorRegisterAddDTO());
+            if (VisitorRegisterAddTypeEnum.ONLINE.getCode().equals(param.getAddType())) {
+                if (!StringUtils.isBlank((String)param.getImage())) {
+                    super.faceFeatureCheck(param.getImage(), cloudwalkContext);
+                    CloudwalkResult uploadCloudwalkResult = this.fileStorageService.fileUpload("visitorReg.jpg", param.getImage());
+                    if (!uploadCloudwalkResult.isSuccess() || uploadCloudwalkResult.getData() == null) {
+                        this.logger.error("\u65b0\u589e\u8bbf\u5ba2\u6ce8\u518c\u7533\u8bf7\uff0c\u4e0a\u4f20\u6ce8\u518c\u7167\u7247\u5931\u8d25\uff0c\u539f\u56e0{}", (Object)uploadCloudwalkResult.getMessage());
+                        throw new ServiceException("\u4e0a\u4f20\u7167\u7247\u5931\u8d25");
+                    }
+                    addDTO.setRegFaceUrl((String)uploadCloudwalkResult.getData());
+                }
+            } else {
+                if (!VisitorRegisterAddTypeEnum.OFFLINE.getCode().equals(param.getAddType())) throw new ServiceException("762510040", this.getMessage("762510040"));
+                if (StringUtils.isBlank((String)param.getCardNo())) {
+                    throw new ServiceException("762510041", this.getMessage("762510041"));
+                }
+            }
+            addDTO.setId(this.genUUID());
+            addDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            addDTO.setApproveStatus(ApproveStatusEnum.APPROVED.getCode());
+            addDTO.setPersonId(personInfo.getId());
+            addDTO.setPersonName(personInfo.getName());
+            addDTO.setPersonTelephone(personInfo.getPhone());
+            addDTO.setCardNo(param.getCardNo());
+            addDTO.setCreateUserId(cloudwalkContext.getUser().getCaller());
+            addDTO.setLastUpdateUserId(cloudwalkContext.getUser().getCaller());
+            addDTO.setRegType(param.getRegType().getCode());
+            addDTO.setTelephone(param.getTelephone());
+            addDTO.setLicensePlate(param.getLicensePlate());
+            addDTO.setCompanyName(param.getCompanyName());
+            addDTO.setCause(param.getCause());
+            addDTO.setCarryOn(param.getCarryOn());
+            addDTO.setAddType(param.getAddType());
+            addDTO.setApproveTime(Long.valueOf(System.currentTimeMillis()));
+            addDTO.setApprovePersonId(cloudwalkContext.getUser().getCaller());
+            addDTO.setApprovePersonName(cloudwalkContext.getUser().getCallerName());
+            addDTO.setLastUpdateTime(Long.valueOf(System.currentTimeMillis()));
+            this.visitorRegisterManager.add(addDTO);
+            if (CollectionUtils.isNotEmpty((Collection)param.getDeviceIds())) {
+                this.deviceAdd(cloudwalkContext, param.getDeviceIds(), addDTO.getId());
+            }
+            VisitorRegisterQueryDTO queryDTO = new VisitorRegisterQueryDTO();
+            queryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            queryDTO.setIds(Collections.singletonList(addDTO.getId()));
+            if (!super.validCurrentUserRole(cloudwalkContext, PersonRoleEnum.CORP_ADMIN, PersonRoleEnum.BUSINESS_ADMIN)) {
+                queryDTO.setPersonId(super.gerCurrentUserPersonId(cloudwalkContext));
+            }
+            List dtoList = this.visitorRegisterManager.query(queryDTO);
+            for (VisitorRegisterQueryResultDTO dto : dtoList) {
+                PersonResult approvePersonDTO = this.queryPerson(cloudwalkContext, dto.getPersonId());
+                VisitorNewParam visitorNewParam = (VisitorNewParam)BeanCopyUtils.copyProperties((Object)dto, VisitorNewParam.class);
+                if (!ObjectUtils.isEmpty((Object)dto.getRegFaceUrl())) {
+                    CloudwalkResult downResult = this.fileStorageService.getFileBase64(dto.getRegFaceUrl());
+                    visitorNewParam.setRegFaceUrl((String)downResult.getData());
+                }
+                visitorNewParam.setBegVisitorTime(dto.getBegVisiterTime());
+                visitorNewParam.setEndVisitorTime(dto.getEndVisiterTime());
+                visitorNewParam.setDeviceIds(param.getDeviceIds());
+                visitorNewParam.setRegisterId(dto.getId());
+                visitorNewParam.setCardNo(dto.getCardNo());
+                if (approvePersonDTO != null) {
+                    visitorNewParam.setPersonName(approvePersonDTO.getName());
+                }
+                visitorNewParam.setRegType(VisitorRegisterTypeEnum.getEnumByCode((Integer)dto.getRegType()));
+                visitorNewParam.setId(dto.getId());
+                visitorNewParam.setFloorIds(param.getFloorIds());
+                this.visitorService.add(visitorNewParam, cloudwalkContext);
+            }
+            try {
+                if (!param.getRegType().equals((Object)VisitorRegisterTypeEnum.MINI_PROGRAM)) {
+                    this.sendAdd(addDTO.getId(), param, cloudwalkContext);
+                }
+            }
+            catch (Exception e) {
+                this.logger.error("\u53d1\u9001\u77ed\u4fe1\u901a\u77e5\u88ab\u8bbf\u8005\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            }
+            result.setId(addDTO.getId());
+            result.setRegFacePath(addDTO.getRegFaceUrl());
+            return CloudwalkResult.success((Object)result);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u65b0\u589e\u8bbf\u5ba2\u6ce8\u518c\u8bb0\u5f55\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<VisitorRegisterAddResult> edit(VisitorRegisterEditParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            CloudwalkResult personListResult;
+            List personList;
+            VisitorRegisterAddResult result = new VisitorRegisterAddResult();
+            PersonResult personInfo = null;
+            PersonQueryParam personQueryParam = new PersonQueryParam();
+            personQueryParam.setPhone(param.getPersonTelephone());
+            if (!param.getRegType().equals((Object)VisitorRegisterTypeEnum.MINI_PROGRAM)) {
+                personQueryParam.setCreateSysAccount(Integer.valueOf(1));
+            }
+            if (CollectionUtils.isEmpty((Collection)(personList = (List)(personListResult = this.personService.list(personQueryParam, cloudwalkContext)).getData()))) {
+                this.logger.error("\u8bbf\u5ba2\u7533\u8bf7\u65b0\u589e\u5931\u8d25\uff0c\u539f\u56e0\uff1a\u88ab\u8bbf\u8005\u4e0d\u5b58\u5728");
+                return CloudwalkResult.fail((String)"762510034", (String)"\u88ab\u8bbf\u4eba\u7535\u8bdd\u4e0d\u5b58\u5728");
+            }
+            for (PersonResult personResult : personList) {
+                if (!StringUtils.equals((String)personResult.getName(), (String)param.getPersonName())) continue;
+                personInfo = personResult;
+                break;
+            }
+            if (personInfo == null) {
+                return CloudwalkResult.fail((String)"762510034", (String)"\u88ab\u8bbf\u4eba\u4fe1\u606f\u4e0d\u6b63\u786e");
+            }
+            VisitorRegisterEditDTO editDTO = (VisitorRegisterEditDTO)BeanCopyUtils.copyProperties((Object)param, (CloudwalkCallContext)cloudwalkContext, (Object)new VisitorRegisterEditDTO());
+            if (!StringUtils.isBlank((String)param.getImage())) {
+                super.faceFeatureCheck(param.getImage(), cloudwalkContext);
+                CloudwalkResult uploadCloudwalkResult = this.fileStorageService.fileUpload("visitorReg.jpg", param.getImage());
+                if (!uploadCloudwalkResult.isSuccess() || uploadCloudwalkResult.getData() == null) {
+                    this.logger.error("\u65b0\u589e\u8bbf\u5ba2\u6ce8\u518c\u7533\u8bf7\uff0c\u4e0a\u4f20\u6ce8\u518c\u7167\u7247\u5931\u8d25\uff0c\u539f\u56e0{}", (Object)uploadCloudwalkResult.getMessage());
+                    throw new ServiceException("\u4e0a\u4f20\u7167\u7247\u5931\u8d25");
+                }
+                editDTO.setRegFaceUrl((String)uploadCloudwalkResult.getData());
+                result.setRegFacePath(editDTO.getRegFaceUrl());
+            }
+            editDTO.setId(param.getId());
+            if (VisitorRegisterTypeEnum.CARD_REG.equals((Object)param.getRegType()) || VisitorRegisterTypeEnum.OTHER.equals((Object)param.getRegType())) {
+                editDTO.setEndVisiterTime(param.getEndVisiterTime());
+            } else {
+                editDTO.setEndVisiterTime(Long.valueOf(param.getBegVisiterTime() + param.getTime() * 60L * 60L * 1000L));
+            }
+            editDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            editDTO.setApproveStatus(ApproveStatusEnum.WAITING.getCode());
+            editDTO.setPersonId(personInfo.getId());
+            editDTO.setPersonName(personInfo.getName());
+            editDTO.setPersonTelephone(personInfo.getPhone());
+            editDTO.setCardNo(param.getCardNo());
+            editDTO.setCreateUserId(cloudwalkContext.getUser().getCaller());
+            editDTO.setLastUpdateUserId(cloudwalkContext.getUser().getCaller());
+            editDTO.setRegType(param.getRegType().getCode());
+            editDTO.setTelephone(param.getTelephone());
+            this.visitorRegisterManager.edit(editDTO);
+            if (CollectionUtils.isNotEmpty((Collection)param.getDeviceIds())) {
+                VisitorDeviceDeleteDTO deviceDeleteDTO = new VisitorDeviceDeleteDTO();
+                deviceDeleteDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+                deviceDeleteDTO.setVisitorId(editDTO.getId());
+                this.visitorDeviceManager.delete(deviceDeleteDTO);
+                this.deviceAdd(cloudwalkContext, param.getDeviceIds(), editDTO.getId());
+            }
+            result.setId(editDTO.getId());
+            return CloudwalkResult.success((Object)result);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u65b0\u589e\u8bbf\u5ba2\u6ce8\u518c\u8bb0\u5f55\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    private void deviceAdd(CloudwalkCallContext cloudwalkContext, List<String> deviceIds, String id) throws DataAccessException {
+        for (String deviceId : deviceIds) {
+            VisitorDeviceNewDTO visitorDeviceNewDTO = new VisitorDeviceNewDTO();
+            visitorDeviceNewDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            visitorDeviceNewDTO.setVisitorId(id);
+            visitorDeviceNewDTO.setDeviceId(deviceId);
+            visitorDeviceNewDTO.setId(this.genUUID());
+            this.visitorDeviceManager.add(visitorDeviceNewDTO);
+        }
+    }
+
+    protected String getPid(CloudwalkCallContext context) {
+        if (context.getExt() != null) {
+            Map ext = (Map)((DefaultExtendContext)context.getExt()).getValue();
+            Object o = ext.get("pid");
+            return o == null ? null : o.toString();
+        }
+        return null;
+    }
+
+    public CloudwalkResult<List<VisitorRegisterQueryResult>> gets(VisitorRegisterGetsParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            VisitorRegisterGetsDTO getsDTO = (VisitorRegisterGetsDTO)BeanCopyUtils.copyProperties((Object)param, VisitorRegisterGetsDTO.class);
+            getsDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            List getsList = this.visitorRegisterManager.gets(getsDTO);
+            if (CollectionUtils.isEmpty((Collection)getsList)) {
+                return CloudwalkResult.success(new ArrayList());
+            }
+            return CloudwalkResult.success(this.convertGetResult(getsList, cloudwalkContext));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u67e5\u8be2\u8bbf\u5ba2\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<Integer> pendingCount(CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        Integer count = 0;
+        try {
+            VisitorRegisterPendingCountDTO pendingCountDto = new VisitorRegisterPendingCountDTO();
+            pendingCountDto.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            if (!this.validCurrentUserRole(cloudwalkContext, PersonRoleEnum.CORP_ADMIN, PersonRoleEnum.BUSINESS_ADMIN)) {
+                pendingCountDto.setApprovePersonId(cloudwalkContext.getUser().getCaller());
+            }
+            pendingCountDto.setEndVisiterTime(Long.valueOf(System.currentTimeMillis()));
+            count = this.visitorRegisterManager.pendingCount(pendingCountDto);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u7edf\u8ba1\u5f85\u5ba1\u6838\u4eba\u5458\u5931\u8d25\uff0c\u539f\u56e0", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+        return CloudwalkResult.success((Object)count);
+    }
+
+    public CloudwalkResult<List<VisitorRegisterCountResult>> count(CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        VisitorRegisterPendingCountDTO countDTO = new VisitorRegisterPendingCountDTO();
+        countDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+        countDTO.setApprovePersonId(cloudwalkContext.getUser().getCaller());
+        try {
+            List count = this.visitorRegisterManager.count(countDTO);
+            List result = BeanCopyUtils.copy((Collection)count, VisitorRegisterCountResult.class);
+            countDTO.setEndVisiterTime(Long.valueOf(System.currentTimeMillis()));
+            Integer expiredCount = this.visitorRegisterManager.expiredCount(countDTO);
+            VisitorRegisterCountResult expiredCountResult = new VisitorRegisterCountResult();
+            expiredCountResult.setApproveStatus(ApproveStatusEnum.EXPIRE.getCode());
+            expiredCountResult.setNum(expiredCount);
+            result.add(expiredCountResult);
+            return CloudwalkResult.success((Object)result);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u7edf\u8ba1\u4eba\u5458\u5931\u8d25\uff0c\u539f\u56e0", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @Transactional(rollbackFor={Exception.class})
+    @CloudwalkParamsValidate
+    public CloudwalkResult<Boolean> outerApprove(VisitorRegisterApproveParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            VisitorRegisterQueryDTO queryDTO = new VisitorRegisterQueryDTO();
+            queryDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            queryDTO.setIds(param.getIds());
+            List dtoList = this.visitorRegisterManager.query(queryDTO);
+            DeviceDefaultGetsDTO defaultGetsDTO = new DeviceDefaultGetsDTO();
+            defaultGetsDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            List deviceDefaultList = this.deviceDefaultManager.gets(defaultGetsDTO);
+            if (ApproveStatusEnum.APPROVED.getCode().equals(param.getApproveStatus())) {
+                if (CollectionUtils.isEmpty((Collection)deviceDefaultList)) {
+                    this.logger.info("\u6ca1\u6709\u8bbe\u7f6e\u8bbf\u5ba2\u53ef\u7528\u8bbe\u5907\uff0c\u8bf7\u8054\u7cfb\u7ba1\u7406\u5458");
+                    return CloudwalkResult.fail((String)"762508023", (String)this.getMessage("762508023"));
+                }
+                param.setDeviceIds(deviceDefaultList.stream().map(DeviceDefaultResultDTO::getDeviceId).collect(Collectors.toList()));
+            }
+            param.setDeviceIds(deviceDefaultList.stream().map(DeviceDefaultResultDTO::getDeviceId).collect(Collectors.toList()));
+            ArrayList<VisitorRegisterQueryResultDTO> smsList = new ArrayList<VisitorRegisterQueryResultDTO>();
+            for (VisitorRegisterQueryResultDTO dto : dtoList) {
+                if (!ApproveStatusEnum.WAITING.getCode().equals(dto.getApproveStatus()) || dto.getEndVisiterTime() <= System.currentTimeMillis()) continue;
+                if (ApproveStatusEnum.APPROVED.getCode().equals(param.getApproveStatus())) {
+                    PersonResult approvePersonDTO = this.queryPerson(cloudwalkContext, dto.getPersonId());
+                    VisitorNewParam visitorNewParam = (VisitorNewParam)BeanCopyUtils.copyProperties((Object)dto, VisitorNewParam.class);
+                    CloudwalkResult downResult = this.fileStorageService.getFileBase64(dto.getRegFaceUrl());
+                    visitorNewParam.setRegFaceUrl((String)downResult.getData());
+                    visitorNewParam.setBegVisitorTime(dto.getBegVisiterTime());
+                    visitorNewParam.setEndVisitorTime(dto.getEndVisiterTime());
+                    visitorNewParam.setDeviceIds(param.getDeviceIds());
+                    if (approvePersonDTO != null) {
+                        visitorNewParam.setPersonName(approvePersonDTO.getName());
+                    }
+                    visitorNewParam.setRegType(VisitorRegisterTypeEnum.getEnumByCode((Integer)dto.getRegType()));
+                    this.visitorService.add(visitorNewParam, cloudwalkContext);
+                }
+                VisitorRegisterEditDTO editDTO = new VisitorRegisterEditDTO();
+                editDTO.setId(dto.getId());
+                editDTO.setApproveDesc(param.getApproveDesc());
+                editDTO.setApproveStatus(param.getApproveStatus());
+                editDTO.setApproveTime(Long.valueOf(System.currentTimeMillis()));
+                editDTO.setApprovePersonId(dto.getPersonId());
+                editDTO.setApprovePersonName(dto.getPersonName());
+                editDTO.setLastUpdateUserId(dto.getPersonName());
+                editDTO.setLastUpdateTime(Long.valueOf(System.currentTimeMillis()));
+                this.visitorRegisterManager.edit(editDTO);
+                smsList.add(dto);
+            }
+            if (CollectionUtils.isNotEmpty(smsList)) {
+                try {
+                    this.sendApproved(smsList, cloudwalkContext);
+                }
+                catch (Exception e) {
+                    this.logger.error("\u53d1\u9001\u77ed\u4fe1\u901a\u77e5\u5ba1\u6838\u901a\u8fc7\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+                }
+            }
+            return CloudwalkResult.success((Object)true);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u5ba1\u6838\u8bbf\u5ba2\u6ce8\u518c\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<VisitorRegisterPidInfoResult> getPidInfo(VisitorRegisterGetPidInfoParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        VisitorRegisterPidInfoResult result = new VisitorRegisterPidInfoResult();
+        String personId = this.getPersonIdByPid(this.getPid(cloudwalkContext));
+        PersonDetailParam personDetailParam = new PersonDetailParam();
+        personDetailParam.setId(personId);
+        CloudwalkResult personResult = this.personService.detail(personDetailParam, cloudwalkContext);
+        if (!personResult.isSuccess() || personResult.getData() == null) {
+            throw new ServiceException("\u67e5\u8be2\u4eba\u5458\u4fe1\u606f\u5931\u8d25");
+        }
+        PersonResult personInfo = (PersonResult)personResult.getData();
+        result.setPersonTelephone(personInfo.getPhone() == null ? null : personInfo.getPhone().replaceAll("(\\d{0})\\d{7}(\\d{4})", "*******$2"));
+        result.setPersonName(MaskUtil.maskUserName((String)personInfo.getName()));
+        return CloudwalkResult.success((Object)result);
+    }
+
+    @CloudwalkParamsValidate
+    public CloudwalkResult<Boolean> qrcodeUpload(VisitorYZTQrcodeUploadParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        CloudwalkResult uploadCloudwalkResult = this.fileStorageService.fileUpload("yztQrcode.jpg", param.getQrcodeBase64());
+        if (!uploadCloudwalkResult.isSuccess() || uploadCloudwalkResult.getData() == null) {
+            this.logger.error("\u4e0a\u4f20\u5fae\u4fe1\u5c0f\u7a0b\u5e8f\u4e8c\u7ef4\u7801\u5931\u8d25\uff0c\u539f\u56e0{}", (Object)uploadCloudwalkResult.getMessage());
+            return CloudwalkResult.fail((String)uploadCloudwalkResult.getCode(), (String)uploadCloudwalkResult.getMessage());
+        }
+        VisitorConfigQueryParam configQueryParam = new VisitorConfigQueryParam();
+        configQueryParam.setConfigKey(VisitorConfigKeyEnum.YZT_WX_MINI_PROGRAM_QRCODE_PATH.getCode());
+        CloudwalkResult configQueryResult = this.visitorConfigService.query(configQueryParam, cloudwalkContext);
+        String configId = null;
+        if (configQueryResult.isSuccess() && CollectionUtils.isNotEmpty((Collection)((Collection)configQueryResult.getData()))) {
+            configId = ((VisitorConfigQueryResult)((List)configQueryResult.getData()).get(0)).getId();
+        }
+        VisitorConfigEditParam configEditParam = new VisitorConfigEditParam();
+        configEditParam.setConfigKey(VisitorConfigKeyEnum.YZT_WX_MINI_PROGRAM_QRCODE_PATH.getCode());
+        configEditParam.setConfigValue((String)uploadCloudwalkResult.getData());
+        configEditParam.setId(configId);
+        return this.visitorConfigService.edit(configEditParam, cloudwalkContext);
+    }
+
+    private String getPersonIdByPid(String pid) throws ServiceException {
+        try {
+            return AesUtil.decrypt((String)pid, (String)"www.cloudwalk.cn", (String)"otJe9ywLJ6#LLtgC");
+        }
+        catch (Exception e) {
+            this.logger.error("pid\u89e3\u5bc6\u5931\u8d25,\u539f\u56e0\uff1a{}", (Throwable)e);
+            throw new ServiceException("762508049", this.getMessage("762508049"));
+        }
+    }
+
+    private List<VisitorRegisterQueryResult> convertGetResult(List<VisitorRegisterQueryResultDTO> getsList, CloudwalkCallContext cloudwalkContext) throws DataAccessException, ServiceException {
+        String businessName = this.getBusinessName(cloudwalkContext);
+        ArrayList<VisitorRegisterQueryResult> resultList = new ArrayList<VisitorRegisterQueryResult>(10);
+        for (VisitorRegisterQueryResultDTO dto : getsList) {
+            VisitorRegisterQueryResult queryResult = (VisitorRegisterQueryResult)BeanCopyUtils.copyProperties((Object)dto, VisitorRegisterQueryResult.class);
+            queryResult.setRegFacePath(dto.getRegFaceUrl());
+            VisitorDeviceGetsDTO visitorDeviceGetsDTO = new VisitorDeviceGetsDTO();
+            visitorDeviceGetsDTO.setBusinessId(cloudwalkContext.getCompany().getCompanyId());
+            visitorDeviceGetsDTO.setVisitorId(dto.getId());
+            List visitorDeviceResultDTOList = this.visitorDeviceManager.gets(visitorDeviceGetsDTO);
+            List deviceIds = visitorDeviceResultDTOList.stream().map(VisitorDeviceResultDTO::getDeviceId).collect(Collectors.toList());
+            if (CollectionUtils.isNotEmpty(deviceIds)) {
+                DeviceQueryParam deviceQueryParam = new DeviceQueryParam();
+                deviceQueryParam.setIds(deviceIds);
+                Map<String, String> areaMap = this.getDeviceAreaMap(cloudwalkContext);
+                CloudwalkResult deviceResult = this.deviceService.list(deviceQueryParam, cloudwalkContext);
+                if (deviceResult.isSuccess()) {
+                    ArrayList<VisitorDeviceInfoResult> visitorDeviceInfoList = new ArrayList<VisitorDeviceInfoResult>();
+                    for (DeviceResult device : (List)deviceResult.getData()) {
+                        VisitorDeviceInfoResult visitorDeviceInfoResult = new VisitorDeviceInfoResult();
+                        visitorDeviceInfoResult.setDeviceId(device.getId());
+                        visitorDeviceInfoResult.setDeviceName(device.getDeviceName());
+                        visitorDeviceInfoResult.setDeviceAreaName(areaMap.get(device.getAreaId()));
+                        visitorDeviceInfoList.add(visitorDeviceInfoResult);
+                    }
+                    queryResult.setDeviceInfo(visitorDeviceInfoList);
+                } else {
+                    throw new ServiceException(deviceResult.getCode(), deviceResult.getMessage());
+                }
+            }
+            queryResult.setBusinessName(businessName);
+            resultList.add(queryResult);
+        }
+        return resultList;
+    }
+
+    private void sendAdd(String id, VisitorRegisterAddParam param, CloudwalkCallContext context) throws ServiceException {
+        String businessName = this.getBusinessName(context);
+        SmsSendParam sendParam = new SmsSendParam();
+        sendParam.setTelephone(param.getPersonTelephone());
+        sendParam.setServiceCode("visitor-mgmt");
+        sendParam.setTemplateId("SMS_182677013");
+        Parameter parameter1 = new Parameter();
+        parameter1.setKey("visitor_name");
+        parameter1.setValue(param.getName());
+        Parameter parameter2 = new Parameter();
+        parameter2.setKey("company_name");
+        parameter2.setValue(businessName);
+        Parameter parameter3 = new Parameter();
+        parameter3.setKey("visit_time_start");
+        parameter3.setValue(DateUtils.formatDate((Date)new Date(param.getBegVisiterTime()), (String)"yyyy-MM-dd HH:mm:ss"));
+        Parameter parameter4 = new Parameter();
+        parameter4.setKey("visit_time_length");
+        parameter4.setValue(param.getTime() + "");
+        Parameter parameter5 = new Parameter();
+        parameter5.setKey("short_url");
+        String shotUrl = this.getShotUrl(id, param.getUl(), context);
+        parameter5.setValue(shotUrl);
+        ArrayList<Parameter> parameters = new ArrayList<Parameter>(4);
+        parameters.add(parameter1);
+        parameters.add(parameter2);
+        parameters.add(parameter3);
+        parameters.add(parameter4);
+        parameters.add(parameter5);
+        sendParam.setParameter(parameters);
+        CloudwalkResult result = this.smsService.send(sendParam);
+    }
+
+    private String getShotUrl(String id, String ul, CloudwalkCallContext context) throws ServiceException {
+        CloudwalkResult sign = this.anonymousVerifyService.sign(context);
+        AnonymousAddSignResult signResult = (AnonymousAddSignResult)sign.getData();
+        HashMap<String, String> params = new HashMap<String, String>(8);
+        params.put("id", id);
+        params.put("bid", signResult.getBid());
+        params.put("sign", signResult.getSign());
+        params.put("ct", signResult.getCt() + "");
+        String url = UrlUtil.appendParams((String)ul, params);
+        GetShortUrlParam urlParam = new GetShortUrlParam();
+        urlParam.setUrl(url);
+        CloudwalkResult shortUrlRes = this.smsService.getShortUrl(urlParam);
+        if (shortUrlRes.isSuccess() && shortUrlRes.getData() != null) {
+            return ((ShotUrlResult)shortUrlRes.getData()).getShortUrl();
+        }
+        return "";
+    }
+
+    private void sendApproved(List<VisitorRegisterQueryResultDTO> smsList, CloudwalkCallContext context) throws ServiceException {
+        String businessName = this.getBusinessName(context);
+        for (VisitorRegisterQueryResultDTO dto : smsList) {
+            if (!ApproveStatusEnum.APPROVED.getCode().equals(dto.getApproveStatus()) && !ApproveStatusEnum.REFUSED.getCode().equals(dto.getApproveStatus())) continue;
+            SmsSendParam sendParam = new SmsSendParam();
+            if (ApproveStatusEnum.APPROVED.getCode().equals(dto.getApproveStatus()) && YesNoTypeEnum.Y.getCode().toString().equals(super.getConifgVaule(VisitorConfigKeyEnum.VISITOR_REG_SUCCESS_SMS_NOTIFY.getCode(), context))) {
+                sendParam.setTemplateId("SMS_193244830");
+            }
+            if (ApproveStatusEnum.REFUSED.getCode().equals(dto.getApproveStatus()) && YesNoTypeEnum.Y.getCode().toString().equals(super.getConifgVaule(VisitorConfigKeyEnum.VISITOR_REG_FAIL_SMS_NOTIFY.getCode(), context))) {
+                sendParam.setTemplateId("SMS_193520508");
+            }
+            sendParam.setTelephone(dto.getTelephone());
+            sendParam.setServiceCode("visitor-mgmt");
+            Parameter parameter1 = new Parameter();
+            parameter1.setKey("visit_time");
+            parameter1.setValue(DateUtils.formatDate((Date)new Date(dto.getBegVisiterTime()), (String)"yyyy-MM-dd HH:mm:ss"));
+            Parameter parameter2 = new Parameter();
+            parameter2.setKey("company_name");
+            if (businessName != null) {
+                parameter2.setValue(businessName);
+            } else {
+                parameter2.setValue(dto.getPersonTelephone());
+            }
+            ArrayList<Parameter> parameters = new ArrayList<Parameter>(3);
+            parameters.add(parameter1);
+            parameters.add(parameter2);
+            sendParam.setParameter(parameters);
+            this.smsService.send(sendParam);
+        }
+    }
+
+    private String getBusinessName(CloudwalkCallContext context) {
+        try {
+            EnterpriseBasicParam remoteParam = new EnterpriseBasicParam();
+            remoteParam.setId(context.getCompany().getCompanyId());
+            CloudwalkResult remoteResult = ResourceClient.getInstance().getPortalEnterpriseService().detail(remoteParam, context);
+            if (remoteResult.isSuccess() && remoteResult.getData() != null) {
+                return ((EnterpriseDetailResult)remoteResult.getData()).getCorpName();
+            }
+        }
+        catch (Exception e) {
+            this.logger.error("\u8c03\u7528\u8fdc\u7a0b\u63a5\u53e3\u67e5\u8be2\u4f01\u4e1a\u8be6\u60c5\u9519\u8bef\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+        }
+        return null;
+    }
+
+    private List<VisitorRegisterPageResult> pageConvert(CloudwalkCallContext cloudwalkContext, CloudwalkPageAble<VisitorRegisterPageResultDTO> data) throws DataAccessException, ServiceException {
+        List dtoList = (List)data.getDatas();
+        ArrayList<VisitorRegisterPageResult> resultList = new ArrayList<VisitorRegisterPageResult>(dtoList.size());
+        for (VisitorRegisterPageResultDTO dto : dtoList) {
+            VisitorRegisterPageResult pageResult = (VisitorRegisterPageResult)BeanCopyUtils.copyProperties((Object)dto, VisitorRegisterPageResult.class);
+            if (dto.getEndVisiterTime() != null && dto.getBegVisiterTime() != null) {
+                long time = (dto.getEndVisiterTime() - dto.getBegVisiterTime()) / 3600000L;
+                pageResult.setTime(Long.valueOf(time));
+            }
+            if (ApproveStatusEnum.WAITING.getCode().equals(dto.getApproveStatus()) && dto.getEndVisiterTime() < System.currentTimeMillis()) {
+                pageResult.setApproveStatus(ApproveStatusEnum.EXPIRE.getCode());
+            }
+            resultList.add(pageResult);
+        }
+        return resultList;
+    }
+
+    private PersonResult queryPerson(CloudwalkCallContext cloudwalkContext, String personId) throws ServiceException, DataAccessException {
+        try {
+            PersonQueryParam personQueryParam = new PersonQueryParam();
+            personQueryParam.setIds(Collections.singletonList(personId));
+            CloudwalkResult personCloudwalkResult = this.personService.list(personQueryParam, cloudwalkContext);
+            if (personCloudwalkResult.isSuccess() && CollectionUtils.isNotEmpty((Collection)((Collection)personCloudwalkResult.getData()))) {
+                return (PersonResult)((List)personCloudwalkResult.getData()).get(0);
+            }
+            return null;
+        }
+        catch (ServiceException e) {
+            this.logger.error("\u67e5\u8be2\u4eba\u5458\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/storage/FileStorageServiceImpl.java

@@ -0,0 +1,215 @@
+/*
+ * 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.visitor.photo.param.PhotoDelParam
+ *  cn.cloudwalk.client.ninca.visitor.storage.service.FileStorageService
+ *  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.file.dto.FileRemoveDTO
+ *  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
+ *  cn.cloudwalk.intelligent.davinci.storage.manager.FileStorageManager
+ *  org.apache.commons.codec.binary.Base64
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Component
+ *  org.springframework.util.FileCopyUtils
+ *  org.springframework.web.multipart.MultipartFile
+ */
+package cn.cloudwalk.service.ninca.visitor.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.visitor.photo.param.PhotoDelParam;
+import cn.cloudwalk.client.ninca.visitor.storage.service.FileStorageService;
+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.file.dto.FileRemoveDTO;
+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.intelligent.davinci.storage.manager.FileStorageManager;
+import cn.cloudwalk.service.ninca.visitor.common.AbstractCloudwalkService;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import org.apache.commons.codec.binary.Base64;
+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 FileStorageServiceImpl
+extends AbstractCloudwalkService
+implements FileStorageService {
+    @Autowired
+    private FileStorageManager fileStorageManager;
+    @Autowired
+    private FilePartManager filePartManager;
+
+    public CloudwalkResult<String> fileUpload(String fileName, String image) throws ServiceException {
+        byte[] bytes = Base64.decodeBase64((String)image);
+        return this.fileUpload(fileName, bytes);
+    }
+
+    public CloudwalkResult<String> fileUpload(String fileName, byte[] bytes) {
+        MultipartFile file = this.buildMultipartFile(fileName, bytes);
+        return this.fileUpload(file);
+    }
+
+    public CloudwalkResult<String> fileUpload(MultipartFile file) {
+        try {
+            return CloudwalkResult.success((Object)this.fileStorageManager.fileUpload("aiot", file));
+        }
+        catch (DavinciServiceException e) {
+            this.logger.error("\u4e0a\u4f20\u6587\u4ef6\u5931\u8d25\uff0c", (Throwable)e);
+            return CloudwalkResult.fail((String)"76251403", (String)this.getMessage("76251403"));
+        }
+    }
+
+    public CloudwalkResult<String> bigFileUpload(MultipartFile file) {
+        try {
+            return CloudwalkResult.success((Object)this.fileStorageManager.bigFileUpload("aiot", file));
+        }
+        catch (DavinciServiceException e) {
+            return CloudwalkResult.fail((String)"76251403", (String)this.getMessage("76251403"));
+        }
+    }
+
+    public byte[] fileDownload(String path) throws ServiceException {
+        try {
+            return this.fileStorageManager.fileDownload(path);
+        }
+        catch (DavinciServiceException e) {
+            this.logger.error("\u4e0b\u8f7d\u6587\u4ef6\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<String> getFileBase64(String path) throws ServiceException {
+        try {
+            return CloudwalkResult.success((Object)this.fileStorageManager.getFileBase64(path));
+        }
+        catch (DavinciServiceException e) {
+            this.logger.error("\u83b7\u53d6\u6587\u4ef6BASE64\u7f16\u7801\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public InputStream fileDownLoadWithAbsoluteUrl(String url) throws ServiceException {
+        try {
+            return this.fileStorageManager.fileDownLoadWithAbsoluteUrl(url);
+        }
+        catch (DavinciServiceException e) {
+            this.logger.error("\u4e0b\u8f7d\u6587\u4ef6\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<List<String>> delete(PhotoDelParam param) throws ServiceException {
+        FileRemoveDTO dto = new FileRemoveDTO();
+        dto.setFileList(param.getFilePaths());
+        try {
+            return CloudwalkResult.success((Object)this.fileStorageManager.remove(dto));
+        }
+        catch (DavinciServiceException e) {
+            this.logger.error("\u5220\u9664\u6587\u4ef6\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @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-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/storage/feign/FileManagerFeignClient.java

@@ -0,0 +1,84 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.client.davinci.portal.file.param.RemoveFileParam
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  feign.Response
+ *  org.springframework.stereotype.Component
+ *  org.springframework.web.bind.annotation.RequestBody
+ *  org.springframework.web.bind.annotation.RequestMapping
+ *  org.springframework.web.bind.annotation.RequestMethod
+ *  org.springframework.web.bind.annotation.RequestParam
+ *  org.springframework.web.bind.annotation.RequestPart
+ *  org.springframework.web.multipart.MultipartFile
+ */
+package cn.cloudwalk.service.ninca.visitor.storage.feign;
+
+import cn.cloudwalk.client.davinci.portal.file.param.RemoveFileParam;
+import cn.cloudwalk.cloud.result.CloudwalkResult;
+import cn.cloudwalk.service.ninca.visitor.storage.feign.fallback.AbstractFallback;
+import feign.Response;
+import java.util.List;
+import org.springframework.stereotype.Component;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RequestPart;
+import org.springframework.web.multipart.MultipartFile;
+
+public interface FileManagerFeignClient {
+    public static final String MODULE_CATEGORY = "aiot";
+
+    @RequestMapping(value={"/aiot/fileUpload"}, method={RequestMethod.POST}, consumes={"multipart/form-data"})
+    public CloudwalkResult<String> fileUpload(@RequestPart(value="file") MultipartFile var1);
+
+    @RequestMapping(value={"/aiot/bigFileUpload"}, method={RequestMethod.POST}, consumes={"multipart/form-data"})
+    public CloudwalkResult<String> bigFileUpload(@RequestPart(value="file") MultipartFile var1);
+
+    @RequestMapping(value={"/imgByPath"}, method={RequestMethod.GET})
+    public Response fileDownload(@RequestParam(value="path") String var1);
+
+    @RequestMapping(value={"/aiot/getFileData"}, method={RequestMethod.POST})
+    public CloudwalkResult<String> getFileData(@RequestParam(value="path") String var1);
+
+    @RequestMapping(value={"/remove/images"}, method={RequestMethod.POST})
+    public CloudwalkResult<List<String>> remove(@RequestBody RemoveFileParam var1);
+
+    @Component
+    public static class FileManagerFeignClientFallback
+    extends AbstractFallback
+    implements FileManagerFeignClient {
+        @Override
+        public CloudwalkResult<String> fileUpload(MultipartFile file) {
+            this.logger.error("\u8c03\u7528Davinci-portal\u670d\u52a1\uff0c\u6a21\u5757\u6587\u4ef6\u4e0a\u4f20\u63a5\u53e3\u5f02\u5e38");
+            return CloudwalkResult.fail((String)"76251403", (String)"\u6587\u4ef6\u5b58\u50a8\u5931\u8d25");
+        }
+
+        @Override
+        public CloudwalkResult<String> bigFileUpload(MultipartFile file) {
+            this.logger.error("\u8c03\u7528Davinci-portal\u670d\u52a1\uff0c\u5927\u6587\u4ef6\u4e0a\u4f20\u63a5\u53e3\u5f02\u5e38");
+            return CloudwalkResult.fail((String)"76251403", (String)"\u6587\u4ef6\u5b58\u50a8\u5931\u8d25");
+        }
+
+        @Override
+        public Response fileDownload(String path) {
+            this.logger.error("\u8c03\u7528Davinci-portal\u670d\u52a1\uff0c\u83b7\u53d6\u6587\u4ef6\u6d41\u63a5\u53e3\u5f02\u5e38");
+            return null;
+        }
+
+        @Override
+        public CloudwalkResult<String> getFileData(String path) {
+            this.logger.error("\u8c03\u7528Davinci-portal\u670d\u52a1\uff0c\u83b7\u53d6\u83b7\u53d6\u6587\u4ef6Base64\u5185\u5bb9\u63a5\u53e3\u5f02\u5e38");
+            return null;
+        }
+
+        @Override
+        public CloudwalkResult<List<String>> remove(RemoveFileParam param) {
+            this.logger.error("\u8c03\u7528Davinci-portal\u670d\u52a1\uff0c\u5220\u9664\u6587\u4ef6\u63a5\u53e3\u5f02\u5e38");
+            return null;
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/storage/feign/OuterCallFeignClient.java

@@ -0,0 +1,17 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  feign.RequestLine
+ *  feign.Response
+ */
+package cn.cloudwalk.service.ninca.visitor.storage.feign;
+
+import feign.RequestLine;
+import feign.Response;
+
+public interface OuterCallFeignClient {
+    @RequestLine(value="GET ")
+    public Response downLoad();
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/storage/feign/fallback/AbstractFallback.java

@@ -0,0 +1,32 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  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.visitor.storage.feign.fallback;
+
+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 abstract class AbstractFallback {
+    protected final Logger logger = LoggerFactory.getLogger(this.getClass());
+    @Autowired
+    private MessageSource messageSource;
+
+    public String getMessage(String code, String defaultMsg) {
+        return this.messageSource.getMessage(code, (Object[])null, defaultMsg, LocaleContextHolder.getLocale());
+    }
+
+    public String getMessage(String code) {
+        return this.getMessage(code, "");
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/task/DelExpiredVisitorsTask.java

@@ -0,0 +1,108 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.ninca.visitor.visitor.VisitorManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonDelParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.service.PersonService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.DataAccessException
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.session.company.CompanyContext
+ *  cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorAnalyseDTO
+ *  cn.cloudwalk.common.ninca.visitor.util.CollectionUtils
+ *  com.alibaba.fastjson.JSON
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.beans.factory.annotation.Value
+ *  org.springframework.scheduling.annotation.Scheduled
+ *  org.springframework.stereotype.Component
+ */
+package cn.cloudwalk.service.ninca.visitor.task;
+
+import cn.cloudwalk.biz.ninca.visitor.visitor.VisitorManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonDelParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.service.PersonService;
+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.session.company.CompanyContext;
+import cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorAnalyseDTO;
+import cn.cloudwalk.common.ninca.visitor.util.CollectionUtils;
+import com.alibaba.fastjson.JSON;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+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.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+@Component
+public class DelExpiredVisitorsTask {
+    private Logger logger = LoggerFactory.getLogger(DelExpiredVisitorsTask.class);
+    @Value(value="${del.expired.visitors.cron.businessId}")
+    private String businessId;
+    @Value(value="${sendRecord.boolean}")
+    private Boolean sendBoolean;
+    @Autowired
+    private VisitorManager visitorManager;
+    @Autowired
+    private PersonService personService;
+
+    @Scheduled(cron="${del.expired.visitors.cron:0 0 1 * * ? }")
+    public void execute() {
+        if (!this.sendBoolean.booleanValue()) {
+            return;
+        }
+        this.logger.info("\u5b9a\u65f6\u6e05\u7406\u8fc7\u671f\u8bbf\u5ba2\u5f00\u59cb\uff01");
+        try {
+            VisitorAnalyseDTO analyseDTO = new VisitorAnalyseDTO();
+            Date dateNow = new Date();
+            Date dateBefore = new Date();
+            Calendar cal = Calendar.getInstance();
+            cal.setTime(dateNow);
+            cal.add(5, -1);
+            dateBefore = cal.getTime();
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+            String time1 = sdf.format(dateBefore) + " 00:00:00";
+            Date d1 = sdf.parse(time1);
+            long startTime = d1.getTime();
+            long endTime = startTime + 86399000L;
+            analyseDTO.setStartTime(Long.valueOf(startTime));
+            analyseDTO.setEndTime(Long.valueOf(endTime));
+            this.logger.info("\u67e5\u8be2\u8fc7\u671f\u8bbf\u5ba2\u5165\u53c2\u4e3a\uff1a{}", (Object)JSON.toJSONString((Object)analyseDTO));
+            List expiredVisitorIds = this.visitorManager.getExpiredVisitorIdsByTime(analyseDTO);
+            this.logger.info("\u8fc7\u671f\u8bbf\u5ba2id\u7ed3\u679c\u4e3a\uff1a{}", (Object)JSON.toJSONString((Object)expiredVisitorIds));
+            if (!CollectionUtils.isEmpty((Collection)expiredVisitorIds)) {
+                CloudwalkCallContext context = new CloudwalkCallContext();
+                CompanyContext companyContext = new CompanyContext();
+                companyContext.setCompanyId(this.businessId);
+                context.setCompany(companyContext);
+                PersonDelParam personDelParam = new PersonDelParam();
+                personDelParam.setIds(expiredVisitorIds);
+                CloudwalkResult delete = this.personService.delete(personDelParam, context);
+                this.logger.info("\u6279\u91cf\u5220\u9664\u4eba\u5458\u4fe1\u606f\u7ed3\u679c\u4e3a\uff1a{}", (Object)JSON.toJSONString((Object)delete));
+            }
+        }
+        catch (ParseException e) {
+            this.logger.error("\u83b7\u53d6\u524d\u4e00\u5929\u65f6\u95f4\u6233\u5931\u8d25\uff0c\u539f\u56e0\u662f\uff1a{}", (Throwable)e);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u83b7\u53d6\u8fc7\u671fid\u96c6\u5408\u5931\u8d25\uff0c\u539f\u56e0\u662f\uff1a{}", (Throwable)e);
+        }
+        catch (ServiceException e) {
+            this.logger.error("\u6279\u91cf\u5220\u9664\u4eba\u5458\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0\u662f\uff1a{}", (Throwable)e);
+        }
+        this.logger.info("\u5b9a\u65f6\u6e05\u7406\u8fc7\u671f\u8bbf\u5ba2\u7ed3\u675f\uff01");
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/visitor/VisitorAnalyseServiceImpl.java

@@ -0,0 +1,91 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.ninca.visitor.visitor.VisitorManager
+ *  cn.cloudwalk.client.ninca.visitor.register.param.VisitorAnalyseCycleParam
+ *  cn.cloudwalk.client.ninca.visitor.register.result.VisitorAnalyseCycleBusinessResult
+ *  cn.cloudwalk.client.ninca.visitor.register.result.VisitorAnalyseCycleResult
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorAnalyseCountParam
+ *  cn.cloudwalk.client.ninca.visitor.visitor.service.VisitorAnalyseService
+ *  cn.cloudwalk.cloud.context.CloudwalkCallContext
+ *  cn.cloudwalk.cloud.exception.ServiceException
+ *  cn.cloudwalk.cloud.result.CloudwalkResult
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorAnalyseDTO
+ *  cn.cloudwalk.common.ninca.visitor.util.DateUtils
+ *  cn.cloudwalk.common.ninca.visitor.util.StartTimeAndEndTime
+ *  org.apache.commons.collections4.CollectionUtils
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.stereotype.Service
+ */
+package cn.cloudwalk.service.ninca.visitor.visitor;
+
+import cn.cloudwalk.biz.ninca.visitor.visitor.VisitorManager;
+import cn.cloudwalk.client.ninca.visitor.register.param.VisitorAnalyseCycleParam;
+import cn.cloudwalk.client.ninca.visitor.register.result.VisitorAnalyseCycleBusinessResult;
+import cn.cloudwalk.client.ninca.visitor.register.result.VisitorAnalyseCycleResult;
+import cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorAnalyseCountParam;
+import cn.cloudwalk.client.ninca.visitor.visitor.service.VisitorAnalyseService;
+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.visitor.bean.visitor.dto.VisitorAnalyseDTO;
+import cn.cloudwalk.common.ninca.visitor.util.DateUtils;
+import cn.cloudwalk.common.ninca.visitor.util.StartTimeAndEndTime;
+import cn.cloudwalk.service.ninca.visitor.common.AbstractCloudwalkService;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.apache.commons.collections4.CollectionUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class VisitorAnalyseServiceImpl
+extends AbstractCloudwalkService
+implements VisitorAnalyseService {
+    @Autowired
+    private VisitorManager visitorManager;
+
+    public CloudwalkResult<List<VisitorAnalyseCycleResult>> analyseCycle(VisitorAnalyseCycleParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        List cycleList = DateUtils.getCycle((Integer)param.getTimeType(), (int)7);
+        ArrayList<VisitorAnalyseCycleResult> resultList = new ArrayList<VisitorAnalyseCycleResult>(cycleList.size());
+        try {
+            for (StartTimeAndEndTime startTimeAndEndTime : cycleList) {
+                VisitorAnalyseDTO analyseDTO = new VisitorAnalyseDTO();
+                analyseDTO.setStartTime(startTimeAndEndTime.getStartTime());
+                analyseDTO.setEndTime(startTimeAndEndTime.getEndTime());
+                analyseDTO.setBusinessId(param.getBusinessId());
+                VisitorAnalyseCycleResult result = new VisitorAnalyseCycleResult();
+                result.setCurrentTime(startTimeAndEndTime.getCurrentTime());
+                List analyseGroup = this.visitorManager.analyseGroup(analyseDTO);
+                if (!CollectionUtils.isEmpty((Collection)analyseGroup)) {
+                    List groupResult = BeanCopyUtils.copy((Collection)analyseGroup, VisitorAnalyseCycleBusinessResult.class);
+                    result.setRanking(groupResult.stream().sorted(Comparator.comparing(VisitorAnalyseCycleBusinessResult::getCount).reversed()).collect(Collectors.toList()));
+                }
+                resultList.add(result);
+            }
+            return CloudwalkResult.success(resultList);
+        }
+        catch (Exception e) {
+            this.logger.error("\u5f00\u95e8\u8bb0\u5f55\u7edf\u8ba1\u5206\u6790\u67e5\u8be2\u5931\u8d25,\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<Integer> analyseCount(VisitorAnalyseCountParam param, CloudwalkCallContext cloudwalkContext) throws ServiceException {
+        try {
+            VisitorAnalyseDTO analyseDTO = (VisitorAnalyseDTO)BeanCopyUtils.copyProperties((Object)param, VisitorAnalyseDTO.class);
+            return CloudwalkResult.success((Object)this.visitorManager.analyseCount(analyseDTO));
+        }
+        catch (Exception e) {
+            this.logger.error("\u5f00\u95e8\u8bb0\u5f55\u7edf\u8ba1\u5206\u6790\u67e5\u8be2\u5931\u8d25,\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/cn/cloudwalk/service/ninca/visitor/visitor/VisitorServiceImpl.java

@@ -0,0 +1,988 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  cn.cloudwalk.biz.ninca.visitor.deivce.DeviceDefaultManager
+ *  cn.cloudwalk.biz.ninca.visitor.deivce.DeviceImageStoreManager
+ *  cn.cloudwalk.biz.ninca.visitor.deivce.VisitorDeviceManager
+ *  cn.cloudwalk.biz.ninca.visitor.visitor.VisitorManager
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.application.param.ApplicationImageStoreDelParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.application.service.ApplicationImageStoreService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceApplicationParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceImageStoreParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.param.DeviceQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.result.DeviceResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceApplicationService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceImageStoreService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.elevator.param.AcsPersonAddVisitorParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.elevator.service.ElevatorPersonService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStoreDelParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStorePersonBindParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStorePersonDelParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStoreQueryParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.result.ImageStoreListResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.service.ImageStorePersonService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.service.ImageStoreService
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonAddParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonDelParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonDetailParam
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonEditParam
+ *  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.cwoscomponent.intelligent.user.result.UserAcountDetailResult
+ *  cn.cloudwalk.client.cwoscomponent.intelligent.user.service.UserService
+ *  cn.cloudwalk.client.ninca.visitor.batch.result.BatchImportResult
+ *  cn.cloudwalk.client.ninca.visitor.common.VisitorApplicationService
+ *  cn.cloudwalk.client.ninca.visitor.device.service.VisitorDeviceService
+ *  cn.cloudwalk.client.ninca.visitor.importrecord.param.ImportNewParam
+ *  cn.cloudwalk.client.ninca.visitor.importrecord.param.ImportRecordParam
+ *  cn.cloudwalk.client.ninca.visitor.importrecord.serivce.ImportRecordService
+ *  cn.cloudwalk.client.ninca.visitor.label.VisitorLabelService
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorComplexQueryParam
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorDelParam
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorDeviceAddDeviceParam
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorDeviceAddParam
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorDeviceDelParam
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorDeviceEditParam
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorEditParam
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorGetsParam
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorImportData
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorImportParam
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorNewParam
+ *  cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorQueryParam
+ *  cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorAddResult
+ *  cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorDeviceInfoResult
+ *  cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorDeviceResult
+ *  cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorPageResult
+ *  cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorResult
+ *  cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorResultExcel
+ *  cn.cloudwalk.client.ninca.visitor.visitor.service.VisitorService
+ *  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.ApplicationContextUtils
+ *  cn.cloudwalk.cloud.utils.BeanCopyUtils
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceDefaultGetsDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreDeleteDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreQueryDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreResultDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceGetsDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceResultDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.record.VisitorRecordQueryDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorComplexQueryDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorDelDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorEditDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorGetsDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorNewDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorQueryDTO
+ *  cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorResultDTO
+ *  cn.cloudwalk.common.ninca.visitor.config.VisitorFeignThreadLocalUtil
+ *  cn.cloudwalk.common.ninca.visitor.em.ImageStoreStatusEnum
+ *  cn.cloudwalk.common.ninca.visitor.em.ImportExceptionEnum
+ *  cn.cloudwalk.common.ninca.visitor.em.PersonRoleEnum
+ *  cn.cloudwalk.common.ninca.visitor.em.ValidStatusEnum
+ *  cn.cloudwalk.common.ninca.visitor.em.VisitorRegisterTypeEnum
+ *  cn.cloudwalk.common.ninca.visitor.em.YesNoTypeEnum
+ *  cn.cloudwalk.common.ninca.visitor.util.CollectionUtils
+ *  cn.cloudwalk.common.ninca.visitor.util.DateUtil
+ *  cn.cloudwalk.common.ninca.visitor.util.StringUtils
+ *  cn.cloudwalk.data.ninca.visitor.device.dao.DeviceImageStoreDao
+ *  com.alibaba.fastjson.JSONObject
+ *  com.google.common.collect.Lists
+ *  org.apache.commons.codec.binary.Base64
+ *  org.slf4j.Logger
+ *  org.slf4j.LoggerFactory
+ *  org.springframework.beans.factory.annotation.Autowired
+ *  org.springframework.scheduling.annotation.Async
+ *  org.springframework.stereotype.Service
+ *  org.springframework.transaction.annotation.Propagation
+ *  org.springframework.transaction.annotation.Transactional
+ *  org.springframework.transaction.interceptor.TransactionAspectSupport
+ *  org.springframework.util.Base64Utils
+ *  org.springframework.util.ObjectUtils
+ *  org.springframework.web.bind.annotation.RequestBody
+ */
+package cn.cloudwalk.service.ninca.visitor.visitor;
+
+import cn.cloudwalk.biz.ninca.visitor.deivce.DeviceDefaultManager;
+import cn.cloudwalk.biz.ninca.visitor.deivce.DeviceImageStoreManager;
+import cn.cloudwalk.biz.ninca.visitor.deivce.VisitorDeviceManager;
+import cn.cloudwalk.biz.ninca.visitor.visitor.VisitorManager;
+import cn.cloudwalk.client.cwoscomponent.intelligent.application.param.ApplicationImageStoreDelParam;
+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.DeviceImageStoreParam;
+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.DeviceApplicationService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceImageStoreService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.device.service.DeviceService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.elevator.param.AcsPersonAddVisitorParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.elevator.service.ElevatorPersonService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStoreDelParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStorePersonBindParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.param.ImageStorePersonDelParam;
+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.ImageStorePersonService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.imagestore.service.ImageStoreService;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonAddParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonDelParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonDetailParam;
+import cn.cloudwalk.client.cwoscomponent.intelligent.person.param.PersonEditParam;
+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.cwoscomponent.intelligent.user.result.UserAcountDetailResult;
+import cn.cloudwalk.client.cwoscomponent.intelligent.user.service.UserService;
+import cn.cloudwalk.client.ninca.visitor.batch.result.BatchImportResult;
+import cn.cloudwalk.client.ninca.visitor.common.VisitorApplicationService;
+import cn.cloudwalk.client.ninca.visitor.device.service.VisitorDeviceService;
+import cn.cloudwalk.client.ninca.visitor.importrecord.param.ImportNewParam;
+import cn.cloudwalk.client.ninca.visitor.importrecord.param.ImportRecordParam;
+import cn.cloudwalk.client.ninca.visitor.importrecord.serivce.ImportRecordService;
+import cn.cloudwalk.client.ninca.visitor.label.VisitorLabelService;
+import cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorComplexQueryParam;
+import cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorDelParam;
+import cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorDeviceAddDeviceParam;
+import cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorDeviceAddParam;
+import cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorDeviceDelParam;
+import cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorDeviceEditParam;
+import cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorEditParam;
+import cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorGetsParam;
+import cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorImportData;
+import cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorImportParam;
+import cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorNewParam;
+import cn.cloudwalk.client.ninca.visitor.visitor.param.VisitorQueryParam;
+import cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorAddResult;
+import cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorDeviceInfoResult;
+import cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorDeviceResult;
+import cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorPageResult;
+import cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorResult;
+import cn.cloudwalk.client.ninca.visitor.visitor.result.VisitorResultExcel;
+import cn.cloudwalk.client.ninca.visitor.visitor.service.VisitorService;
+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.ApplicationContextUtils;
+import cn.cloudwalk.cloud.utils.BeanCopyUtils;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceDefaultGetsDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreDeleteDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreQueryDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.DeviceImageStoreResultDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceGetsDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.device.dto.VisitorDeviceResultDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.record.VisitorRecordQueryDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorComplexQueryDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorDelDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorEditDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorGetsDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorNewDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorQueryDTO;
+import cn.cloudwalk.common.ninca.visitor.bean.visitor.dto.VisitorResultDTO;
+import cn.cloudwalk.common.ninca.visitor.config.VisitorFeignThreadLocalUtil;
+import cn.cloudwalk.common.ninca.visitor.em.ImageStoreStatusEnum;
+import cn.cloudwalk.common.ninca.visitor.em.ImportExceptionEnum;
+import cn.cloudwalk.common.ninca.visitor.em.PersonRoleEnum;
+import cn.cloudwalk.common.ninca.visitor.em.ValidStatusEnum;
+import cn.cloudwalk.common.ninca.visitor.em.VisitorRegisterTypeEnum;
+import cn.cloudwalk.common.ninca.visitor.em.YesNoTypeEnum;
+import cn.cloudwalk.common.ninca.visitor.util.CollectionUtils;
+import cn.cloudwalk.common.ninca.visitor.util.DateUtil;
+import cn.cloudwalk.common.ninca.visitor.util.StringUtils;
+import cn.cloudwalk.data.ninca.visitor.device.dao.DeviceImageStoreDao;
+import cn.cloudwalk.service.ninca.visitor.common.AbstractImportService;
+import cn.cloudwalk.service.ninca.visitor.common.job.executable.CleanGroupExpiredVisitorsJob;
+import com.alibaba.fastjson.JSONObject;
+import com.google.common.collect.Lists;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import org.apache.commons.codec.binary.Base64;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.interceptor.TransactionAspectSupport;
+import org.springframework.util.Base64Utils;
+import org.springframework.util.ObjectUtils;
+import org.springframework.web.bind.annotation.RequestBody;
+
+@Service
+public class VisitorServiceImpl
+extends AbstractImportService<VisitorImportData>
+implements VisitorService {
+    private static final Logger LOGGER = LoggerFactory.getLogger(CleanGroupExpiredVisitorsJob.class);
+    @Autowired
+    private VisitorManager visitorManager;
+    @Autowired
+    private VisitorDeviceManager visitorDeviceManager;
+    @Autowired
+    private ImportRecordService importRecordService;
+    @Autowired
+    private PersonService personService;
+    @Autowired
+    private ElevatorPersonService elevatorPersonService;
+    @Autowired
+    private UserService userService;
+    @Autowired
+    private VisitorDeviceService visitorDeviceService;
+    @Autowired
+    private DeviceService deviceService;
+    @Autowired
+    private VisitorLabelService visitorLabelService;
+    @Autowired
+    private DeviceDefaultManager deviceDefaultManager;
+    @Autowired
+    private DeviceApplicationService deviceApplicationService;
+    @Autowired
+    private VisitorApplicationService visitorApplicationService;
+    @Autowired
+    private DeviceImageStoreDao deviceImageStoreDao;
+    @Autowired
+    private DeviceImageStoreService deviceImageStoreService;
+    @Autowired
+    private DeviceImageStoreManager deviceImageStoreManager;
+    @Autowired
+    private ImageStoreService imageStoreService;
+    @Autowired
+    private ApplicationImageStoreService applicationImageStoreService;
+    @Autowired
+    private ImageStorePersonService imageStorePersonService;
+
+    @CloudwalkParamsValidate(argsIndexs={0, 1})
+    @Transactional(propagation=Propagation.REQUIRED, rollbackFor={Exception.class})
+    public CloudwalkResult<VisitorAddResult> add(VisitorNewParam param, CloudwalkCallContext context) throws ServiceException {
+        LOGGER.info("\u6dfb\u52a0\u8bbf\u5ba2\u5f00\u59cb\uff0cVisitorNewParam=[{}], CloudwalkCallContext=[{}]", (Object)JSONObject.toJSONString((Object)param), (Object)JSONObject.toJSONString((Object)context));
+        VisitorAddResult result = new VisitorAddResult();
+        String visitorId = null;
+        try {
+            CloudwalkResult visitorLabelResult;
+            CloudwalkResult page;
+            VisitorNewDTO dto = new VisitorNewDTO();
+            if (null != param.getPersonId()) {
+                PersonResult personResult = this.getPersonInfo(param.getPersonId(), context);
+                param.setPersonId(personResult.getId());
+                param.setPersonName(personResult.getName());
+            }
+            if (!ObjectUtils.isEmpty((Object)param.getIsDevice())) {
+                PersonQueryParam personQueryParam = new PersonQueryParam();
+                personQueryParam.setPhone(param.getTelephone());
+                personQueryParam.setIsVisitor(Integer.valueOf(1));
+                page = this.personService.page(personQueryParam, context);
+                List personList = (List)((CloudwalkPageAble)page.getData()).getDatas();
+                if (!CollectionUtils.isEmpty((Collection)personList)) {
+                    for (PersonResult personResult : personList) {
+                        if (personResult.getIsAcrossDay() != 0) continue;
+                        CloudwalkResult cloudwalkResult = CloudwalkResult.fail((String)"762508031", (String)this.getMessage("762508031"));
+                        return cloudwalkResult;
+                    }
+                }
+            }
+            if (!(visitorLabelResult = this.visitorLabelService.getLabelId(context)).isSuccess()) {
+                page = CloudwalkResult.fail((String)visitorLabelResult.getCode(), (String)visitorLabelResult.getMessage());
+                return page;
+            }
+            if (!ObjectUtils.isEmpty((Object)param.getRegFaceUrl())) {
+                CloudwalkResult cloudwalkResult;
+                byte[] bytes = Base64.decodeBase64((String)param.getRegFaceUrl());
+                try {
+                    bytes = super.resize(bytes);
+                }
+                catch (IOException e) {
+                    this.logger.error("\u56fe\u7247\u538b\u7f29\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+                    cloudwalkResult = CloudwalkResult.fail((String)"762508027", (String)this.getMessage("762508027"));
+                    super.clearTempPath();
+                    return cloudwalkResult;
+                }
+                try {
+                    super.faceFeatureCheck(Base64.encodeBase64String((byte[])bytes), context);
+                }
+                catch (ServiceException e) {
+                    this.logger.error("\u56fe\u7247\u7279\u5f81\u6821\u9a8c\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+                    cloudwalkResult = CloudwalkResult.fail((String)e.getCode(), (String)e.getMessage());
+                    super.clearTempPath();
+                    return cloudwalkResult;
+                }
+                String facePath = super.uploadImg(param.getRegFaceUrl(), context);
+                param.setRegFaceUrl(facePath);
+            }
+            if (!ObjectUtils.isEmpty((Object)param.getDisplayUrl())) {
+                String displayPath = super.uploadImg(param.getDisplayUrl(), context);
+                param.setDisplayUrl(displayPath);
+            }
+            PersonAddParam personAddParam = new PersonAddParam();
+            personAddParam.setComparePicture(param.getRegFaceUrl());
+            personAddParam.setName(param.getName());
+            personAddParam.setUserName(this.genUUID());
+            personAddParam.setExpiryBeginDate(param.getBegVisitorTime());
+            personAddParam.setExpiryEndDate(param.getEndVisitorTime());
+            personAddParam.setLabelIds((List)Lists.newArrayList((Object[])new String[]{(String)visitorLabelResult.getData()}));
+            personAddParam.setShowPicture(param.getDisplayUrl());
+            personAddParam.setWelcome(param.getGreetWord());
+            personAddParam.setPhone(param.getTelephone());
+            personAddParam.setVisitorId(param.getId());
+            CloudwalkResult personAddResult = this.personService.add(personAddParam, context);
+            if (personAddResult.isSuccess()) {
+                CloudwalkResult detail;
+                visitorId = (String)personAddResult.getData();
+                BeanCopyUtils.copyProperties((Object)param, (CloudwalkCallContext)context, (Object)dto);
+                dto.setId(visitorId);
+                dto.setBusinessId(context.getCompany().getCompanyId());
+                dto.setImageStoreStatus(ImageStoreStatusEnum.NORMAL.getCode());
+                dto.setRegType(param.getRegType().getCode());
+                if (!ObjectUtils.isEmpty((Object)param.getDeviceCode())) {
+                    DeviceQueryParam queryParam = new DeviceQueryParam();
+                    queryParam.setDeviceCode(param.getDeviceCode());
+                    CloudwalkResult deviceList = this.deviceService.list(queryParam, context);
+                    dto.setDeviceName(((DeviceResult)((List)deviceList.getData()).get(0)).getDeviceName());
+                }
+                if (!ObjectUtils.isEmpty((Object)param.getOperatorUserId()) && !ObjectUtils.isEmpty((Object)(detail = this.userService.detail(param.getOperatorUserId(), context)).getData())) {
+                    dto.setOperatorUserName(((UserAcountDetailResult)detail.getData()).getName());
+                }
+                try {
+                    this.visitorManager.add(dto);
+                    if (!CollectionUtils.isEmpty((Collection)param.getDeviceIds())) {
+                        this.visitorDeviceAdd(param.getDeviceIds(), visitorId, dto.getName(), param.getRegFaceUrl(), dto.getBegVisitorTime(), dto.getEndVisitorTime(), context);
+                    }
+                    result.setPersonId(visitorId);
+                }
+                catch (DataAccessException e) {
+                    super.cleanTempPhoto(context);
+                    if (StringUtils.isNotBlank((String)visitorId)) {
+                        PersonDelParam personDelParam = new PersonDelParam();
+                        personDelParam.setIds(Collections.singletonList(visitorId));
+                        this.personService.delete(personDelParam, context);
+                    }
+                    this.logger.error("\u65b0\u589e\u8bbf\u5ba2\u5173\u8054\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+                    throw new ServiceException((Throwable)e);
+                }
+            } else {
+                throw new ServiceException(personAddResult.getCode(), personAddResult.getMessage());
+            }
+            AcsPersonAddVisitorParam visitorParam = new AcsPersonAddVisitorParam();
+            visitorParam.setVisitorId(dto.getId());
+            visitorParam.setPersonId(dto.getPersonId());
+            visitorParam.setBegVisitorTime(dto.getBegVisitorTime());
+            visitorParam.setEndVisitorTime(dto.getEndVisitorTime());
+            visitorParam.setFloorIds(param.getFloorIds());
+            this.elevatorPersonService.addVisitor(visitorParam, context);
+            CloudwalkResult cloudwalkResult = CloudwalkResult.success((Object)result);
+            return cloudwalkResult;
+        }
+        catch (ServiceException e) {
+            super.cleanTempPhoto(context);
+            if (StringUtils.isNotBlank(visitorId)) {
+                PersonDelParam personDelParam = new PersonDelParam();
+                personDelParam.setIds(Collections.singletonList(visitorId));
+                this.personService.delete(personDelParam, context);
+            }
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            throw new ServiceException((Throwable)e);
+        }
+        finally {
+            super.clearTempPath();
+        }
+    }
+
+    private PersonResult getPersonInfo(String personId, CloudwalkCallContext context) throws ServiceException {
+        PersonDetailParam personDetailParam = new PersonDetailParam();
+        personDetailParam.setId(personId);
+        CloudwalkResult personResult = this.personService.detail(personDetailParam, context);
+        if (personResult.isSuccess() && personResult.getData() != null) {
+            return (PersonResult)personResult.getData();
+        }
+        throw new ServiceException("762510019", this.getMessage("762510019"));
+    }
+
+    @CloudwalkParamsValidate(argsIndexs={0, 1})
+    @Transactional(propagation=Propagation.REQUIRED, rollbackFor={Exception.class})
+    public CloudwalkResult<Boolean> edit(VisitorEditParam param, CloudwalkCallContext context) throws ServiceException {
+        VisitorEditDTO dto;
+        block30: {
+            VisitorGetsDTO getsDTO = new VisitorGetsDTO();
+            getsDTO.setBusinessId(context.getCompany().getCompanyId());
+            getsDTO.setIds(Collections.singletonList(param.getId()));
+            List resultDTOList = null;
+            VisitorResultDTO visitorResultDTO = null;
+            try {
+                resultDTOList = this.visitorManager.gets(getsDTO);
+                if (CollectionUtils.isEmpty((Collection)resultDTOList)) {
+                    this.logger.error("\u8bbf\u5ba2\u7f16\u8f91\u5931\u8d25\uff0c\u539f\u56e0\uff1a\u8bb0\u5f55\u4e0d\u5b58\u5728");
+                    return CloudwalkResult.fail((String)"762510023", (String)this.getMessage("762510023"));
+                }
+                visitorResultDTO = (VisitorResultDTO)resultDTOList.get(0);
+            }
+            catch (DataAccessException e) {
+                this.logger.error("\u67e5\u8be2\u8bbf\u5ba2\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+                throw new ServiceException((Throwable)e);
+            }
+            dto = new VisitorEditDTO();
+            BeanCopyUtils.copyProperties((Object)param, (CloudwalkCallContext)context, (Object)dto);
+            if (null != param.getPersonId()) {
+                PersonResult personResult = this.getPersonInfo(param.getPersonId(), context);
+                dto.setPersonId(personResult.getId());
+                dto.setPersonName(personResult.getName());
+            }
+            dto.setRegFaceUrl(visitorResultDTO.getRegFaceUrl());
+            dto.setDisplayUrl(visitorResultDTO.getDisplayUrl());
+            if (StringUtils.isNotBlank((String)param.getRegFaceUrl())) {
+                super.faceFeatureCheck(param.getRegFaceUrl(), context);
+                String regPath = super.uploadImg(param.getRegFaceUrl(), context);
+                dto.setRegFaceUrl(regPath);
+            }
+            if (StringUtils.isNotBlank((String)param.getDisplayUrl())) {
+                String displayPath = super.uploadImg(param.getDisplayUrl(), context);
+                dto.setDisplayUrl(displayPath);
+            }
+            if (VisitorRegisterTypeEnum.CARD_REG.getCode().equals(visitorResultDTO.getRegType())) {
+                dto.setName(visitorResultDTO.getName());
+                dto.setCardNo(visitorResultDTO.getCardNo());
+            }
+            dto.setBusinessId(context.getCompany().getCompanyId());
+            dto.setImageStoreStatus(ImageStoreStatusEnum.NORMAL.getCode());
+            CloudwalkResult visitorLabelResult = this.visitorLabelService.getLabelId(context);
+            if (!visitorLabelResult.isSuccess()) {
+                return CloudwalkResult.fail((String)visitorLabelResult.getCode(), (String)visitorLabelResult.getMessage());
+            }
+            try {
+                PersonEditParam personEditParam = new PersonEditParam();
+                personEditParam.setId(dto.getId());
+                personEditParam.setComparePicture(dto.getRegFaceUrl());
+                personEditParam.setName(param.getName());
+                personEditParam.setUserName(this.genUUID());
+                personEditParam.setExpiryBeginDate(param.getBegVisitorTime());
+                personEditParam.setExpiryEndDate(param.getEndVisitorTime());
+                personEditParam.setLabelIds((List)Lists.newArrayList((Object[])new String[]{(String)visitorLabelResult.getData()}));
+                personEditParam.setShowPicture(dto.getDisplayUrl());
+                personEditParam.setWelcome(param.getGreetWord());
+                personEditParam.setPhone(param.getTelephone());
+                CloudwalkResult personEditResult = this.personService.edit(personEditParam, context);
+                if (!personEditResult.isSuccess()) {
+                    CloudwalkResult cloudwalkResult = CloudwalkResult.fail((String)personEditResult.getCode(), (String)personEditResult.getMessage());
+                    return cloudwalkResult;
+                }
+                this.visitorManager.edit(dto);
+                if (dto.getPersonId().equals(visitorResultDTO.getPersonId())) break block30;
+                ImageStoreQueryParam imageStoreQueryParam = new ImageStoreQueryParam();
+                ArrayList<String> personIds = new ArrayList<String>();
+                personIds.add(dto.getId());
+                imageStoreQueryParam.setPersonIds(personIds);
+                CloudwalkResult imageAllList = this.imageStoreService.list(imageStoreQueryParam, context);
+                ArrayList<String> bindImageList = new ArrayList<String>();
+                if (!ObjectUtils.isEmpty((Object)imageAllList) && !CollectionUtils.isEmpty((Collection)((Collection)imageAllList.getData()))) {
+                    for (ImageStoreListResult imageStoreListResult : (List)imageAllList.getData()) {
+                        if (!imageStoreListResult.getName().contains("-\u9ed8\u8ba4\u89c4\u5219")) continue;
+                        bindImageList.add(imageStoreListResult.getId());
+                    }
+                }
+                if (!CollectionUtils.isEmpty(bindImageList)) {
+                    for (String imageId : bindImageList) {
+                        ImageStorePersonDelParam delParam = new ImageStorePersonDelParam();
+                        delParam.setImageStoreId(imageId);
+                        delParam.setPersonId(dto.getId());
+                        CloudwalkResult bindResult = this.imageStorePersonService.delete(delParam, context);
+                        if (bindResult.isSuccess()) continue;
+                        this.logger.error("\u8fdc\u7a0b\u8c03\u7528\u56fe\u5e93\u4eba\u5458\u5220\u9664\u5f02\u5e38\uff0c\u539f\u56e0\uff1a[{}],\u5931\u8d25\u4eba\u5458id:[{}],\u56fe\u5e93id:[{}]", new Object[]{bindResult.getMessage(), dto.getId(), imageId});
+                        CloudwalkResult cloudwalkResult = CloudwalkResult.fail((String)bindResult.getCode(), (String)bindResult.getMessage());
+                        return cloudwalkResult;
+                    }
+                }
+                ImageStoreQueryParam imageStoreQueryParam2 = new ImageStoreQueryParam();
+                ArrayList<String> personIds2 = new ArrayList<String>();
+                personIds2.add(param.getPersonId());
+                imageStoreQueryParam2.setPersonIds(personIds2);
+                CloudwalkResult imageAllList2 = this.imageStoreService.list(imageStoreQueryParam2, context);
+                ArrayList<String> bindImageList2 = new ArrayList<String>();
+                if (!ObjectUtils.isEmpty((Object)imageAllList2) && !CollectionUtils.isEmpty((Collection)((Collection)imageAllList2.getData()))) {
+                    for (ImageStoreListResult imageStoreListResult : (List)imageAllList2.getData()) {
+                        if (!imageStoreListResult.getName().contains("-\u9ed8\u8ba4\u89c4\u5219")) continue;
+                        bindImageList2.add(imageStoreListResult.getId());
+                    }
+                }
+                if (CollectionUtils.isEmpty(bindImageList2)) break block30;
+                for (String imageId : bindImageList2) {
+                    ImageStorePersonBindParam bindParam = new ImageStorePersonBindParam();
+                    bindParam.setImageStoreId(imageId);
+                    bindParam.setPersonId(dto.getId());
+                    bindParam.setExpiryBeginDate(dto.getBegVisitorTime());
+                    bindParam.setExpiryEndDate(dto.getEndVisitorTime());
+                    CloudwalkResult bindResult = this.imageStorePersonService.bind(bindParam, context);
+                    if (bindResult.isSuccess()) continue;
+                    this.logger.error("\u8fdc\u7a0b\u8c03\u7528\u7ed1\u5b9a\u4eba\u5458\u56fe\u5e93\u5f02\u5e38\uff0c\u539f\u56e0\uff1a[{}],\u5931\u8d25\u4eba\u5458id:[{}],\u56fe\u5e93id:[{}]", new Object[]{bindResult.getMessage(), dto.getId(), imageId});
+                    CloudwalkResult cloudwalkResult = CloudwalkResult.fail((String)bindResult.getCode(), (String)bindResult.getMessage());
+                    return cloudwalkResult;
+                }
+            }
+            catch (DataAccessException e) {
+                this.logger.error("\u66f4\u65b0\u8bbf\u5ba2\u5173\u8054\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+                super.cleanTempPhoto(context);
+                throw new ServiceException((Throwable)e);
+            }
+            finally {
+                super.clearTempPath();
+            }
+        }
+        if (!CollectionUtils.isEmpty((Collection)param.getDeviceIds())) {
+            VisitorDeviceGetsDTO visitorDeviceGetsDTO = new VisitorDeviceGetsDTO();
+            visitorDeviceGetsDTO.setVisitorId(param.getId());
+            visitorDeviceGetsDTO.setBusinessId(context.getCompany().getCompanyId());
+            List visitorDeviceResult = null;
+            try {
+                visitorDeviceResult = this.visitorDeviceManager.gets(visitorDeviceGetsDTO);
+            }
+            catch (DataAccessException e) {
+                this.logger.error("\u67e5\u8be2\u8bbf\u5ba2\u8bbe\u5907\u5173\u8054\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+                super.cleanTempPhoto(context);
+                throw new ServiceException((Throwable)e);
+            }
+            finally {
+                super.clearTempPath();
+            }
+            List devInDbList = visitorDeviceResult.stream().map(VisitorDeviceResultDTO::getDeviceId).collect(Collectors.toList());
+            ArrayList devAddList = Lists.newArrayList((Iterable)param.getDeviceIds());
+            devAddList.removeAll(devInDbList);
+            ArrayList devDelList = Lists.newArrayList(devInDbList);
+            devDelList.removeAll(param.getDeviceIds());
+            ArrayList devEditList = Lists.newArrayList(devInDbList);
+            devEditList.removeAll(devDelList);
+            this.visitorDeviceAdd(devAddList, param.getId(), dto.getName(), dto.getRegFaceUrl(), dto.getBegVisitorTime(), dto.getEndVisitorTime(), context);
+            this.visitorDeviceEdit(devEditList, param.getId(), dto.getName(), dto.getRegFaceUrl(), dto.getBegVisitorTime(), dto.getEndVisitorTime(), context);
+            this.visitorDeviceDel(devDelList, param.getId(), context);
+        }
+        return CloudwalkResult.success((Object)true);
+    }
+
+    private void visitorDeviceAdd(List<String> deviceIds, String visitorId, String visitorName, String facePath, Long expiryBeginDate, Long expiryEndDate, CloudwalkCallContext context) throws ServiceException {
+        for (String deviceId : deviceIds) {
+            VisitorDeviceAddParam visitorDeviceAddParam = new VisitorDeviceAddParam();
+            visitorDeviceAddParam.setDeviceId(deviceId);
+            visitorDeviceAddParam.setVisitorId(visitorId);
+            visitorDeviceAddParam.setVisitorName(visitorName);
+            visitorDeviceAddParam.setFacePath(facePath);
+            visitorDeviceAddParam.setExpiryBeginDate(expiryBeginDate);
+            visitorDeviceAddParam.setExpiryEndDate(expiryEndDate);
+            this.visitorDeviceService.add(visitorDeviceAddParam, context);
+        }
+    }
+
+    private void visitorDeviceEdit(List<String> deviceIds, String visitorId, String visitorName, String facePath, Long expiryBeginDate, Long expiryEndDate, CloudwalkCallContext context) throws ServiceException {
+        VisitorDeviceEditParam visitorDeviceEditParam = new VisitorDeviceEditParam();
+        visitorDeviceEditParam.setDeviceIds(deviceIds);
+        visitorDeviceEditParam.setVisitorId(visitorId);
+        visitorDeviceEditParam.setVisitorName(visitorName);
+        visitorDeviceEditParam.setFacePath(facePath);
+        visitorDeviceEditParam.setExpiryBeginDate(expiryBeginDate);
+        visitorDeviceEditParam.setExpiryEndDate(expiryEndDate);
+        this.visitorDeviceService.edit(visitorDeviceEditParam, context);
+    }
+
+    private void visitorDeviceDel(List<String> deviceIds, String visitorId, CloudwalkCallContext context) throws ServiceException {
+        VisitorDeviceDelParam visitorDeviceAddParam = new VisitorDeviceDelParam();
+        visitorDeviceAddParam.setDeviceIds(deviceIds);
+        visitorDeviceAddParam.setVisitorId(visitorId);
+        this.visitorDeviceService.delete(visitorDeviceAddParam, context);
+    }
+
+    public CloudwalkResult<List<VisitorResult>> gets(VisitorGetsParam param, CloudwalkCallContext context) throws ServiceException {
+        VisitorGetsDTO dto = new VisitorGetsDTO();
+        dto.setIds(param.getIds());
+        dto.setBusinessId(context.getCompany().getCompanyId());
+        try {
+            List resultDtoList = this.visitorManager.gets(dto);
+            return CloudwalkResult.success((Object)BeanCopyUtils.copy((Collection)resultDtoList, VisitorResult.class));
+        }
+        catch (DataAccessException e) {
+            this.logger.warn("\u83b7\u53d6\u8bbf\u5ba2\u5173\u8054\u4fe1\u606f\u5931\u8d25,\u9519\u8bef\u4fe1\u606f\uff1a{}", (Object)e.getMessage());
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<List<VisitorDeviceResult>> getsIncludeDeviceInfo(VisitorGetsParam param, CloudwalkCallContext context) throws ServiceException {
+        ArrayList<VisitorDeviceResult> resultList = new ArrayList<VisitorDeviceResult>();
+        VisitorGetsDTO dto = new VisitorGetsDTO();
+        dto.setIds(param.getIds());
+        dto.setBusinessId(context.getCompany().getCompanyId());
+        try {
+            List resultDtoList = this.visitorManager.gets(dto);
+            if (CollectionUtils.isNotEmpty((Collection)resultDtoList)) {
+                for (VisitorResultDTO visitorResultDTO : resultDtoList) {
+                    VisitorDeviceResult visitorDeviceResult = (VisitorDeviceResult)BeanCopyUtils.copyProperties((Object)visitorResultDTO, VisitorDeviceResult.class);
+                    visitorDeviceResult.setRegFacePath(visitorResultDTO.getRegFaceUrl());
+                    VisitorDeviceGetsDTO visitorDeviceGetsDTO = new VisitorDeviceGetsDTO();
+                    visitorDeviceGetsDTO.setBusinessId(context.getCompany().getCompanyId());
+                    visitorDeviceGetsDTO.setVisitorId(visitorResultDTO.getId());
+                    List visitorDeviceResultDTOList = this.visitorDeviceManager.gets(visitorDeviceGetsDTO);
+                    List deviceIds = visitorDeviceResultDTOList.stream().map(VisitorDeviceResultDTO::getDeviceId).collect(Collectors.toList());
+                    if (CollectionUtils.isNotEmpty(deviceIds)) {
+                        DeviceQueryParam deviceQueryParam = new DeviceQueryParam();
+                        deviceQueryParam.setIds(deviceIds);
+                        Map<String, String> areaMap = this.getDeviceAreaMap(context);
+                        CloudwalkResult deviceResult = this.deviceService.list(deviceQueryParam, context);
+                        if (deviceResult.isSuccess()) {
+                            ArrayList<VisitorDeviceInfoResult> visitorDeviceInfoList = new ArrayList<VisitorDeviceInfoResult>();
+                            for (DeviceResult device : (List)deviceResult.getData()) {
+                                VisitorDeviceInfoResult visitorDeviceInfoResult = new VisitorDeviceInfoResult();
+                                visitorDeviceInfoResult.setDeviceId(device.getId());
+                                visitorDeviceInfoResult.setDeviceName(device.getDeviceName());
+                                visitorDeviceInfoResult.setDeviceAreaName(areaMap.get(device.getAreaId()));
+                                visitorDeviceInfoList.add(visitorDeviceInfoResult);
+                            }
+                            visitorDeviceResult.setDeviceInfo(visitorDeviceInfoList);
+                        } else {
+                            return CloudwalkResult.fail((String)deviceResult.getCode(), (String)deviceResult.getMessage());
+                        }
+                    }
+                    resultList.add(visitorDeviceResult);
+                }
+            }
+            return CloudwalkResult.success(resultList);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u83b7\u53d6\u8bbf\u5ba2\u5173\u8054\u4fe1\u606f\u5931\u8d25,\u9519\u8bef\u4fe1\u606f\uff1a{}", (Object)e.getMessage());
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<CloudwalkPageAble<VisitorPageResult>> page(VisitorComplexQueryParam param, CloudwalkPageInfo page, CloudwalkCallContext context) throws ServiceException {
+        this.logger.info("\u5206\u9875\u67e5\u8be2\u8bbf\u5ba2\u4fe1\u606f\u5165\u53c2\uff1a{}", (Object)JSONObject.toJSONString((Object)param));
+        try {
+            List results = new ArrayList();
+            VisitorComplexQueryDTO dto = (VisitorComplexQueryDTO)BeanCopyUtils.copyProperties((Object)param, VisitorComplexQueryDTO.class);
+            dto.setBusinessId(context.getCompany().getCompanyId());
+            if (CollectionUtils.isEmpty((Collection)param.getDeviceIds()) && (CollectionUtils.isNotEmpty((Collection)param.getDistrictIds()) || CollectionUtils.isNotEmpty((Collection)param.getAreaIds()))) {
+                CloudwalkResult deviceResult;
+                DeviceQueryParam deviceQueryParam = new DeviceQueryParam();
+                if (CollectionUtils.isNotEmpty((Collection)param.getDistrictIds())) {
+                    deviceQueryParam.setDistrictIds(param.getDistrictIds());
+                }
+                if (CollectionUtils.isNotEmpty((Collection)param.getAreaIds())) {
+                    deviceQueryParam.setAreaIds(param.getAreaIds());
+                }
+                if ((deviceResult = this.deviceService.list(deviceQueryParam, context)).isSuccess()) {
+                    if (CollectionUtils.isEmpty((Collection)((Collection)deviceResult.getData()))) {
+                        return CloudwalkResult.success((Object)new CloudwalkPageAble(results, page, 0L));
+                    }
+                    List deviceIds = ((List)deviceResult.getData()).stream().map(DeviceResult::getId).collect(Collectors.toList());
+                    dto.setDeviceIds(deviceIds);
+                } else {
+                    return CloudwalkResult.fail((String)deviceResult.getCode(), (String)deviceResult.getMessage());
+                }
+            }
+            if (!param.isFromOpen() && !super.validCurrentUserRole(context, PersonRoleEnum.CORP_ADMIN, PersonRoleEnum.BUSINESS_ADMIN)) {
+                dto.setPersonId(super.gerCurrentUserPersonId(context));
+                dto.setCreateUserId(context.getUser().getCaller());
+            }
+            CloudwalkPageAble cloudwalkResult = null;
+            cloudwalkResult = this.visitorManager.page(dto, page);
+            this.logger.info("\u5206\u9875\u4fe1\u606f\u4e3a\uff1a{}", JSONObject.toJSON((Object)cloudwalkResult));
+            results = BeanCopyUtils.copy((Collection)cloudwalkResult.getDatas(), VisitorPageResult.class);
+            this.logger.info("\u8fd4\u56de\u7684\u5206\u9875\u4fe1\u606f\u4e3a\uff1a{}", JSONObject.toJSON(results));
+            for (VisitorPageResult result : results) {
+                long now = DateUtil.getTimeMillis();
+                if (result.getBegVisitorTime() > now) {
+                    result.setValidStatus(ValidStatusEnum.NOT_EFFECTIVE.getCode());
+                    result.setValidStatusDesc(ValidStatusEnum.NOT_EFFECTIVE.getMessage());
+                    continue;
+                }
+                if (result.getBegVisitorTime() <= now && result.getEndVisitorTime() >= now) {
+                    result.setValidStatus(ValidStatusEnum.EFFECTIVE.getCode());
+                    result.setValidStatusDesc(ValidStatusEnum.EFFECTIVE.getMessage());
+                    continue;
+                }
+                if (result.getEndVisitorTime() >= now) continue;
+                result.setValidStatus(ValidStatusEnum.OVERDUE.getCode());
+                result.setValidStatusDesc(ValidStatusEnum.OVERDUE.getMessage());
+            }
+            return CloudwalkResult.success((Object)new CloudwalkPageAble(results, page, cloudwalkResult.getTotalRows()));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u8bbf\u5ba2\u4eba\u5458\u5206\u9875\u67e5\u8be2\u5931\u8d25\uff0c\u539f\u56e0:", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    @CloudwalkParamsValidate(argsIndexs={0, 1})
+    @Transactional(propagation=Propagation.REQUIRED, rollbackFor={Exception.class})
+    public CloudwalkResult<Boolean> delete(VisitorDelParam param, CloudwalkCallContext context) throws ServiceException, DataAccessException {
+        ArrayList<String> devicesIds = new ArrayList<String>();
+        for (String id2 : param.getIds()) {
+            VisitorDeviceGetsDTO visitorDeviceGetsDTO = new VisitorDeviceGetsDTO();
+            visitorDeviceGetsDTO.setBusinessId(context.getCompany().getCompanyId());
+            visitorDeviceGetsDTO.setVisitorId(id2);
+            List visitorDeviceResultDTOList = this.visitorDeviceManager.gets(visitorDeviceGetsDTO);
+            List<String> deviceIds = visitorDeviceResultDTOList.stream().map(VisitorDeviceResultDTO::getDeviceId).collect(Collectors.toList());
+            devicesIds.addAll(deviceIds);
+            this.visitorDeviceDel(deviceIds, id2, context);
+        }
+        PersonDelParam personDelParam = new PersonDelParam();
+        personDelParam.setIds(param.getIds());
+        this.personService.delete(personDelParam, context);
+        VisitorDelDTO dto = new VisitorDelDTO();
+        dto.setIds(param.getIds());
+        dto.setBusinessId(context.getCompany().getCompanyId());
+        dto.setImageStoreStatus(ImageStoreStatusEnum.DELETED.getCode());
+        this.visitorManager.delete(dto);
+        devicesIds.forEach(id -> this.checkIsBind((String)id, context));
+        return CloudwalkResult.success((Object)true);
+    }
+
+    @Async
+    public CloudwalkResult<Boolean> batchImport(VisitorImportParam param, Map<String, String> headerMap, CloudwalkCallContext context) throws ServiceException, DataAccessException {
+        VisitorFeignThreadLocalUtil.setRequestHeader(headerMap);
+        int execNum = 0;
+        BatchImportResult importResult = new BatchImportResult();
+        ArrayList importRecords = Lists.newArrayList();
+        try {
+            List importDatas;
+            importResult = this.parseImportedFiles(param.getFileName(), param.getFilePath(), VisitorImportData.class);
+            if (importResult.isSuccess() && CollectionUtils.isNotEmpty((Collection)(importDatas = importResult.getImportDatas()))) {
+                Map<String, Long> nameCountMap = importDatas.stream().collect(Collectors.groupingBy(VisitorImportData::getName, Collectors.counting()));
+                int startLine = 2;
+                for (VisitorImportData importData : importDatas) {
+                    ImportRecordParam recordParam = new ImportRecordParam();
+                    recordParam.setLineNum(Integer.valueOf(++startLine));
+                    if (this.importDataValidate(importData, nameCountMap, recordParam) && this.addVistor(importData, param, recordParam, context)) {
+                        ++execNum;
+                        continue;
+                    }
+                    importRecords.add(recordParam);
+                }
+            }
+        }
+        catch (Exception e) {
+            this.logger.error("\u672a\u77e5\u5f02\u5e38,{}", (Object)e.getMessage());
+            importResult.setRemark(ImportExceptionEnum.UNKONWN_EXCEPTION.getMessage());
+        }
+        importResult.setExecNum(Integer.valueOf(execNum));
+        importResult.setImportRecords((List)importRecords);
+        ImportNewParam importNewParam = (ImportNewParam)BeanCopyUtils.copyProperties((Object)importResult, ImportNewParam.class);
+        this.importRecordService.add(importNewParam, context);
+        return CloudwalkResult.success((Object)true);
+    }
+
+    private boolean importDataValidate(VisitorImportData importData, Map<String, Long> nameCountMap, ImportRecordParam recordParam) {
+        String name = importData.getName();
+        if (StringUtils.isBlank((String)name)) {
+            recordParam.setInfo(ImportExceptionEnum.REQUIRED.getMessage());
+            return false;
+        }
+        recordParam.setKeyWord(name.length() < 64 ? name : name.substring(0, 64));
+        if (nameCountMap.get(name) > 1L) {
+            recordParam.setInfo(ImportExceptionEnum.DUPLICATION_NAME.getMessage());
+            return false;
+        }
+        if (super.getImg(name) == null) {
+            recordParam.setInfo(ImportExceptionEnum.NO_IMG.getMessage());
+            return false;
+        }
+        return true;
+    }
+
+    private boolean addVistor(VisitorImportData importData, VisitorImportParam param, ImportRecordParam recordParam, CloudwalkCallContext context) {
+        String base64 = Base64Utils.encodeToString((byte[])((byte[])super.getImg(importData.getName())));
+        VisitorNewParam visitorNewParam = new VisitorNewParam();
+        BeanCopyUtils.copyProperties((Object)importData, (Object)visitorNewParam);
+        visitorNewParam.setRegFaceUrl(base64);
+        visitorNewParam.setDeviceIds(param.getDeviceIds());
+        visitorNewParam.setBegVisitorTime(param.getBegVisitorTime());
+        visitorNewParam.setEndVisitorTime(param.getEndVisitorTime());
+        visitorNewParam.setPersonId(param.getPersonId());
+        visitorNewParam.setPersonName(param.getPersonName());
+        visitorNewParam.setRegType(VisitorRegisterTypeEnum.BACKSTAGE);
+        try {
+            VisitorService visitorService = (VisitorService)ApplicationContextUtils.getBean(VisitorService.class);
+            CloudwalkResult addResult = visitorService.add(visitorNewParam, context);
+            if (!addResult.isSuccess()) {
+                recordParam.setInfo(ImportExceptionEnum.SAVE_FAIL.getMessage());
+                return false;
+            }
+        }
+        catch (ServiceException e) {
+            recordParam.setInfo(e.getMessage());
+            return false;
+        }
+        catch (Exception e) {
+            recordParam.setInfo(ImportExceptionEnum.SAVE_FAIL.getMessage());
+            return false;
+        }
+        return true;
+    }
+
+    public List<VisitorResultExcel> queryVisitorResultExcel(@RequestBody VisitorComplexQueryParam param, CloudwalkCallContext context) throws ServiceException, DataAccessException {
+        CloudwalkPageAble cloudwalkPageAble;
+        List<Object> visitorResultExcels = new ArrayList<VisitorResultExcel>();
+        CloudwalkPageInfo page = new CloudwalkPageInfo(1, 500);
+        CloudwalkResult<CloudwalkPageAble<VisitorPageResult>> pageAbleCloudwalkResult = this.page(param, page, context);
+        if (pageAbleCloudwalkResult != null && (cloudwalkPageAble = (CloudwalkPageAble)pageAbleCloudwalkResult.getData()) != null) {
+            List visitorPageResults = (List)cloudwalkPageAble.getDatas();
+            visitorResultExcels = BeanCopyUtils.copy((Collection)visitorPageResults, VisitorResultExcel.class);
+        }
+        return visitorResultExcels;
+    }
+
+    public CloudwalkResult<CloudwalkPageAble<VisitorResult>> expired(VisitorQueryParam param, CloudwalkPageInfo pageInfo, CloudwalkCallContext context) throws ServiceException {
+        VisitorQueryDTO dto = (VisitorQueryDTO)BeanCopyUtils.copyProperties((Object)param, VisitorQueryDTO.class);
+        try {
+            CloudwalkPageAble result = this.visitorManager.expired(dto, pageInfo);
+            List visitorResultList = BeanCopyUtils.copy((Collection)result.getDatas(), VisitorResult.class);
+            return CloudwalkResult.success((Object)new CloudwalkPageAble((Collection)visitorResultList, pageInfo, result.getTotalRows()));
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u67e5\u8be2\u5931\u6548\u8bbf\u5ba2\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public CloudwalkResult<Boolean> deviceAdd(VisitorDeviceAddDeviceParam param, CloudwalkCallContext context) throws ServiceException {
+        VisitorGetsDTO visitorGetsDTO = new VisitorGetsDTO();
+        visitorGetsDTO.setIds(param.getPersonIds());
+        visitorGetsDTO.setBusinessId(context.getCompany().getCompanyId());
+        visitorGetsDTO.setIsDelete(YesNoTypeEnum.N.getCode());
+        try {
+            List visitors = this.visitorManager.gets(visitorGetsDTO);
+            for (VisitorResultDTO visitor : visitors) {
+                VisitorDeviceGetsDTO visitorDeviceGetsDTO = new VisitorDeviceGetsDTO();
+                visitorDeviceGetsDTO.setVisitorId(visitor.getId());
+                visitorDeviceGetsDTO.setBusinessId(context.getCompany().getCompanyId());
+                List visitorDeviceResult = null;
+                try {
+                    visitorDeviceResult = this.visitorDeviceManager.gets(visitorDeviceGetsDTO);
+                }
+                catch (DataAccessException e) {
+                    this.logger.error("\u67e5\u8be2\u8bbf\u5ba2\u8bbe\u5907\u5173\u8054\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+                    throw new ServiceException((Throwable)e);
+                }
+                List devInDbList = visitorDeviceResult.stream().map(VisitorDeviceResultDTO::getDeviceId).collect(Collectors.toList());
+                ArrayList devAddList = Lists.newArrayList((Iterable)param.getDeviceIds());
+                devAddList.removeAll(devInDbList);
+                this.visitorDeviceAdd(devAddList, visitor.getId(), visitor.getName(), visitor.getRegFaceUrl(), visitor.getBegVisitorTime(), visitor.getEndVisitorTime(), context);
+            }
+            return CloudwalkResult.success((Object)true);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u67e5\u8be2\u8bbf\u5ba2\u4fe1\u606f\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new ServiceException((Throwable)e);
+        }
+    }
+
+    public List<String> listIdsByTime(VisitorRecordQueryDTO dto) throws DataAccessException {
+        try {
+            return this.visitorManager.listIdsByTime(dto);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u6839\u636e\u65f6\u95f4\u83b7\u53d6\u8bbf\u5ba2ids\u5931\u8d25\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+            throw new DataAccessException((Throwable)e);
+        }
+    }
+
+    private void checkIsBind(String deviceId, CloudwalkCallContext context) {
+        try {
+            DeviceDefaultGetsDTO deviceDefaultGetsDTO = new DeviceDefaultGetsDTO();
+            deviceDefaultGetsDTO.setBusinessId(context.getCompany().getCompanyId());
+            List defaultDevices = this.deviceDefaultManager.gets(deviceDefaultGetsDTO);
+            HashSet defaultDeviceIds = new HashSet(defaultDevices.size());
+            defaultDevices.forEach(ele -> defaultDeviceIds.add(ele.getDeviceId()));
+            if (!defaultDeviceIds.contains(deviceId)) {
+                this.logger.info("{}\u4e0d\u662f\u9ed8\u8ba4\u8bbe\u5907", (Object)deviceDefaultGetsDTO);
+                VisitorDeviceGetsDTO visitorDeviceGetsDTO = new VisitorDeviceGetsDTO();
+                visitorDeviceGetsDTO.setBusinessId(context.getCompany().getCompanyId());
+                visitorDeviceGetsDTO.setDeviceId(deviceId);
+                List deviceVistors = this.visitorDeviceManager.gets(visitorDeviceGetsDTO);
+                this.logger.info("\u8bbe\u5907{}\u4e0b\u7684\u8bbf\u5ba2\u6570\u91cf\u4e3a{}", (Object)deviceId, (Object)deviceVistors.size());
+                if (!CollectionUtils.isEmpty((Collection)deviceVistors)) {
+                    ArrayList visitorIds = new ArrayList(deviceVistors.size());
+                    deviceVistors.forEach(ele -> visitorIds.add(ele.getVisitorId()));
+                    VisitorGetsDTO visitorGetsDTO = new VisitorGetsDTO();
+                    visitorGetsDTO.setBusinessId(context.getCompany().getCompanyId());
+                    visitorGetsDTO.setIds(visitorIds);
+                    List imgStoreNormal = this.visitorManager.gets(visitorGetsDTO);
+                    HashMap<String, Integer> imgStatus = new HashMap<String, Integer>(imgStoreNormal.size());
+                    imgStoreNormal.forEach(ele -> imgStatus.put(ele.getId(), ele.getImageStoreStatus()));
+                    VisitorDeviceGetsDTO visitorDeviceGetByDevice = new VisitorDeviceGetsDTO();
+                    visitorDeviceGetByDevice.setBusinessId(context.getCompany().getCompanyId());
+                    visitorDeviceGetByDevice.setDeviceId(deviceId);
+                    if (!this.needDelBind(imgStatus, visitorDeviceGetByDevice)) {
+                        this.logger.info("{}\u8bbe\u5907\u4e0d\u9700\u89e3\u7ed1\uff0c\u6709\u672a\u8fc7\u671f\u4eba\u5458", (Object)deviceId);
+                        return;
+                    }
+                }
+                this.logger.info("{}\u8bbe\u5907\u9700\u89e3\u7ed1\u5e94\u7528", (Object)deviceId);
+                DeviceImageStoreQueryDTO dto = new DeviceImageStoreQueryDTO();
+                dto.setBusinessId(context.getCompany().getCompanyId());
+                dto.setDeviceId(deviceId);
+                DeviceImageStoreResultDTO deviceImageStoreResultDTO = this.deviceImageStoreDao.queryByDeviceId(dto);
+                DeviceImageStoreParam param = new DeviceImageStoreParam();
+                param.setDeviceId(deviceId);
+                param.setImageStoreId(deviceImageStoreResultDTO.getImageStoreId());
+                CloudwalkResult isDeleteImg = this.deviceImageStoreService.delete(param, null);
+                CloudwalkResult isDeleteApp = null;
+                String applicationId = null;
+                if ("00000000".equals(isDeleteImg.getCode())) {
+                    this.logger.info("\u89e3\u9664\u8bbe\u5907\u5e94\u7528\u7ed1\u5b9a{}{}{}", new Object[]{isDeleteImg.getMessage(), deviceId, deviceImageStoreResultDTO.getImageStoreId()});
+                    applicationId = this.visitorApplicationService.getApplicationId(context.getCompany().getCompanyId());
+                    DeviceApplicationParam deviceImageStoreParam = new DeviceApplicationParam();
+                    deviceImageStoreParam.setDeviceId(deviceId);
+                    deviceImageStoreParam.setApplicationId(applicationId);
+                    isDeleteApp = this.deviceApplicationService.delete(deviceImageStoreParam, null);
+                }
+                if ("00000000".equals(isDeleteApp.getCode())) {
+                    this.logger.info("\u89e3\u9664\u56fe\u5e93\u548c\u5e94\u7528\u7684\u5173\u7cfb");
+                    ApplicationImageStoreDelParam delParam = new ApplicationImageStoreDelParam();
+                    delParam.setApplicationId(applicationId);
+                    delParam.setImageStoreId(deviceImageStoreResultDTO.getImageStoreId());
+                    this.applicationImageStoreService.delete(delParam, context);
+                    this.logger.info("\u5220\u9664\u56fe\u5e93");
+                    ImageStoreDelParam imageStoreDelParam = new ImageStoreDelParam();
+                    imageStoreDelParam.setId(deviceImageStoreResultDTO.getImageStoreId());
+                    CloudwalkResult delete = this.imageStoreService.delete(imageStoreDelParam, context);
+                    DeviceImageStoreDeleteDTO deviceImageStoreDeleteDTO = new DeviceImageStoreDeleteDTO();
+                    deviceImageStoreDeleteDTO.setBusinessId(context.getCompany().getCompanyId());
+                    deviceImageStoreDeleteDTO.setDeviceId(deviceId);
+                    this.deviceImageStoreManager.deleteByDeviceId(deviceImageStoreDeleteDTO);
+                }
+            }
+        }
+        catch (DataAccessException | ServiceException e) {
+            this.logger.info("\u68c0\u67e5\u8bbe\u5907{}\u662f\u5426\u9700\u8981\u89e3\u7ed1\u51fa\u9519", (Object)deviceId, (Object)e);
+        }
+    }
+
+    private boolean needDelBind(Map<String, Integer> imgStatus, VisitorDeviceGetsDTO visitorDeviceGetByDevice) {
+        List visitorIds = null;
+        try {
+            visitorIds = this.visitorDeviceManager.gets(visitorDeviceGetByDevice);
+        }
+        catch (DataAccessException e) {
+            this.logger.error("\u8bbf\u5ba2\u8bbe\u5907\u67e5\u8be2\u5f02\u5e38\uff0c\u539f\u56e0\uff1a", (Throwable)e);
+        }
+        if (CollectionUtils.isNotEmpty((Collection)visitorIds)) {
+            for (VisitorDeviceResultDTO visitorDeviceResultDTO : visitorIds) {
+                if (!imgStatus.containsKey(visitorDeviceResultDTO.getVisitorId()) || !ImageStoreStatusEnum.NORMAL.getCode().equals(imgStatus.get(visitorDeviceResultDTO.getVisitorId()))) continue;
+                this.logger.info("{}\u672a\u8fc7\u671f", (Object)visitorDeviceResultDTO.getVisitorId());
+                return false;
+            }
+        }
+        return true;
+    }
+}
+

maven-ninca-crk-from-lib/ninca-crk-visitor-management-service/src/main/java/summary.txt

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