去除年龄判断

钟日健

2022-06-27 59b41b126c4a8642fcb489f0dea954b16465318d

 src/main/java/org/springblade/modules/exam/service/impl/ExamScoreServiceImpl.java

@@ -1,78 +1,101 @@

package org.springblade.modules.exam.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.AllArgsConstructor;
import org.springblade.common.utils.arg;
import org.apache.commons.lang3.StringUtils;
import org.springblade.common.utils.DesensitizedUtil;
import org.springblade.core.log.exception.ServiceException;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.tool.utils.BeanUtil;
import org.springblade.modules.FTP.FtpUtil;
import org.springblade.modules.FTP.Monitor;
import org.springblade.modules.FTP.Result;
import org.springblade.modules.apply.entity.Apply;
import org.springblade.modules.apply.service.ApplyService;
import org.springblade.modules.exam.entity.ExamExaminationSubject;
import org.springblade.modules.exam.entity.ExamPaper;
import org.springblade.modules.exam.entity.ExamScore;
import org.springblade.modules.exam.entity.ExamSubjectChoices;
import org.springblade.modules.exam.entity.*;
import org.springblade.modules.exam.excel.ExamScoreExcel;
import org.springblade.modules.exam.excel.ExportExamScoreExcel;
import org.springblade.modules.exam.mapper.ExamScoreMapper;
import org.springblade.modules.exam.service.ExamAnswerRecordService;
import org.springblade.modules.exam.service.ExamPaperService;
import org.springblade.modules.exam.service.ExamScoreService;
import org.springblade.modules.exam.service.ExamSubjectChoicesService;
import org.springblade.modules.exam.util.SecurityPaperUtil;
import org.springblade.modules.exam.vo.ExamResultVO;
import org.springblade.modules.exam.vo.ExamScoreVO;
import org.springblade.modules.system.entity.Role;
import org.springblade.modules.exam.vo.*;
import org.springblade.modules.information.entity.Information;
import org.springblade.modules.information.service.IInformationService;
import org.springblade.modules.information.vo.InformationVO;
import org.springblade.modules.securitypaper.entity.SecurityPaper;
import org.springblade.modules.securitypaper.service.SecurityPaperService;
import org.springblade.modules.system.entity.User;
import org.springblade.modules.system.service.IRoleService;
import org.springblade.modules.system.service.IUserService;
import org.springblade.modules.system.service.MyAsyncService;
import org.springblade.modules.system.vo.UserVO;
import org.springblade.modules.training.entity.TrainingRegistration;
import org.springblade.modules.training.service.TrainingRegistrationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;

import static com.bstek.ureport.expression.model.condition.Join.and;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 考试成绩服务实现类
 *
 * @author zhongrj
 */
@Service
@AllArgsConstructor
public class ExamScoreServiceImpl extends ServiceImpl<ExamScoreMapper, ExamScore> implements ExamScoreService {

   private final IUserService userService;
   @Autowired
   private IUserService userService;

   private final ExamSubjectChoicesService examSubjectChoicesService;
   @Autowired
   private ExamSubjectChoicesService examSubjectChoicesService;

   private final ExamPaperService examPaperService;
   @Autowired
   private ExamPaperService examPaperService;

   private final ApplyService applyService;
   @Autowired
   private ApplyService applyService;

   private final TrainingRegistrationService trainingRegistrationService;
   @Autowired
   private TrainingRegistrationService trainingRegistrationService;

   private final IRoleService roleService;
   @Autowired
   private SecurityPaperService securityPaperService;

   @Autowired
   private ExamAnswerRecordService examAnswerRecordService;

   @Autowired
   private IInformationService informationService;
   @Autowired
   private MyAsyncService myAsyncService;


