保安员新增，导入，报名修改，修改为定时响应

Administrator

2022-06-09 f2d47fa3543738676e27c5a11b975f0d6a7fee6f

保安员新增，导入，报名修改，修改为定时响应

 src/main/java/org/springblade/common/config/AsyncConfig.java

@@ -25,7 +25,7 @@
        //核心线程数
        executor.setCorePoolSize(4);
        //最大线程数
        executor.setMaxPoolSize(6);
        executor.setMaxPoolSize(10);
        //队列大小
        executor.setQueueCapacity(1000);
        //线程最大空闲时间

 src/main/java/org/springblade/modules/quartz/task/Task.java

@@ -10,6 +10,7 @@
import org.springblade.modules.system.entity.User;
import org.springblade.modules.system.service.IUserService;
import org.springblade.modules.system.service.MyAsyncService;
import org.springblade.modules.training.entity.TrainingRegistration;
import org.springblade.modules.training.service.TrainingRegistrationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
@@ -21,6 +22,7 @@
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;

import static org.springblade.common.config.FtpConfig.*;
import static org.springblade.common.config.FtpConfig.ftpPath;
@@ -118,7 +120,6 @@
                    String fileName = files[i].getName();
                    System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"：读取到文件 = " + fileName);
                    if (fileName.contains("nq")) {
//                        InputStream is = ftp.retrieveFileStream(new String(fileName.getBytes("GBK"), FTP.DEFAULT_CONTROL_ENCODING));
                        //把文件下载到本地
                        long l = System.currentTimeMillis();
                        FtpUtil.downloadFtpFile(ftpHost, ftpUserNameIn, ftpPasswordIn, ftpPort, ftpPath, localPath, fileName);
@@ -277,7 +278,7 @@
    }

    /**
     * 读取内外推送的保安员单个新增文件
     * 读取内外推送的保安员批量导入文件
     * @return
     */
    public boolean readSecurityListFile() {
@@ -289,7 +290,7 @@
            ftp.setConnectTimeout(10000);
            //连接
            ftp.connect(ftpHost, ftpPort);
            System.out.println("ftp 连接成功!"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            System.out.println("定时任务：读取内外推送的保安员批量导入文件!"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            // 登陆
            ftp.login(ftpUserNameIn, ftpPasswordIn);
            // 检验登陆操作的返回码是否正确
@@ -314,29 +315,43 @@

            FTPFile[] files = ftp.listFiles();
            //文件个数大于10个时开始处理
            if (files.length==0 || files.length<10){
            if (files.length==0){
                ftp.logout();
                return false;
            }
            else {
                for (int i = files.length-1; i >0 ; i--) {
                for (int i = files.length-1; i >=0 ; i--) {
                    String fileName = files[i].getName();
                    System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"：读取到文件 = " + fileName);
                    if (fileName.contains("nl")) {
//                        InputStream is = ftp.retrieveFileStream(new String(fileName.getBytes("GBK"), FTP.DEFAULT_CONTROL_ENCODING));
                        //把文件下载到本地
                        long l = System.currentTimeMillis();
                        FtpUtil.downloadFtpFile(ftpHost, ftpUserNameIn, ftpPasswordIn, ftpPort, ftpPath, localPath, fileName);
                        long x = System.currentTimeMillis();
                        System.out.println("下载文件耗时 = " + (x-l)+" 毫秒");
                        //
                        String s = OutJson.TestJson(fileName);
                        //sql语句
                        String sql = OutJson.stringReplace(s);
                        //删除本地服务器文件
                        //数据转换
                        String json = OutJson.TestJson(fileName);
                        //取出map
                        Map<String,Object> map = JSON.parseObject(json, Map.class);
                        //取出 key/uuid,取出结果
                        String uuid = null;
                        Result result = new Result();
                        for (Map.Entry entry : map.entrySet()) {
                            Object value = entry.getValue();
                            //转换
                            result = JSON.parseObject(value.toString(), Result.class);
                        }
                        if (null!=result) {
                            try {
                                userListInfoHandler(result);
                            }catch (Exception e) {
                                //异步用户处理逻辑
                                e.printStackTrace();
                            }
                        }
                        //删除本地文件
                        MysqlCenlint.deletess(fileName);
                        //删除 ftp 服务器文件
//                        ftp.dele(fileName);
                        //删除 ftp 文件
                        FtpUtil.deleteFile(ftpHost, ftpPort, ftpUserNameIn, ftpPasswordIn, ftpPath, fileName);
                        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"：成功删除ftp文件 = " + fileName);
                    }
@@ -358,6 +373,60 @@
            }
        }
        return false;
    }

    /**
     * 用户集合信息处理
     * @param result
     */
    private void userListInfoHandler(Result result) {
        //获取 result
        List<Result> data1 = result.getData();
        if (data1.size()>0){
            for (Result result1 : data1) {
                // 取出 Msg ,此 msg 存的对应的 uuid
                String uuid = result1.getMsg();
                // 从redis 中获取对应的用户信息,脱敏处理过
                User user = handlerUserInfo(uuid);
                if (result1.getCode()==200){
                    user.setId(result1.getUserId());
                    boolean save = userService.save(user);
                    if (save){
                        //数据异步同步到群防群控
                        myAsyncService.qfqkUserSave(user);
                    }
                }
                //更新
                if (result1.getCode()==201){
                    //先查询当前库是否有改用户？
                    User user1 = userService.getById(result1.getUserId());
                    if (null!=user1) {
                        //存在，更新
                        user.setId(result1.getUserId());
                        user.setCreateTime(null);
                        boolean update = userService.updateById(user);
                        if (update) {
                            //数据异步同步到群防群控
                            myAsyncService.updateUserByQfqk(user);
                        }
                    }else {
                        //不存在，则新增
                        user.setId(result1.getUserId());
                        boolean save = userService.save(user);
                        if (save){
                            //数据异步同步到群防群控
                            myAsyncService.qfqkUserSave(user);
                        }
                    }
                }
                if (result1.getCode()==202){
                    //已在其他单位存在
                }
                if (result1.getCode()==203){
                    //保安证编号不匹配
                }
            }
        }
    }

    /**
@@ -373,7 +442,7 @@
            ftp.setConnectTimeout(10000);
            //连接
            ftp.connect(ftpHost, ftpPort);
            System.out.println("ftp 连接成功!"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            System.out.println("读取内外推送的保安员报名信息!"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            // 登陆
            ftp.login(ftpUserNameIn, ftpPasswordIn);
            // 检验登陆操作的返回码是否正确
@@ -398,12 +467,12 @@

            FTPFile[] files = ftp.listFiles();
            //文件个数大于10个时开始处理
            if (files.length==0 || files.length<10){
            if (files.length==0){
                ftp.logout();
                return false;
            }
            else {
                for (int i = files.length-1; i >0 ; i--) {
                for (int i = files.length-1; i >=0 ; i--) {
                    String fileName = files[i].getName();
                    System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"：读取到文件 = " + fileName);
                    if (fileName.contains("nt")) {
@@ -412,14 +481,25 @@
                        FtpUtil.downloadFtpFile(ftpHost, ftpUserNameIn, ftpPasswordIn, ftpPort, ftpPath, localPath, fileName);
                        long x = System.currentTimeMillis();
                        System.out.println("下载文件耗时 = " + (x-l)+" 毫秒");
                        //
                        String s = OutJson.TestJson(fileName);
                        //sql语句
                        String sql = OutJson.stringReplace(s);
                        //删除本地服务器文件
                        //数据转换
                        String json = OutJson.TestJson(fileName);
                        //取出map
                        Map<String,Object> map = JSON.parseObject(json, Map.class);
                        //取出 key/uuid,取出结果
                        String uuid = null;
                        Result result = new Result();
                        for (Map.Entry entry : map.entrySet()) {
                            uuid = entry.getKey().toString();
                            Object value = entry.getValue();
                            //转换
                            result = JSON.parseObject(value.toString(), Result.class);
                        }
                        if (null!=result) {
                            applyHandler(uuid,result);
                        }
                        //删除本地文件
                        MysqlCenlint.deletess(fileName);
                        //删除 ftp 服务器文件
//                        ftp.dele(fileName);
                        //删除 ftp 文件
                        FtpUtil.deleteFile(ftpHost, ftpPort, ftpUserNameIn, ftpPasswordIn, ftpPath, fileName);
                        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"：成功删除ftp文件 = " + fileName);
                    }
@@ -444,10 +524,114 @@
    }

    /**
     * 报名信息处理
     * @param result
     */
    private void applyHandler(String uuid,Result result) {
        //取出培训学校id
        //从redis 中获取用户数据
        String s = redisTemplate.opsForValue().get(uuid).toString();
        if (null!=s && !s.equals("")) {
            //创建集合，存年龄符合要求
            List<String> ageList = new ArrayList<>();
            //创建年龄不符合集合
            List<String> errorList = new ArrayList<>();
            AtomicInteger number = new AtomicInteger();
            if (null != result) {
                //获取 result
                List<Result> data1 = result.getData();
                if (data1.size() > 0) {
                    for (Result result1 : data1) {
                        // 取出 Msg ,此 msg 存的对应的 uuid
                        Long userId = result1.getUserId();
                        if (result1.getCode() == 200) {
                            //加入新增集合
                            ageList.add(userId.toString());
                        }
                        //年龄不符合要求
                        if (result1.getCode() == 201) {
                            //number ++
                            number.getAndIncrement();
                            //查询用户信息
                            User user = userService.getById(userId);
                            //加入更新集合
                            errorList.add(user.getRealName());
                        }
                    }
                }
            }

            if (ageList.size() > 0) {
                //遍历
                ageList.forEach(userId -> {
                    User user = userService.getUserById(userId);
                    //未报名的新增，已报名的不做处理
                    if (null == user.getIsTrain()) {
                        TrainingRegistration trainingRegistration1 = new TrainingRegistration();
                        trainingRegistration1.setCancel(1);
                        //默认为未考试状态
                        trainingRegistration1.setIsExam(1);
                        //未提交考试审核
                        trainingRegistration1.setAuditStatus(4);
                        trainingRegistration1.setTrainingTime(new Date());
                        trainingRegistration1.setUserId(userId);
                        trainingRegistration1.setTrainingUnitId(s);
                        trainingRegistrationService.save(trainingRegistration1);
                        //修改保安报名状态
                        user.setIsTrain(1);
                        userService.updateById(user);

                        //数据同步
                        saveTrainingRegistration(trainingRegistration1, user);
                    } else {
                        if (user.getIsTrain() != 1) {
                            TrainingRegistration trainingRegistration1 = new TrainingRegistration();
                            trainingRegistration1.setCancel(1);
                            //默认为未考试状态
                            trainingRegistration1.setIsExam(1);
                            //未提交考试审核
                            trainingRegistration1.setAuditStatus(4);
                            trainingRegistration1.setTrainingTime(new Date());
                            trainingRegistration1.setUserId(userId);
                            trainingRegistration1.setTrainingUnitId(s);
                            trainingRegistrationService.save(trainingRegistration1);
                            //修改保安报名状态
                            user.setIsTrain(1);
                            userService.updateById(user);

                            //数据同步
                            saveTrainingRegistration(trainingRegistration1, user);
                        }
                    }
                });
            }
        }
    }

    /**
     * 报名
     */
    private void saveTrainingRegistration(TrainingRegistration trainingRegistration,User user1){
        String formatStr = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        Long id = trainingRegistration.getId();
        String sql = "insert into sys_training_registration(id,training_unit_id,training_time,cancel,user_id,is_exam,audit_status) " +
            "values(" + "'" + id + "'"
            + "," + "'" + trainingRegistration.getTrainingUnitId() +"'"
            + "," + "'" + formatStr +"'"
            + "," + "'" + trainingRegistration.getCancel() + "'"
            + "," + "'" + trainingRegistration.getUserId() + "'"
            + "," + "'" + trainingRegistration.getIsExam() + "'"
            + "," +"'" + trainingRegistration.getAuditStatus() + "'" + ");" +
            "update blade_user set is_train = " + user1.getIsTrain() + " " +"where id = " + "'" + user1.getId() + "'";
        myAsyncService.FTP(sql);
    }

    /**
     *  用户审查
     * @return
     */
    public void userExamine() {
        System.out.println("用户审查任务----");
        //查询审查状态为未审查的保安员
        User user = new User();
        user.setStatus(1);

 src/main/java/org/springblade/modules/system/service/impl/UserServiceImpl.java

@@ -1373,116 +1373,116 @@
            map.put(uuid, userList);
            myAsyncService.FTPObjectList(map);

            int count = 0;
            //调用ftp获取返回数据
            while (true){
                try {
                    Thread.sleep(4000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //调用ftp获取返回数据
                result = Monitor.getFtpDataByUuidList(uuid);
                //如果返回true,就退处
                if (result.getCode() == 200) {
                    break;
                }
                else {
                    count++;
                    if (count == 20) {
                        break;
                    }
                }
            }
//            int count = 0;
//            //调用ftp获取返回数据
//            while (true){
//                try {
//                    Thread.sleep(4000);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                //调用ftp获取返回数据
//                result = Monitor.getFtpDataByUuidList(uuid);
//                //如果返回true,就退处
//                if (result.getCode() == 200) {
//                    break;
//                }
//                else {
//                    count++;
//                    if (count == 20) {
//                        break;
//                    }
//                }
//            }
        }

        if (null!=result){
            //获取 result
            List<Result> data1 = result.getData();
            if (data1.size()>0){
                for (Result result1 : data1) {
                    // 取出 Msg ,此 msg 存的对应的 uuid
                    String uuid = result1.getMsg();
                    //从redis 中获取用户数据
                    Object o1 = redisTemplate.opsForValue().get(uuid);
                    User user0 = JSON.parseObject(o1.toString(), User.class);
                    // 从redis 中获取对应的用户信息,脱敏处理过
                    User user = handlerUserInfo(uuid);
                    if (result1.getCode()==200){
                        user.setId(result1.getUserId());
                        boolean save = this.save(user);
                        //同步用户数据到群防群控
                        if (save) {
                            myAsyncService.qfqkUserSave(user);
                        }
                        //加入新增集合
//                        addList.add(user);
                    }
                    if (result1.getCode()==201){
                        //先查询当前库是否有改用户？
                        User user1 = this.getById(result1.getUserId());
                        if (null!=user1) {
                            //存在，更新
                            user.setId(result1.getUserId());
                            user.setCreateTime(null);
                            boolean update = this.updateById(user);
                            if (update) {
                                //数据异步同步到群防群控
                                myAsyncService.updateUserByQfqk(user);
                            }
                        }else {
                            //不存在，则新增
                            user.setId(result1.getUserId());
                            boolean save = this.save(user);
                            if (save){
                                //数据异步同步到群防群控
                                myAsyncService.qfqkUserSave(user);
                            }
                        }
                        //加入更新集合
//                        updateList.add(user);
                    }
                    if (result1.getCode()==202){
                        status.set(false);
                        //已在其他单位存在
                        errorList.add(user0.getCardid());
                    }
                    if (result1.getCode()==203){
                        securityInvalidStatus.set(false);
                        //保安证编号不匹配
                        securityInvalidList.add(user0.getCardid());
                    }
                }
//                //批量插入
//                if (addList.size()>0){
//                    baseMapper.batchUserList(addList);
//        if (null!=result){
//            //获取 result
//            List<Result> data1 = result.getData();
//            if (data1.size()>0){
//                for (Result result1 : data1) {
//                    // 取出 Msg ,此 msg 存的对应的 uuid
//                    String uuid = result1.getMsg();
//                    //从redis 中获取用户数据
//                    Object o1 = redisTemplate.opsForValue().get(uuid);
//                    User user0 = JSON.parseObject(o1.toString(), User.class);
//                    // 从redis 中获取对应的用户信息,脱敏处理过
//                    User user = handlerUserInfo(uuid);
//                    if (result1.getCode()==200){
//                        user.setId(result1.getUserId());
//                        boolean save = this.save(user);
//                        //同步用户数据到群防群控
//                        if (save) {
//                            myAsyncService.qfqkUserSave(user);
//                        }
//                        //加入新增集合
////                        addList.add(user);
//                    }
//                    if (result1.getCode()==201){
//                        //先查询当前库是否有改用户？
//                        User user1 = this.getById(result1.getUserId());
//                        if (null!=user1) {
//                            //存在，更新
//                            user.setId(result1.getUserId());
//                            user.setCreateTime(null);
//                            boolean update = this.updateById(user);
//                            if (update) {
//                                //数据异步同步到群防群控
//                                myAsyncService.updateUserByQfqk(user);
//                            }
//                        }else {
//                            //不存在，则新增
//                            user.setId(result1.getUserId());
//                            boolean save = this.save(user);
//                            if (save){
//                                //数据异步同步到群防群控
//                                myAsyncService.qfqkUserSave(user);
//                            }
//                        }
//                        //加入更新集合
////                        updateList.add(user);
//                    }
//                    if (result1.getCode()==202){
//                        status.set(false);
//                        //已在其他单位存在
//                        errorList.add(user0.getCardid());
//                    }
//                    if (result1.getCode()==203){
//                        securityInvalidStatus.set(false);
//                        //保安证编号不匹配
//                        securityInvalidList.add(user0.getCardid());
//                    }
//                }
//                //批量更新
//                if (updateList.size()>0){
//                    baseMapper.batchUpdateUserList(updateList);
//                }
            }
        }
////                //批量插入
////                if (addList.size()>0){
////                    baseMapper.batchUserList(addList);
////                }
////                //批量更新
////                if (updateList.size()>0){
////                    baseMapper.batchUpdateUserList(updateList);
////                }
//            }
//        }

        //如果所有数据导入有一个异常
        StringBuilder errorBuilder = new StringBuilder();
        if (!status.get()){
            String errorAccount = StringUtils.join(errorList, "\\\n");
            errorBuilder.append("用户:[" + errorAccount + "]导入失败!已在其他单位存在!");
        }
        if (!agetStatus.get()){
            String errorAccount = StringUtils.join(ageErrorList, "\\\n");
            errorBuilder.append("用户:[" + errorAccount + "]导入失败!身份证号码不正确,请核对!");
        }
        if (!securityInvalidStatus.get()){
            String errorAccount = StringUtils.join(securityInvalidList, "\\\n");
//            errorBuilder.append("用户:[" + errorAccount + "]保安证编号不匹配,请核实!");
            errorBuilder.append("用户:[" + errorAccount + "]保安证编号不匹配,请核实!也可通过提供保安证件信息提交核实申请!");
        }
        //抛出异常
        if (errorBuilder.length()>0){
            throw new ServiceException(errorBuilder.toString());
        }
//        //如果所有数据导入有一个异常
//        StringBuilder errorBuilder = new StringBuilder();
//        if (!status.get()){
//            String errorAccount = StringUtils.join(errorList, "\\\n");
//            errorBuilder.append("用户:[" + errorAccount + "]导入失败!已在其他单位存在!");
//        }
//        if (!agetStatus.get()){
//            String errorAccount = StringUtils.join(ageErrorList, "\\\n");
//            errorBuilder.append("用户:[" + errorAccount + "]导入失败!身份证号码不正确,请核对!");
//        }
//        if (!securityInvalidStatus.get()){
//            String errorAccount = StringUtils.join(securityInvalidList, "\\\n");
////            errorBuilder.append("用户:[" + errorAccount + "]保安证编号不匹配,请核实!");
//            errorBuilder.append("用户:[" + errorAccount + "]保安证编号不匹配,请核实!也可通过提供保安证件信息提交核实申请!");
//        }
//        //抛出异常
//        if (errorBuilder.length()>0){
//            throw new ServiceException(errorBuilder.toString());
//        }
    }

    /**
@@ -1651,109 +1651,109 @@
            map.put(uuid, userList);
            myAsyncService.FTPObjectList(map);

            int count = 0;
            //调用ftp获取返回数据
            while (true){
                try {
                    Thread.sleep(4000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //调用ftp获取返回数据
                result = Monitor.getFtpDataByUuidList(uuid);
                //如果返回true,就退处
                if (result.getCode() == 200) {
                    break;
                }
                else {
                    count++;
                    if (count == 20) {
                        break;
                    }
                }
            }
//            int count = 0;
//            //调用ftp获取返回数据
//            while (true){
//                try {
//                    Thread.sleep(4000);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                //调用ftp获取返回数据
//                result = Monitor.getFtpDataByUuidList(uuid);
//                //如果返回true,就退处
//                if (result.getCode() == 200) {
//                    break;
//                }
//                else {
//                    count++;
//                    if (count == 20) {
//                        break;
//                    }
//                }
//            }
        }

        if (null!=result){
            //获取 result
            List<Result> data1 = result.getData();
            if (data1.size()>0){
                for (Result result1 : data1) {
                    // 取出 Msg ,此 msg 存的对应的 uuid
                    String uuid = result1.getMsg();
                    //从redis 中获取用户数据
                    Object o1 = redisTemplate.opsForValue().get(uuid);
                    User user0 = JSON.parseObject(o1.toString(), User.class);
                    // 从redis 中获取对应的用户信息,脱敏处理过
                    User user = handlerUserInfo(uuid);
                    if (result1.getCode()==200){
                        user.setId(result1.getUserId());
                        boolean save = this.save(user);
                        if (save){
                            //数据异步同步到群防群控
                            myAsyncService.qfqkUserSave(user);
                        }
                        //加入新增集合
//                        addList.add(user);
                    }
                    //更新
                    if (result1.getCode()==201){
                        //先查询当前库是否有改用户？
                        User user1 = this.getById(result1.getUserId());
                        if (null!=user1) {
                            //存在，更新
                            user.setId(result1.getUserId());
                            user.setCreateTime(null);
                            boolean update = this.updateById(user);
                            if (update) {
                                //数据异步同步到群防群控
                                myAsyncService.updateUserByQfqk(user);
                            }
                        }else {
                            //不存在，则新增
                            user.setId(result1.getUserId());
                            boolean save = this.save(user);
                            if (save){
                                //数据异步同步到群防群控
                                myAsyncService.qfqkUserSave(user);
                            }
                        }
                        //加入更新集合
//                        updateList.add(user);
                    }
                    if (result1.getCode()==202){
                        status.set(false);
                        //已在其他单位存在
                        errorList.add(user0.getCardid());
                    }
                    if (result1.getCode()==203){
                        securityInvalidStatus.set(false);
                        //保安证编号不匹配
                        securityInvalidList.add(user0.getCardid());
                    }
                }
            }
        }

        //如果所有数据导入有一个异常
        StringBuilder errorBuilder = new StringBuilder();
        if (!status.get()){
            String errorAccount = StringUtils.join(errorList, "\\\n");
            errorBuilder.append("用户:[" + errorAccount + "]导入失败!已在其他单位存在!");
        }
        if (!agetStatus.get()){
            String errorAccount = StringUtils.join(ageErrorList, "\\\n");
            errorBuilder.append("用户:[" + errorAccount + "]导入失败!身份证号码不正确,请核对!");
        }
        if (!securityInvalidStatus.get()){
            String errorAccount = StringUtils.join(securityInvalidList, "\\\n");
            errorBuilder.append("用户:[" + errorAccount + "]保安证编号不匹配,请核实!");
//            errorBuilder.append("用户:[" + errorAccount + "]保安证编号不匹配,请核实!也可通过提供保安证件信息提交核实申请!");
        }
        //抛出异常
        if (errorBuilder.length()>0){
            throw new ServiceException(errorBuilder.toString());
        }
//        if (null!=result){
//            //获取 result
//            List<Result> data1 = result.getData();
//            if (data1.size()>0){
//                for (Result result1 : data1) {
//                    // 取出 Msg ,此 msg 存的对应的 uuid
//                    String uuid = result1.getMsg();
//                    //从redis 中获取用户数据
//                    Object o1 = redisTemplate.opsForValue().get(uuid);
//                    User user0 = JSON.parseObject(o1.toString(), User.class);
//                    // 从redis 中获取对应的用户信息,脱敏处理过
//                    User user = handlerUserInfo(uuid);
//                    if (result1.getCode()==200){
//                        user.setId(result1.getUserId());
//                        boolean save = this.save(user);
//                        if (save){
//                            //数据异步同步到群防群控
//                            myAsyncService.qfqkUserSave(user);
//                        }
//                        //加入新增集合
////                        addList.add(user);
//                    }
//                    //更新
//                    if (result1.getCode()==201){
//                        //先查询当前库是否有改用户？
//                        User user1 = this.getById(result1.getUserId());
//                        if (null!=user1) {
//                            //存在，更新
//                            user.setId(result1.getUserId());
//                            user.setCreateTime(null);
//                            boolean update = this.updateById(user);
//                            if (update) {
//                                //数据异步同步到群防群控
//                                myAsyncService.updateUserByQfqk(user);
//                            }
//                        }else {
//                            //不存在，则新增
//                            user.setId(result1.getUserId());
//                            boolean save = this.save(user);
//                            if (save){
//                                //数据异步同步到群防群控
//                                myAsyncService.qfqkUserSave(user);
//                            }
//                        }
//                        //加入更新集合
////                        updateList.add(user);
//                    }
//                    if (result1.getCode()==202){
//                        status.set(false);
//                        //已在其他单位存在
//                        errorList.add(user0.getCardid());
//                    }
//                    if (result1.getCode()==203){
//                        securityInvalidStatus.set(false);
//                        //保安证编号不匹配
//                        securityInvalidList.add(user0.getCardid());
//                    }
//                }
//            }
//        }
//
//        //如果所有数据导入有一个异常
//        StringBuilder errorBuilder = new StringBuilder();
//        if (!status.get()){
//            String errorAccount = StringUtils.join(errorList, "\\\n");
//            errorBuilder.append("用户:[" + errorAccount + "]导入失败!已在其他单位存在!");
//        }
//        if (!agetStatus.get()){
//            String errorAccount = StringUtils.join(ageErrorList, "\\\n");
//            errorBuilder.append("用户:[" + errorAccount + "]导入失败!身份证号码不正确,请核对!");
//        }
//        if (!securityInvalidStatus.get()){
//            String errorAccount = StringUtils.join(securityInvalidList, "\\\n");
//            errorBuilder.append("用户:[" + errorAccount + "]保安证编号不匹配,请核实!");
////            errorBuilder.append("用户:[" + errorAccount + "]保安证编号不匹配,请核实!也可通过提供保安证件信息提交核实申请!");
//        }
//        //抛出异常
//        if (errorBuilder.length()>0){
//            throw new ServiceException(errorBuilder.toString());
//        }
    }



 src/main/java/org/springblade/modules/training/controller/TrainingRegistrationController.java

@@ -319,113 +319,116 @@
        //将集合推送内网，判断年龄是否符合要求，得到返回的结果，结果需包含userId，及年龄是否符合的状态
        //生成随机数
        String uuid = UUID.randomUUID().toString();
        //将 学校id 存入 redis
        redisTemplate.opsForValue().set(uuid, JSON.toJSONString(trainingRegistration.getTrainingUnitId()));
        //数据推送
        Map<String, Object> map = new HashMap<>(1);
        map.put(uuid, list);
        myAsyncService.FTPObjectListUserId(map);

        Result result = new Result();
        int count = 0;
        //调用ftp获取返回数据
        while (true){
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //调用ftp获取返回数据
            result = Monitor.getFtpDataByUuidListTrain(uuid);
            //如果返回true,就退处
            if (result.getCode() == 200) {
                break;
            }
            else {
                count++;
                if (count == 30) {
                    break;
                }
            }
        }

        //创建集合，存年龄符合要求
        List<String> ageList = new ArrayList<>();
        //创建年龄不符合集合
        List<String> errorList = new ArrayList<>();
        AtomicInteger number  = new AtomicInteger();
        if (null!=result){
            //获取 result
            List<Result> data1 = result.getData();
            if (data1.size()>0){
                for (Result result1 : data1) {
                    // 取出 Msg ,此 msg 存的对应的 uuid
                    Long userId = result1.getUserId();
                    if (result1.getCode()==200){
                        //加入新增集合
                        ageList.add(userId.toString());
                    }
                    //年龄不符合要求
                    if (result1.getCode()==201){
                        //number ++
                        number.getAndIncrement();
                        //查询用户信息
                        User user = userService.getById(userId);
                        //加入更新集合
                        errorList.add(user.getRealName());
                    }
                }
            }
        }

        if (ageList.size()>0) {
            //遍历
            ageList.forEach(userId -> {
                User user = userService.getUserById(userId);
                //未报名的新增，已报名的不做处理
                if (null == user.getIsTrain()) {
                    TrainingRegistration trainingRegistration1 = new TrainingRegistration();
                    trainingRegistration1.setCancel(1);
                    //默认为未考试状态
                    trainingRegistration1.setIsExam(1);
                    //未提交考试审核
                    trainingRegistration1.setAuditStatus(4);
                    trainingRegistration1.setTrainingTime(new Date());
                    trainingRegistration1.setUserId(userId);
                    trainingRegistration1.setTrainingUnitId(trainingRegistration.getTrainingUnitId());
                    trainingRegistrationService.save(trainingRegistration1);
                    //修改保安报名状态
                    user.setIsTrain(1);
                    userService.updateById(user);

                    //数据同步
                    saveTrainingRegistration(trainingRegistration1, user);
                } else {
                    if (user.getIsTrain() != 1) {
                        TrainingRegistration trainingRegistration1 = new TrainingRegistration();
                        trainingRegistration1.setCancel(1);
                        //默认为未考试状态
                        trainingRegistration1.setIsExam(1);
                        //未提交考试审核
                        trainingRegistration1.setAuditStatus(4);
                        trainingRegistration1.setTrainingTime(new Date());
                        trainingRegistration1.setUserId(userId);
                        trainingRegistration1.setTrainingUnitId(trainingRegistration.getTrainingUnitId());
                        trainingRegistrationService.save(trainingRegistration1);
                        //修改保安报名状态
                        user.setIsTrain(1);
                        userService.updateById(user);

                        //数据同步
                        saveTrainingRegistration(trainingRegistration1, user);
                    }
                }
            });
        }

        //如果存在年龄不符的，则抛出异常
        if (number.get()>0){
            String errorAccount = StringUtils.join(errorList, "\\\n");
            throw new ServiceException("保安员:[" + errorAccount + "]报名失败!年龄不符,报名年龄为[18-60]周岁!");
        }
//        Result result = new Result();
//        int count = 0;
//        //调用ftp获取返回数据
//        while (true){
//            try {
//                Thread.sleep(3000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            //调用ftp获取返回数据
//            result = Monitor.getFtpDataByUuidListTrain(uuid);
//            //如果返回true,就退处
//            if (result.getCode() == 200) {
//                break;
//            }
//            else {
//                count++;
//                if (count == 30) {
//                    break;
//                }
//            }
//        }
//
//        //创建集合，存年龄符合要求
//        List<String> ageList = new ArrayList<>();
//        //创建年龄不符合集合
//        List<String> errorList = new ArrayList<>();
//        AtomicInteger number  = new AtomicInteger();
//        if (null!=result){
//            //获取 result
//            List<Result> data1 = result.getData();
//            if (data1.size()>0){
//                for (Result result1 : data1) {
//                    // 取出 Msg ,此 msg 存的对应的 uuid
//                    Long userId = result1.getUserId();
//                    if (result1.getCode()==200){
//                        //加入新增集合
//                        ageList.add(userId.toString());
//                    }
//                    //年龄不符合要求
//                    if (result1.getCode()==201){
//                        //number ++
//                        number.getAndIncrement();
//                        //查询用户信息
//                        User user = userService.getById(userId);
//                        //加入更新集合
//                        errorList.add(user.getRealName());
//                    }
//                }
//            }
//        }
//
//        if (ageList.size()>0) {
//            //遍历
//            ageList.forEach(userId -> {
//                User user = userService.getUserById(userId);
//                //未报名的新增，已报名的不做处理
//                if (null == user.getIsTrain()) {
//                    TrainingRegistration trainingRegistration1 = new TrainingRegistration();
//                    trainingRegistration1.setCancel(1);
//                    //默认为未考试状态
//                    trainingRegistration1.setIsExam(1);
//                    //未提交考试审核
//                    trainingRegistration1.setAuditStatus(4);
//                    trainingRegistration1.setTrainingTime(new Date());
//                    trainingRegistration1.setUserId(userId);
//                    trainingRegistration1.setTrainingUnitId(trainingRegistration.getTrainingUnitId());
//                    trainingRegistrationService.save(trainingRegistration1);
//                    //修改保安报名状态
//                    user.setIsTrain(1);
//                    userService.updateById(user);
//
//                    //数据同步
//                    saveTrainingRegistration(trainingRegistration1, user);
//                } else {
//                    if (user.getIsTrain() != 1) {
//                        TrainingRegistration trainingRegistration1 = new TrainingRegistration();
//                        trainingRegistration1.setCancel(1);
//                        //默认为未考试状态
//                        trainingRegistration1.setIsExam(1);
//                        //未提交考试审核
//                        trainingRegistration1.setAuditStatus(4);
//                        trainingRegistration1.setTrainingTime(new Date());
//                        trainingRegistration1.setUserId(userId);
//                        trainingRegistration1.setTrainingUnitId(trainingRegistration.getTrainingUnitId());
//                        trainingRegistrationService.save(trainingRegistration1);
//                        //修改保安报名状态
//                        user.setIsTrain(1);
//                        userService.updateById(user);
//
//                        //数据同步
//                        saveTrainingRegistration(trainingRegistration1, user);
//                    }
//                }
//            });
//        }
//
//        //如果存在年龄不符的，则抛出异常
//        if (number.get()>0){
//            String errorAccount = StringUtils.join(errorList, "\\\n");
//            throw new ServiceException("保安员:[" + errorAccount + "]报名失败!年龄不符,报名年龄为[18-60]周岁!");
//        }
        return R.data(200,"报名成功");
    }