|
package org.springblade.modules.exam.service.impl;
|
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
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.*;
|
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.*;
|
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.*;
|
import java.util.concurrent.atomic.AtomicBoolean;
|
import java.util.concurrent.atomic.AtomicInteger;
|
|
/**
|
* 考试成绩服务实现类
|
*
|
* @author zhongrj
|
*/
|
@Service
|
public class ExamScoreServiceImpl extends ServiceImpl<ExamScoreMapper, ExamScore> implements ExamScoreService {
|
|
@Autowired
|
private IUserService userService;
|
|
@Autowired
|
private ExamSubjectChoicesService examSubjectChoicesService;
|
|
@Autowired
|
private ExamPaperService examPaperService;
|
|
@Autowired
|
private ApplyService applyService;
|
|
@Autowired
|
private TrainingRegistrationService trainingRegistrationService;
|
|
@Autowired
|
private SecurityPaperService securityPaperService;
|
|
@Autowired
|
private ExamAnswerRecordService examAnswerRecordService;
|
|
@Autowired
|
private IInformationService informationService;
|
@Autowired
|
private MyAsyncService myAsyncService;
|
|
|
/**
|
* 自定义分页数据
|
*
|
* @param page 分页条件
|
* @param examScore 考试成绩对象
|
* @return
|
*/
|
@Override
|
public IPage<ExamScoreVO> selectExamScorePage(IPage<ExamScoreVO> page, ExamScoreVO examScore) {
|
if (null != examScore.getExamType()) {
|
if (examScore.getExamType() == 1) {
|
return page.setRecords(baseMapper.selectExamScorePage(page, examScore));
|
}
|
if (examScore.getExamType() == 2) {
|
return page.setRecords(baseMapper.selectTrainExamScorePage(page, examScore));
|
}
|
}
|
return page.setRecords(baseMapper.selectExamScorePage(page, examScore));
|
}
|
|
/**
|
* 详情
|
*
|
* @param examScore 考试成绩信息对象
|
*/
|
@Override
|
public ExamScoreVO selectExamScoreInfo(ExamScore examScore) {
|
return baseMapper.selectExamScoreInfo(examScore);
|
}
|
|
/**
|
* 保存考试成绩
|
*
|
* @param examScore 考试成绩信息对象
|
* @return
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Boolean saveExamScore(ExamScoreVO examScore) {
|
//取出考试结果
|
if (examScore.getExamResultVOS().size() > 0) {
|
ExamScore score = this.getById(examScore.getId());
|
List<ExamResultVO> examResultVOS = examScore.getExamResultVOS();
|
//获取试卷的内容（题号，答案）
|
// ExamPaper examPaper = new ExamPaper();
|
// examPaper.setId(examScore.getPapersId());
|
// List<ExamExaminationSubject> examExaminationSubjects
|
// = examPaperService.PagerSubject(examPaper).getExamExaminationSubjects();
|
List<ExamSubjectChoices> list = examSubjectChoicesService.list();
|
//比对考试结果
|
//声明理论得分
|
int theoryGrade = 0;
|
for (ExamResultVO examResultVO : examResultVOS) {
|
for (ExamSubjectChoices es : list) {
|
//对比题目id
|
if (examResultVO.getSubjectChoicesId().equals(es.getId())) {
|
//对比答案
|
if (es.getChoicesType() == 2 || es.getChoicesType() == 3) {
|
//判断题逻辑
|
if (examResultVO.getValue().equals(es.getAnswer())) {
|
theoryGrade += examResultVO.getGrade();
|
}
|
} else if (es.getChoicesType() == 0 || es.getChoicesType() == 1) {
|
//处理多选题的答案排序
|
String[] split = examResultVO.getValue().split(",");
|
StringBuilder builder = new StringBuilder();
|
for (String s : split) {
|
builder.append(s);
|
}
|
char[] arrayCh = builder.toString().toCharArray();
|
//利用数组帮助类自动排序
|
Arrays.sort(arrayCh);
|
String sub0 = Arrays.toString(arrayCh);
|
String sub = sub0.substring(1, sub0.length() - 1).replaceAll(" ", "");
|
if (sub.equals(es.getAnswer())) {
|
theoryGrade += examResultVO.getGrade();
|
}
|
}
|
//移除当前试卷题目答案对象
|
list.remove(es);
|
break;
|
}
|
}
|
}
|
//获取考试信息
|
ExamPaper paper = examPaperService.getById(examScore.getPapersId());
|
int age = 0;
|
UserVO user = new UserVO();
|
//使用准考证号查询报名信息，修改考试状态为已考试
|
if (paper.getExamType() == 1) {
|
Apply apply = new Apply();
|
apply.setCandidateNo(examScore.getCandidateNo());
|
Apply apply1 = applyService.getOne(Condition.getQueryWrapper(apply));
|
//查询用户年龄，根据年龄计算总分
|
user = userService.getUserAgeById(apply1.getUserId());
|
//修改用户的考试状态,理论考试结束
|
user.setIsApply(3);
|
userService.updateById(user);
|
age = user.getAge();
|
//修改为已考试
|
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);
|
myAsyncService.FTP(s);
|
|
}
|
//培训考试
|
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();
|
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);
|
}
|
//设置提交时间
|
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))));
|
}
|
//设置状态
|
if (theoryGrade >= 60) {
|
examScore.setQualified(2);
|
} else {
|
examScore.setQualified(1);
|
}
|
//修改成绩数据
|
// int i = baseMapper.updateById(examScore);
|
|
String s1 =
|
"update exam_score set exam_id = " + examScore.getExamId() +
|
",theory_grade = " + "'" + examScore.getTheoryGrade() + "'" +
|
",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);
|
myAsyncService.FTP(s1);
|
|
// if (i > 0) {
|
//返回结果
|
return true;
|
// }
|
}
|
//返回结果
|
return false;
|
}
|
|
/**
|
* 导入实操成绩
|
*
|
* @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);
|
// //遍历
|
// 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);
|
}
|
|
@Override
|
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();
|
}
|
}
|