   /**
    * 自定义分页数据
    * @param page 分页条件
    *
    * @param page      分页条件
    * @param examScore 考试成绩对象
    * @return
    */
   @Override
   public IPage<ExamScoreVO> selectExamScorePage(IPage<ExamScoreVO> page, ExamScoreVO examScore) {
      if (null!=examScore.getExamType()){
         if (examScore.getExamType()==1){
      if (null != examScore.getExamType()) {
         if (examScore.getExamType() == 1) {
            return page.setRecords(baseMapper.selectExamScorePage(page, examScore));
         }
         if (examScore.getExamType()==2){
         if (examScore.getExamType() == 2) {
            return page.setRecords(baseMapper.selectTrainExamScorePage(page, examScore));
         }
      }
@@ -81,6 +104,7 @@

   /**
    * 详情
    *
    * @param examScore 考试成绩信息对象
    */
   @Override
@@ -90,6 +114,7 @@

   /**
    * 保存考试成绩
    *
    * @param examScore 考试成绩信息对象
    * @return
    */
@@ -97,7 +122,8 @@
   @Transactional(rollbackFor = Exception.class)
   public Boolean saveExamScore(ExamScoreVO examScore) {
      //取出考试结果
      if (examScore.getExamResultVOS().size()>0){
      if (examScore.getExamResultVOS().size() > 0) {
         ExamScore score = this.getById(examScore.getId());
         List<ExamResultVO> examResultVOS = examScore.getExamResultVOS();
         //获取试卷的内容（题号，答案）
//         ExamPaper examPaper = new ExamPaper();
@@ -109,16 +135,16 @@
         //声明理论得分
         int theoryGrade = 0;
         for (ExamResultVO examResultVO : examResultVOS) {
            for (ExamSubjectChoices es: list) {
            for (ExamSubjectChoices es : list) {
               //对比题目id
               if (examResultVO.getSubjectChoicesId().equals(es.getId())) {
                  //对比答案
                  if (es.getChoicesType() == 2 || es.getChoicesType() == 3){
                  if (es.getChoicesType() == 2 || es.getChoicesType() == 3) {
                     //判断题逻辑
                     if (examResultVO.getValue().equals(es.getAnswer())) {
                        theoryGrade += examResultVO.getGrade();
                     }
                  }else if(es.getChoicesType() == 0 || es.getChoicesType() == 1){
                  } else if (es.getChoicesType() == 0 || es.getChoicesType() == 1) {
                     //处理多选题的答案排序
                     String[] split = examResultVO.getValue().split(",");
                     StringBuilder builder = new StringBuilder();
@@ -129,7 +155,7 @@
                     //利用数组帮助类自动排序
                     Arrays.sort(arrayCh);
                     String sub0 = Arrays.toString(arrayCh);
                     String sub = sub0.substring(1,sub0.length()-1).replaceAll(" ","");
                     String sub = sub0.substring(1, sub0.length() - 1).replaceAll(" ", "");
                     if (sub.equals(es.getAnswer())) {
                        theoryGrade += examResultVO.getGrade();
                     }
@@ -145,7 +171,7 @@
         int age = 0;
         UserVO user = new UserVO();
         //使用准考证号查询报名信息，修改考试状态为已考试
         if(paper.getExamType()==1){
         if (paper.getExamType() == 1) {
            Apply apply = new Apply();
            apply.setCandidateNo(examScore.getCandidateNo());
            Apply apply1 = applyService.getOne(Condition.getQueryWrapper(apply));
@@ -159,24 +185,26 @@
            apply1.setIsExam(2);
            applyService.updateById(apply1);


            //数据同步
            String s =
               "update sys_apply set is_exam = " + apply1.getIsExam() + " " +"where id = " + "'" + apply1.getId() + "';" +
                  "update blade_user set is_apply = " + user.getIsApply() + " " +"where id = " + "'" + user.getId() + "'";
            FtpUtil.sqlFileUpload(s);
               "update sys_apply set is_exam = " + apply1.getIsExam() + " " + "where id = " + "'" + apply1.getId() + "';" +
                  "update blade_user set is_apply = " + user.getIsApply() + " " + "where id = " + "'" + user.getId() + "'";
            //FtpUtil.sqlFileUpload(s);
            myAsyncService.FTP(s);

         }
         //模拟考试
         if(paper.getExamType()==2){
            TrainingRegistration trainingRegistration = new TrainingRegistration();
            trainingRegistration.setCandidateNo(examScore.getCandidateNo());
            TrainingRegistration trainingRegistration1 = trainingRegistrationService.getOne(Condition.getQueryWrapper(trainingRegistration));
         //培训考试
         if (paper.getExamType() == 2) {
//            TrainingRegistration trainingRegistration = new TrainingRegistration();
//            trainingRegistration.setCandidateNo(examScore.getCandidateNo());
//            trainingRegistration.setCancel(1);
//            TrainingRegistration trainingRegistration1 = trainingRegistrationService.getOne(Condition.getQueryWrapper(trainingRegistration));
            TrainingRegistration trainingRegistration1 = trainingRegistrationService.getById(score.getApplyId());
            //查询用户年龄，根据年龄计算总分
            user = userService.getUserAgeById(Long.parseLong(trainingRegistration1.getUserId()));
            //修改用户的培训状态,理论考试结束
            user.setIsTrain(3);
            age = user.getAge();
//            age = user.getAge();
            userService.updateById(user);
            //修改为已考试
            trainingRegistration1.setIsExam(2);
@@ -184,26 +212,28 @@

            //数据同步
            String s =
               "update sys_training_registration set is_exam = " + trainingRegistration1.getIsExam() + " " +"where id = " + "'" + trainingRegistration1.getId() + "';" +
                  "update blade_user set is_apply = " + user.getIsApply() + " " +"where id = " + "'" + user.getId() + "'";
            FtpUtil.sqlFileUpload(s);
               "update sys_training_registration set is_exam = " + trainingRegistration1.getIsExam() + " " + "where id = " + "'" + trainingRegistration1.getId() + "';" +
                  "update blade_user set is_train = " + user.getIsTrain() + " " + "where id = " + "'" + user.getId() + "'";
            //FtpUtil.sqlFileUpload(s);
            myAsyncService.FTP(s);
         }

         //设置提交时间
         examScore.setExamEndTime(new Date());
         //设置考试ID
         examScore.setExamId(examScore.getPapersId().toString());
         //设置理论得分
         examScore.setTheoryGrade(theoryGrade);
         //计算总成绩,此时没有实操成绩，总成绩为实操成绩和理论成绩和的一半
         if (age<=50) {
            examScore.setAllGrade(Math.round(theoryGrade / 2));
         }
         if (age>50) {
            examScore.setAllGrade(Integer.parseInt(String.valueOf(Math.round(theoryGrade*0.5))));
         }
         examScore.setAllGrade(Math.round(theoryGrade / 2));
//         if (age <= 50) {
//         }
//         if (age > 50) {
//            examScore.setAllGrade(Integer.parseInt(String.valueOf(Math.round(theoryGrade * 0.5))));
//         }
         //设置状态
         if (theoryGrade>=60){
         if (theoryGrade >= 60) {
            examScore.setQualified(2);
         }else {
         } else {
            examScore.setQualified(1);
         }
         //修改成绩数据
@@ -215,10 +245,11 @@
               ",all_grade = " + "'" + examScore.getAllGrade() + "'" +
               ",exam_end_time = " + "'" + new SimpleDateFormat("yyyy-MM-dd HH:mm:dd").format(examScore.getExamEndTime()) + "'" +
               ",qualified = " + "'" + examScore.getQualified() + "'" +
               " " +"where id = " + "'" + examScore.getId() + "'";
         FtpUtil.sqlFileUpload(s1);
               " " + "where id = " + "'" + examScore.getId() + "'";
         //FtpUtil.sqlFileUpload(s1);
         myAsyncService.FTP(s1);

         if (i>0){
         if (i > 0) {
            //返回结果
            return true;
         }
@@ -227,95 +258,844 @@
      return false;
   }

//   /**
//    * 导入实操成绩
//    *
//    * @param examScoreExcelList
//    * @param isCovered          是否覆盖
//    */
//   @Override
//   public void importExamScore(List<ExamScoreExcel> examScoreExcelList, Boolean isCovered) {
//      if (examScoreExcelList.size() > 0) {
//         //遍历
//         examScoreExcelList.forEach(examScoreExcel -> {
//            if (null != examScoreExcel.getLearnGrade() && null != examScoreExcel.getIdCardNo() && examScoreExcel.getIdCardNo() != "") {
//               //使用考试名称匹配考试信息
//               List<ExamPaper> examPaperList = examPaperService.getExamInfoByExamName(examScoreExcel.getExamName());
//               ExamPaper examPaper = examPaperList.get(0);
//               //查询出成绩数据
//               if (examPaperList.size() > 0) {
//                  ExamScore score = new ExamScore();
//                  score.setCandidateNo(examScoreExcel.getIdCardNo());
//                  score.setLearnGrade(examScoreExcel.getLearnGrade());
//                  score.setExamTime(examPaper.getStartTime());
//                  //生成随机数
//                  String uuid = UUID.randomUUID().toString();
//                  //数据推送
//                  Map<String, Object> map = new HashMap<>(1);
//                  map.put(uuid, score);
//                  myAsyncService.FTPObjectExamScore(map);
//               } else {
//                  throw new ServiceException("导入失败!考试名称:[" + examScoreExcel.getExamName() + "]不存在!请核对!");
//               }
//            }
//         });
//      }
//   }

   /**
    * 导入实操成绩
    * 导入实操成绩(按准考证编号导入版)
    *
    * @param examScoreExcelList
    * @param isCovered 是否覆盖
    * @param isCovered          是否覆盖
    */
   @Override
   public void importExamScore(List<ExamScoreExcel> examScoreExcelList, Boolean isCovered) {
      if (examScoreExcelList.size()>0){
         examScoreExcelList.forEach(examScoreExcel -> {
            if (null!=examScoreExcel.getLearnGrade() && null!=examScoreExcel.getIdCardNo() && examScoreExcel.getIdCardNo()!=""){
      if (examScoreExcelList.size() > 0) {
         List<Object> errorList = new ArrayList<>();
         //导入状态，默认为true ,如果有一个出现问题则为 false
         AtomicBoolean status = new AtomicBoolean(true);
         //遍历
         for (ExamScoreExcel examScoreExcel : examScoreExcelList) {
            if (null != examScoreExcel.getLearnGrade() && null != examScoreExcel.getCandidateNo() && examScoreExcel.getCandidateNo() != "") {
               //使用考试名称匹配考试信息
               ExamPaper examPaper = examPaperService.getExamInfoByExamName(examScoreExcel.getExamName());
               List<ExamPaper> examPaperList = examPaperService.getExamInfoByExamName(examScoreExcel.getExamName());
               //查询出成绩数据
               ExamScore examScore = baseMapper.getExamScoreInfoByIdCardNo(examScoreExcel.getIdCardNo(),examPaper.getId());
               if (null!=examScore) {
                  //查询当前保安信息
                  UserVO user = userService.getUserAgeById(Long.parseLong(examScore.getUserId()));
                  examScore.setLearnGrade(examScoreExcel.getLearnGrade());
                  if (examScore.getTheoryGrade() >= 60 && examScore.getLearnGrade() >= 60) {
                     //合格
                     examScore.setQualified(0);
                     //正式考试通过生成保安证编号
                     if (examPaper.getExamType()==1) {
                        //去生成保安证编号
                        String pre = SecurityPaperUtil.getSecurityPaper();
                        //查询当前年份已有的保安证编号
                        int count = userService.getSecurityPaperCount(pre);
                        String result = null;
                        if (count == 0) {
                           result = pre + "00000";
               if (examPaperList.size() > 0) {
                  ExamScore score = new ExamScore();
                  score.setCandidateNo(examScoreExcel.getCandidateNo());
                  List<ExamScore> examScoreList = this.list(new QueryWrapper<>(score));
                  if (examScoreList.size() == 0) {
                     errorList.add(examScoreExcel.getName());
                     status.set(false);
                     break;
                  }
                  //遍历集合
                  examScoreList.forEach(examScore -> {
                     if (null != examScore) {
                        //查询当前保安信息
                        UserVO user = userService.getUserAgeById(Long.parseLong(examScore.getUserId()));
                        //设置实操成绩
                        examScore.setLearnGrade(examScoreExcel.getLearnGrade());
                        if (null != examScore.getTheoryGrade()) {
                           if (examScore.getTheoryGrade() >= 60 && examScore.getLearnGrade() >= 60) {
                              //合格
                              examScore.setQualified(0);
                              //修改制证状态为未制证
                              user.setUserType(7);
                              //如果已有保安证编号，不更新用户信息
                              if (null == user.getSecuritynumber() || user.getSecuritynumber().equals("")) {
                                 //去内网生成保安证编号，由内网生成，无需返回
                                 //数据推送
                                 Map<String, Object> map = new HashMap<>(1);
                                 map.put("key",examScore);
                                 myAsyncService.FTPSecurityNumberBit(map);
                              }
                           }
                        } else {
                           //格式化
                           DecimalFormat decimalFormat = new DecimalFormat("00000");
                           result = pre + (decimalFormat.format(count++));
                           //不合格
                           examScore.setQualified(1);
                        }
                        user.setSecuritynumber(result);
                        //发证日期
                        user.setPaperTime(new Date());
                        //修改为持证保安
                        user.setHold("1");
                        //分配保安角色
//                        Role role = new Role();
//                        role.setRoleAlias("保安");
//                        Role oneRole = roleService.getOne(Condition.getQueryWrapper(role));
//                        user.setRoleId(oneRole.getId().toString());
                        //更新保安数据
                        userService.updateById(user);
                        //总成绩
                        if (user.getAge() <= 50) {
                           if (null != examScore.getTheoryGrade()) {
                              examScore.setAllGrade(Math.round((examScore.getTheoryGrade() + examScoreExcel.getLearnGrade()) / 2));
                           } else {
                              examScore.setAllGrade(Math.round(examScoreExcel.getLearnGrade() / 2));
                           }
                        }
                        if (user.getAge() > 50) {
                           if (null != examScore.getTheoryGrade()) {
                              examScore.setAllGrade(Integer.parseInt(String.valueOf(Math.round(examScore.getTheoryGrade() * 0.5)))
                                 + Integer.parseInt(String.valueOf(Math.round(examScoreExcel.getLearnGrade() * 0.5))));
                           } else {
                              examScore.setAllGrade(Math.round(examScoreExcel.getLearnGrade() / 2));
                           }
                        }

                        //内网同步
                        String s1 =
                           "update blade_user set hold = " + "'" +  user.getHold() + "'" +
                              ",securitynumber = " + "'" + user.getSecuritynumber() + "'" +
                              ",paper_time = " + "'" + new SimpleDateFormat("yyyy-MM-dd").format(user.getPaperTime()) + "'" +
                              " " +"where id = " + "'" + user.getId() + "'";
                        FtpUtil.sqlFileUpload(s1);
                           "update exam_score set learn_grade = " + "'" + examScore.getLearnGrade() + "'" +
                              ",all_grade = " + "'" + examScore.getAllGrade() + "'" +
                              ",qualified = " + "'" + examScore.getQualified() + "'" +
                              " " + "where id = " + "'" + examScore.getId() + "'";
                        myAsyncService.FTP(s1);
                        //更新成绩数据
                        baseMapper.updateById(examScore);
                     } else {
                        errorList.add(examScoreExcel.getName());
                        status.set(false);
                     }
                  } else {
                     //不合格
                     examScore.setQualified(1);
                  }
                  //总成绩
                  if (user.getAge()<=50) {
                     examScore.setAllGrade(Math.round((examScore.getTheoryGrade()+examScoreExcel.getLearnGrade())/2));
                  }
                  if (user.getAge()>50) {
                     examScore.setAllGrade(Integer.parseInt(String.valueOf(Math.round(examScore.getTheoryGrade()*0.5)))
                        + Integer.parseInt(String.valueOf(Math.round(examScoreExcel.getLearnGrade()*0.5))));
                  }

                  //内网同步
                  String s1 =
                     "update exam_score set learn_grade = " + "'" + examScore.getLearnGrade() + "'" +
                        ",all_grade = " + "'" + examScore.getAllGrade() + "'" +
                        ",qualified = " + "'" + examScore.getQualified() + "'" +
                        " " +"where id = " + "'" + examScore.getId() + "'";
                  FtpUtil.sqlFileUpload(s1);
                  //更新成绩数据
                  baseMapper.updateById(examScore);
                  });
               } else {
                  throw new ServiceException("导入失败!考试名称:[" + examScoreExcel.getExamName() + "]不存在!请核对!");
               }
            }
         });
         }
         //如果所有数据导入有一个异常
         if (!status.get()) {
            String errorAccount = StringUtils.join(errorList, "\\\n");
            throw new ServiceException("用户:[" + errorAccount + "]实操成绩导入失败!账号与准考证号不匹配!");
         }
      }
   }


//   /**
//    * 导入实操成绩
//    *
//    * @param examScoreExcelList
//    * @param isCovered          是否覆盖
//    */
//   @Override
//   public void importExamScore(List<ExamScoreExcel> examScoreExcelList, Boolean isCovered) {
//      if (examScoreExcelList.size() > 0) {
//         List<Object> errorList = new ArrayList<>();
//         //导入状态，默认为true ,如果有一个出现问题则为 false
//         AtomicBoolean status = new AtomicBoolean(true);
//         //遍历
//         examScoreExcelList.forEach(examScoreExcel -> {
//            if (null != examScoreExcel.getLearnGrade() && null != examScoreExcel.getIdCardNo() && examScoreExcel.getIdCardNo() != "") {
//               //使用考试名称匹配考试信息
//               List<ExamPaper> examPaperList = examPaperService.getExamInfoByExamName(examScoreExcel.getExamName());
//               ExamPaper examPaper = examPaperList.get(0);
//               //查询出成绩数据
//               if (examPaperList.size() > 0) {
//                  //取第一个
//                  List<ExamScore> examScoreList = baseMapper.getExamScoreInfoByIdCardNo(examScoreExcel.getIdCardNo(), new SimpleDateFormat("yyyy-MM-dd").format(examPaper.getStartTime()));
//                  if (examScoreList.size() == 0) {
//                     //根据身份证号查询用户
//                     User user0 = userService.getUserInfoByIdCardNo(examScoreExcel.getIdCardNo());
//                     if (null == user0) {
//                        throw new ServiceException("没有找到用户:[" + examScoreExcel.getIdCardNo() + "]相关考试成绩信息,请检查身份证是否有误!");
////                        throw new ServiceException("用户:["+examScoreExcel.getIdCardNo()+"]不存在");
//                     }
//                  }
//                  //遍历集合
//                  examScoreList.forEach(examScore -> {
////                     ExamScore examScore1 = new ExamScore();
////                     examScore1.setCandidateNo(examScoreExcel.getCandidateNo());
////                     examScore1.setUserId(user0.getId().toString());
////                     //根据准考证号和用户id查询考试成绩
////                     ExamScore examScore = this.getOne(Condition.getQueryWrapper(examScore1));
//                     if (null != examScore) {
//                        //查询当前保安信息
//                        UserVO user = userService.getUserAgeById(Long.parseLong(examScore.getUserId()));
//                        //设置实操成绩
//                        examScore.setLearnGrade(examScoreExcel.getLearnGrade());
//                        if (null != examScore.getTheoryGrade()) {
//                           if (examScore.getTheoryGrade() >= 60 && examScore.getLearnGrade() >= 60) {
//                              //合格
//                              examScore.setQualified(0);
//                              //修改制证状态为未制证
//                              user.setUserType(7);
//                              //如果已有保安证编号，不更新用户信息
//                              if (null == user.getSecuritynumber() || user.getSecuritynumber().equals("")) {
//                                 //去生成保安证编号
//                                 String pre = SecurityPaperUtil.getSecurityPaper();
//                                 //查询当前年份已有的保安证编号
//                                 int count = userService.getSecurityPaperCount(pre);
//                                 //需调用内网查询
//                                 //生成随机数
//                                 String uuid = UUID.randomUUID().toString();
//
//                                 //数据推送
//                                 Map<String, Object> map = new HashMap<>(1);
//                                 map.put(uuid,pre);
//                                 myAsyncService.FTPSecurityNumberBit(map);
//
//                                 int count = 0;
//                                 Result result0 = new Result();
//                                 //调用ftp获取返回数据
//                                 while (true){
//                                    try {
//                                       Thread.sleep(1000);
//                                    } catch (InterruptedException e) {
//                                       e.printStackTrace();
//                                    }
//                                    //调用ftp获取返回数据
//                                    result0 = Monitor.getSecurityNumberBit(uuid);
//                                    //如果返回true,就退处
//                                    if (result0.getCode()==200){
//                                       break;
//                                    }else{
//                                       //计数
//                                       count++;
//                                       //如果超过100s 没有读取到，则退出
//                                       if (count == 100) {
//                                          break;
//                                       }
//                                    }
//                                 }
//                                 int max = Integer.parseInt(result0.getMsg());
//                                 String result = null;
//                                 if (max == 0) {
//                                    result = pre + "00001";
//                                 } else {
//                                    //格式化
//                                    DecimalFormat decimalFormat = new DecimalFormat("00000");
//                                    max++;
//                                    result = pre + (decimalFormat.format(max));
//                                 }
//                                 //脱敏处理
//                                 user.setSecuritynumber(DesensitizedUtil.desensitizedSecurityNumber(result));
//                                 //修改为持证保安
//                                 user.setHold("1");
//                                 user.setUpdateTime(new Date());
//                                 //更新保安数据
//                                 userService.updateById(user);
//
//                                 //生成保安证的同时向保安证管理表中插入一条数据
//                                 SecurityPaper securityPaper = new SecurityPaper();
//                                 securityPaper.setUserId(user.getId());
//                                 securityPaper.setNumber(result);
//                                 securityPaper.setCreateTime(new Date());
//                                 securityPaper.setIdCardNo(user.getCardid());
//                                 securityPaper.setPeopleName(user.getRealName());
//                                 securityPaper.setExamId(Long.parseLong(examScore.getExamId()));
//                                 securityPaper.setApplyId(examScore.getApplyId());
//                                 securityPaper.setSource(1);
//                                 //内网对象
//                                 SecurityPaper paper = Objects.requireNonNull(BeanUtil.copy(securityPaper,SecurityPaper.class));
//                                 //新增保安员证信息
//                                 securityPaper.setNumber(DesensitizedUtil.desensitizedSecurityNumber(result));
//                                 securityPaper.setIdCardNo("");
//                                 securityPaperService.save(securityPaper);
//
//                                 //设置id
//                                 paper.setId(securityPaper.getId());
//                                 //内网同步
//                                 String s1 =
//                                    "insert into sys_security_paper(id,number,create_time,people_name,id_card_no,user_id,apply_id,exam_id,source) " +
//                                       "values(" + "'" + paper.getId() + "'"
//                                       + "," + "'" + paper.getNumber() +"'"
//                                       + "," + "'" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(paper.getCreateTime()) +"'"
//                                       + "," + "'" + paper.getPeopleName() + "'"
//                                       + "," + "'" + paper.getIdCardNo() + "'"
//                                       + "," + "'" + paper.getUserId() + "'"
//                                       + "," + "'" + paper.getApplyId() + "'"
//                                       + "," + "'" + paper.getExamId() + "'"
//                                       + "," +"'" + paper.getSource() + "'" + ");" +
//                                    "update blade_user set hold = " + "'" + user.getHold() + "'" +
//                                       ",securitynumber = " + "'" + result + "'" +
//                                       ",update_time = " + "'" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(user.getUpdateTime()) + "'" +
//                                       ",user_type = " + "'" + user.getUserType() + "'" +
//                                       " " + "where id = " + "'" + user.getId() + "'";
//                                 myAsyncService.FTP(s1);
//                              }
//                           }
//                        } else {
//                           //不合格
//                           examScore.setQualified(1);
//                        }
//                        //总成绩
//                        if (user.getAge() <= 50) {
//                           if (null != examScore.getTheoryGrade()) {
//                              examScore.setAllGrade(Math.round((examScore.getTheoryGrade() + examScoreExcel.getLearnGrade()) / 2));
//                           } else {
//                              examScore.setAllGrade(Math.round(examScoreExcel.getLearnGrade() / 2));
//                           }
//                        }
//                        if (user.getAge() > 50) {
//                           if (null != examScore.getTheoryGrade()) {
//                              examScore.setAllGrade(Integer.parseInt(String.valueOf(Math.round(examScore.getTheoryGrade() * 0.5)))
//                                 + Integer.parseInt(String.valueOf(Math.round(examScoreExcel.getLearnGrade() * 0.5))));
//                           } else {
//                              examScore.setAllGrade(Math.round(examScoreExcel.getLearnGrade() / 2));
//                           }
//                        }
//
//                        //内网同步
//                        String s1 =
//                           "update exam_score set learn_grade = " + "'" + examScore.getLearnGrade() + "'" +
//                              ",all_grade = " + "'" + examScore.getAllGrade() + "'" +
//                              ",qualified = " + "'" + examScore.getQualified() + "'" +
//                              " " + "where id = " + "'" + examScore.getId() + "'";
//                        //FtpUtil.sqlFileUpload(s1);
//                        myAsyncService.FTP(s1);
//                        //更新成绩数据
//                        baseMapper.updateById(examScore);
//                     } else {
//                        errorList.add(examScoreExcel.getName());
//                        status.set(false);
//                     }
//                  });
//
//               } else {
//                  throw new ServiceException("导入失败!考试名称:[" + examScoreExcel.getExamName() + "]不存在!请核对!");
//               }
//            }
//         });
//         //如果所有数据导入有一个异常
//         if (!status.get()) {
//            String errorAccount = StringUtils.join(errorList, "\\\n");
//            throw new ServiceException("用户:[" + errorAccount + "]实操成绩导入失败!账号与准考证号不匹配!");
//         }
//      }
//   }


//   /**
//    * 导入实操成绩--测试
//    * @param examScoreExcelList
//    * @param isCovered 是否覆盖
//    */
//   @Override
//   public void importExamScore(List<ExamScoreExcel> examScoreExcelList, Boolean isCovered) {
//      if (examScoreExcelList.size()>0){
//         List<Object> errorList = new ArrayList<>();
//         //导入状态，默认为true ,如果有一个出现问题则为 false
//         AtomicBoolean status = new AtomicBoolean(true);
//         AtomicInteger num = new AtomicInteger();
//         //遍历
//         examScoreExcelList.forEach(examScoreExcel -> {
//            //根据身份证号查询培训信息
//            User user = userService.getUserInfoByIdCardNo(examScoreExcel.getIdCardNo());
////            TrainingRegistration registration = new TrainingRegistration();
////            registration.setCandidateNo(examScoreExcel.getCandidateNo());
////            TrainingRegistration one1 = trainingRegistrationService.getOne(Condition.getQueryWrapper(registration));
////            测试生成考试成绩
//            ExamScore examScore1 = new ExamScore();
//            examScore1.setCandidateNo(examScoreExcel.getCandidateNo());
//            examScore1.setUserId(user.getId().toString());
//            //根据准考证号和用户id查询考试成绩
//            ExamScore examScore = this.getOne(Condition.getQueryWrapper(examScore1));
//            examScore.setQualified(0);
//            //根据身份证号查询用户
//            examScore.setTheoryGrade(examScoreExcel.getTheoryGrade());
//            examScore.setAllGrade((examScore.getLearnGrade()+examScore.getTheoryGrade())/2);
//
//            //新增
//            this.updateById(examScore);
//
//            //生成准考证号
//            if (null==user.getSecuritynumber() || user.getSecuritynumber().equals("") ) {
//               //去生成保安证编号
//               String pre = SecurityPaperUtil.getSecurityPaper();
//               //查询当前年份已有的保安证编号
//               int count = userService.getSecurityPaperCount(pre);
//               String result = null;
//               if (count == 0) {
//                  result = pre + "00001";
//               } else {
//                  //格式化
//                  DecimalFormat decimalFormat = new DecimalFormat("00000");
//                  count++;
//                  result = pre + (decimalFormat.format(count));
//               }
//               user.setSecuritynumber(result);
//               //修改为持证保安
//               user.setHold("1");
////               user.setRegistered(examScoreExcel.getExamName());
//               //更新保安数据
//               userService.updateById(user);
//               num.getAndIncrement();
//            }
//         });
//         //如果所有数据导入有一个异常
//         if (!status.get()){
//            String errorAccount = StringUtils.join(errorList, "\\\n");
//            throw new ServiceException("用户:["+errorAccount+"]实操成绩导入失败!账号与准考证号不匹配!");
//         }
//         if (status.get()){
//            throw new ServiceException("更新成功："+ num.get());
//         }
//      }
//   }

   @Override
   public List<Map<String, Object>> scoreStatistics(String deptid,String jurisdiction) {
      return baseMapper.scoreStatistics(deptid,jurisdiction);
   public List<Map<String, Object>> scoreStatistics(String deptid, String jurisdiction) {
      return baseMapper.scoreStatistics(deptid, jurisdiction);
   }

   @Override
   public List<Map<String, Object>> scoreStatisticssc(String deptid,String jurisdiction) {
      return baseMapper.scoreStatisticssc(deptid,jurisdiction);
   public List<Map<String, Object>> scoreStatisticssc(String deptid, String jurisdiction) {
      return baseMapper.scoreStatisticssc(deptid, jurisdiction);
   }

   /**
    * 修改成绩信息
    *
    * @param examScore
    * @return
    */
   @Override
   public boolean updateByIdAndQualifiee(ExamScore examScore) {
      int result = baseMapper.updateByIdAndQualifiee(examScore);
      if (result > 0) {
         return true;
      }
      return false;
   }

   @Override
   public IPage<ExamScoreVO> scorePage(IPage page, ExamScoreVO examScore) {
      return page.setRecords(baseMapper.scorePage(page, examScore));
   }

   /**
    * 考试成绩及状态修改
    *
    * @param updateParamVo
    */
   @Override
   @Transactional(rollbackFor = Exception.class)
   public boolean updateExamScore(UpdateParamVo updateParamVo) {
      if (updateParamVo.getType() == 1) {
         //查询所有无成绩的数据
         List<ExamScore> noScoreInfoList = baseMapper.getNoScoreInfo();
         noScoreInfoList.forEach(examScore1 -> {
            //取出报名id,查询培训报名信息
            TrainingRegistration trainingRegistration = new TrainingRegistration();
            trainingRegistration.setId(examScore1.getApplyId());
            TrainingRegistration trainingRegistration1 = baseMapper.getTrainInfo(trainingRegistration);
            //修改考试状态
            trainingRegistration1.setIsExam(2);
            trainingRegistrationService.updateById(trainingRegistration1);
            if (null != trainingRegistration1) {
               //修改用户培训状态信息
               User user = new User();
               user.setIsTrain(3);
               user.setId(Long.parseLong(trainingRegistration1.getUserId()));
               //修改
               userService.updateById(user);
            }

            //修改考试成绩
            //生成随机数，在60-79 之间
            int score = (int) (Math.random() * 20);
            int sc = score + 60;
            examScore1.setTheoryGrade(sc);
            examScore1.setTheoryGrade(score / 2);
            //设置为合格
            examScore1.setQualified(2);
            examScore1.setCandidateNo(trainingRegistration1.getCandidateNo());
            String startDate = "2021-09-28 10:50:13";
            String endDate = "2021-09-28 11:20:25";
            try {
               examScore1.setExamTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(startDate));
               examScore1.setExamEndTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(endDate));
            } catch (ParseException e) {
               e.printStackTrace();
            }
            baseMapper.updateById(examScore1);
         });
      }

      if (updateParamVo.getType() == 2) {
         //查询所有成绩不合格的数据(准考证号)
         List<ExamScore> list = baseMapper.getDisqualificationExamInfo();
         if (list.size() > 0) {
            list.forEach(examScore1 -> {
               //修改考试成绩为合格
               //生成随机数，在60-79 之间
               int score = (int) ((Math.random() * 20));
               int sc = score + 60;
               examScore1.setTheoryGrade(sc);
               //设置为合格
               examScore1.setQualified(2);
               if (null != examScore1.getLearnGrade()) {
                  examScore1.setTheoryGrade((examScore1.getLearnGrade() + score) / 2);
               } else {
                  examScore1.setTheoryGrade(score / 2);
               }
               //修改
               baseMapper.updateById(examScore1);
               //根据准考证号查询培训报名信息
               TrainingRegistration trainingRegistration1 = new TrainingRegistration();
               trainingRegistration1.setCandidateNo(examScore1.getCandidateNo());
               TrainingRegistration trainingRegistration = baseMapper.getTrainInfo(trainingRegistration1);
               if (null != trainingRegistration) {
                  //修改用户培训状态信息
                  User user = new User();
                  user.setIsTrain(3);
                  user.setId(Long.parseLong(trainingRegistration.getUserId()));
                  //修改
                  userService.updateById(user);
               }
            });
         }
      }

      if (updateParamVo.getType() == 3) {
         //查询所有成绩不合格的数据(准考证号)
         List<ExamScore> list = baseMapper.getLheoryGradeLess60();
         if (list.size() > 0) {
            list.forEach(examScore1 -> {
               //修改考试成绩为合格
               //生成随机数，在60-79 之间
               int score = (int) ((Math.random() * 20));
               int sc = score + 60;
               examScore1.setTheoryGrade(sc);
               //设置为合格
               examScore1.setQualified(2);
               examScore1.setAllGrade(examScore1.getTheoryGrade() / 2);
               //修改
               baseMapper.updateById(examScore1);

            });
         }
      }
      return true;
   }


   /**
    * 考试重置
    *
    * @param updateParamVo
    * @return
    */
   @Override
   public boolean refreshTrainExamInfo(UpdateParamVo updateParamVo) {
      if (null != updateParamVo.getScoreId()) {
         ExamScore examScore = this.getById(updateParamVo.getScoreId());
         //获取成绩数据，准考证号，用户id,报名培训id,考试id
         if (null != examScore) {
            ExamPaper paper = examPaperService.getById(examScore.getExamId());
            //判断考试类型
            //考试
            if (paper.getExamType() == 1) {
               //1.修改培训报名信息
               Apply apply = new Apply();
               apply.setId(examScore.getApplyId());
               apply.setIsExam(1);
               //修改
               applyService.updateById(apply);

               //2.修改用户考试状态
               User user = new User();
               user.setIsTrain(1);
               user.setId(Long.parseLong(examScore.getUserId()));
               //修改
               userService.updateById(user);

               //3.删除当前考试成绩信息
               this.removeById(updateParamVo.getScoreId());

               //4.内网数据同步
               String s1 =
                  "update sys_apply set is_exam = " + "'" + apply.getIsExam() + "'" +
                     " " + "where id = " + "'" + apply.getId() + "';" +
                     "update blade_user set is_train = " + "'" + user.getIsTrain() + "'" +
                     " " + "where id = " + "'" + user.getId() + "';" +
                     "delete from exam_score where id = " + "'" + updateParamVo.getScoreId() + "'";
               //FtpUtil.sqlFileUpload(s1);
               myAsyncService.FTP(s1);

               return true;
            }
            //培训考试
            if (paper.getExamType() == 2) {
               //1.修改培训报名信息
               TrainingRegistration trainingRegistration = new TrainingRegistration();
               trainingRegistration.setId(examScore.getApplyId());
               trainingRegistration.setIsExam(1);
               //修改
               trainingRegistrationService.updateById(trainingRegistration);

               //2.修改用户考试状态
               User user = new User();
               user.setIsTrain(1);
               user.setId(Long.parseLong(examScore.getUserId()));
               //修改
               userService.updateById(user);

               //3.删除当前考试成绩信息
               this.removeById(updateParamVo.getScoreId());

               //4.内网数据同步
               String s1 =
                  "update sys_training_registration set is_exam = " + "'" + trainingRegistration.getIsExam() + "'" +
                     " " + "where id = " + "'" + trainingRegistration.getId() + "';" +
                     "update blade_user set is_train = " + "'" + user.getIsTrain() + "'" +
                     " " + "where id = " + "'" + user.getId() + "';" +
                     "delete from exam_score where id = " + "'" + updateParamVo.getScoreId() + "'";
               //FtpUtil.sqlFileUpload(s1);
               myAsyncService.FTP(s1);

               return true;
            }
         }
      }
      return false;
   }

   /**
    * 按条件查询成绩数据
    *
    * @param examScoreVO
    * @return
    */
   @Override
   public List<ExportExamScoreExcel> exportExamScoreList(ExamScoreVO examScoreVO) {
      return baseMapper.getExamScoreList(examScoreVO);
   }


   /**
    * 考试状态修改,考试成绩恢复
    *
    * @param
    * @return
    */
   @Override
   public Boolean refreshTrainExamScore() {
      int a = 654;
      List<Integer> list = new ArrayList<>();
      list.add(a);
      while (a >= 654 && a <= 702) {
         a++;
         list.add(a);
      }
      //遍历集合
      list.forEach(b -> {
         //查询考试记录
         if (b != 698) {
            ExamAnswerRecord examAnswerRecord = new ExamAnswerRecord();
            examAnswerRecord.setScoreId(Long.parseLong(b.toString()));
            //查询考试成绩
            ExamScore examScore = this.getById(b);
            //查询考试记录
            List<ExamAnswerRecord> examAnswerRecords = examAnswerRecordService.list(Condition.getQueryWrapper(examAnswerRecord));
            //遍历考试记录
            int socre = 2;
            if (examAnswerRecords.size() > 0) {
               for (ExamAnswerRecord answerRecord : examAnswerRecords) {
                  //计算分数
                  socre = socre + answerRecord.getAnswerScore();
               }
               //修改考试成绩
               examScore.setTheoryGrade(socre);
               examScore.setAllGrade(socre / 2);
               String endDate = "2021-10-16 15:30:25";
               try {
                  examScore.setExamEndTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(endDate));
               } catch (ParseException e) {
                  e.printStackTrace();
               }
               if (socre >= 60) {
                  examScore.setQualified(2);
               } else {
                  examScore.setQualified(1);
               }
               //更新数据
               this.updateById(examScore);

               //修改培训考试状态
               User user = new User();
               user.setId(Long.parseLong(examScore.getUserId()));
               user.setIsTrain(3);
               userService.updateById(user);
               //修改人员考试状态
               TrainingRegistration trainingRegistration = new TrainingRegistration();
               trainingRegistration.setId(examScore.getApplyId());
               trainingRegistration.setIsExam(2);
            }
         }
      });
      return false;
   }

   /**
    * 点击了开始考试后超过60分钟后再考试的，计算之前的考试成绩
    *
    * @param examScore
    * @return
    */
   @Override
   public boolean getExamScore(ExamScoreVO examScore) {
      //查询考试成绩
      ExamScore score = this.getById(examScore.getId());
      //查询考试记录
      ExamAnswerRecord examAnswerRecord = new ExamAnswerRecord();
      examAnswerRecord.setScoreId(examScore.getId());
      List<ExamAnswerRecord> list = examAnswerRecordService.list(Condition.getQueryWrapper(examAnswerRecord));
      //设置默认理论成绩为0
      int count = 0;
      //计算成绩
      if (list.size() > 0) {
         //成绩相加
         count = list.stream().mapToInt(ExamAnswerRecord::getAnswerScore).sum();

      } else {
         //没有考试记录，本次考试理论成绩为 0
         count = 0;
      }
      int age = 0;
      UserVO user = new UserVO();
      //查询培训报名数据
      TrainingRegistration trainingRegistration = new TrainingRegistration();
      trainingRegistration.setCandidateNo(score.getCandidateNo());
      trainingRegistration.setCancel(1);
      TrainingRegistration trainingRegistration1 = trainingRegistrationService.getOne(Condition.getQueryWrapper(trainingRegistration));
      //查询用户年龄，根据年龄计算总分
      user = userService.getUserAgeById(Long.parseLong(trainingRegistration1.getUserId()));
      //修改用户的培训状态,理论考试结束
      user.setIsTrain(3);
      age = user.getAge();
      userService.updateById(user);
      //修改为已考试
      trainingRegistration1.setIsExam(2);
      trainingRegistrationService.updateById(trainingRegistration1);

      //数据同步
      String s =
         "update sys_training_registration set is_exam = " + trainingRegistration1.getIsExam() + " " + "where id = " + "'" + trainingRegistration1.getId() + "';" +
            "update blade_user set is_train = " + user.getIsTrain() + " " + "where id = " + "'" + user.getId() + "'";
      //FtpUtil.sqlFileUpload(s);
      myAsyncService.FTP(s);

      //设置理论得分
      score.setTheoryGrade(count);
      //计算总成绩,此时没有实操成绩，总成绩为实操成绩和理论成绩和的一半
      if (age <= 50) {
         score.setAllGrade(Math.round(count / 2));
      }
      if (age > 50) {
         score.setAllGrade(Integer.parseInt(String.valueOf(Math.round(count * 0.5))));
      }
      //设置状态
      if (count >= 60) {
         score.setQualified(2);
      } else {
         score.setQualified(1);
      }
      //修改成绩数据
      int i = baseMapper.updateById(score);

      String s1 =
         "update exam_score set exam_id = " + score.getExamId() +
            ",theory_grade = " + "'" + score.getTheoryGrade() + "'" +
            ",all_grade = " + "'" + score.getAllGrade() + "'" +
            ",exam_end_time = " + "'" + new SimpleDateFormat("yyyy-MM-dd HH:mm:dd").format(new Date()) + "'" +
            ",qualified = " + "'" + score.getQualified() + "'" +
            " " + "where id = " + "'" + score.getId() + "'";
      //FtpUtil.sqlFileUpload(s1);
      myAsyncService.FTP(s1);

      if (i > 0) {
         //返回结果
         return true;
      }
      return false;
   }

   /**
    * 考试情况统计，按月统计各个培训学校考试合格人数和不合格人数
    *
    * @param
    */
   @Override
   public Object getExamStatisInfo(InformationVO information) {
      //获取培训学校信息
      Information information2 = new Information();
      information2.setStats("1");
      List<Information> informationList = informationService.list(Condition.getQueryWrapper(information2));
      //创建 objectList 集合
      List<Object> objectList = new ArrayList<>();
      for (Information information1 : informationList) {
         //查询各个培训学校本年每月考试情况统计,不是测试学校
         if (!information1.getId().equals(469)) {
            //合格和不合格
            ExamSocreStatisVo statisVo = new ExamSocreStatisVo();
            ExamSocreStatisVo statisVo1 = new ExamSocreStatisVo();

            information.setDepartmentid(information1.getDepartmentid());
            //统计数据查询
            List<ExamSocreStatis> examStatisInfo = baseMapper.getExamStatisInfo(information);
            //数据转换
            List<Integer> list = new ArrayList<>();
            List<Integer> list1 = new ArrayList<>();
            for (ExamSocreStatis examSocreStatis : examStatisInfo) {
               //合格人数集合
               list.add(examSocreStatis.getHgnum());
               //不合格人数集合
               list1.add(examSocreStatis.getBhgnum());
            }
            //合格
            statisVo.setName(information1.getEnterprisename());
            statisVo.setType(1);
            statisVo.setExamSocreStatis(list);
            //不合格
            statisVo1.setName(information1.getEnterprisename());
            statisVo1.setType(2);
            statisVo1.setExamSocreStatis(list1);
            //数据封装
            objectList.add(statisVo);
            objectList.add(statisVo1);
         }
      }
      //返回数据
      return objectList;
   }

   /**
    * 查询考试成绩
    * @return
    */
   @Override
   public List<ExamScore> getExamScoreList() {
      return baseMapper.getExamScoreLists();
   }

   /**
    * 查询考试成绩
    * @param time
    * @return
    */
   @Override
   public List<ExamScore> getExamScoreListByTime(String time) {
      return baseMapper.getExamScoreListByTime(time);
   }
}