527 lines
22 KiB
Java
527 lines
22 KiB
Java
package com.peanut.modules.common.controller;
|
|
|
|
import cn.hutool.core.date.DateUtil;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
|
import com.github.promeg.pinyinhelper.Pinyin;
|
|
import com.peanut.common.utils.DateUtils;
|
|
import com.peanut.common.utils.R;
|
|
import com.peanut.common.utils.ShiroUtils;
|
|
import com.peanut.modules.common.dao.ClassExamUserDao;
|
|
import com.peanut.modules.common.entity.*;
|
|
import com.peanut.modules.common.service.ClassEntityService;
|
|
import com.peanut.modules.common.service.ClassExamUserService;
|
|
import com.peanut.modules.common.service.MyUserService;
|
|
import com.peanut.modules.common.service.UserCertificateService;
|
|
import com.peanut.modules.medical.service.CourseService;
|
|
import lombok.extern.slf4j.Slf4j;
|
|
import org.apache.commons.lang.ArrayUtils;
|
|
import org.apache.commons.lang.StringUtils;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
import org.springframework.data.redis.core.StringRedisTemplate;
|
|
import org.springframework.transaction.annotation.Transactional;
|
|
import org.springframework.web.bind.annotation.RequestBody;
|
|
import org.springframework.web.bind.annotation.RequestMapping;
|
|
import org.springframework.web.bind.annotation.RestController;
|
|
|
|
import javax.imageio.ImageIO;
|
|
import java.math.BigDecimal;
|
|
import java.net.URL;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
@Slf4j
|
|
@RestController("commonClass")
|
|
@RequestMapping("common/class")
|
|
public class ClassController {
|
|
|
|
@Autowired
|
|
private ClassEntityService classEntityService;
|
|
@Autowired
|
|
private UserCertificateService userCertificateService;
|
|
@Autowired
|
|
private CourseService courseService;
|
|
@Autowired
|
|
private ClassExamUserService classExamUserService;
|
|
@Autowired
|
|
private StringRedisTemplate redisTemplate;
|
|
|
|
//班级模型列表
|
|
@RequestMapping("/getClassModelList")
|
|
public R getClassModelList(@RequestBody Map<String,Object> params){
|
|
Page classModelList = classEntityService.getClassModelList(params);
|
|
return R.ok().put("page",classModelList);
|
|
}
|
|
|
|
//新增班级模型
|
|
@RequestMapping("/addClassModel")
|
|
public R addClassModel(@RequestBody ClassModel classModel){
|
|
String[] courseIds = classModel.getCourseIds().split(",");
|
|
if(courseIds.length > 0){
|
|
HashSet<String> set = new HashSet<>();
|
|
for (String courseId : courseIds) {
|
|
if (!set.add(courseId)){
|
|
return R.error("课程不能重复");
|
|
}
|
|
}
|
|
}
|
|
int score = 0;
|
|
if (classModel.getIsQuestion()==1){
|
|
score += classModel.getQuestionScore();
|
|
}
|
|
if (classModel.getIsTask()==1){
|
|
score += classModel.getTaskScore();
|
|
}
|
|
if (classModel.getIsMedicalcase()==1){
|
|
score += classModel.getMedicalcaseScore();
|
|
}
|
|
if (classModel.getIsExperience()==1){
|
|
score += classModel.getExperienceScore();
|
|
}
|
|
if (classModel.getIsExam()==1){
|
|
score += classModel.getExamScore();
|
|
}
|
|
if (score==100){
|
|
return classEntityService.addClassModel(classModel);
|
|
}else {
|
|
return R.error("请设置各模块占比总和为100");
|
|
}
|
|
}
|
|
|
|
//修改班级模型
|
|
@RequestMapping("/editClassModel")
|
|
public R editClassModel(@RequestBody ClassModel classModel){
|
|
String[] courseIds = classModel.getCourseIds().split(",");
|
|
if(courseIds.length > 0){
|
|
HashSet<String> set = new HashSet<>();
|
|
for (String courseId : courseIds) {
|
|
if (!set.add(courseId)){
|
|
return R.error("课程不能重复");
|
|
}
|
|
}
|
|
}
|
|
int score = 0;
|
|
if (classModel.getIsQuestion()==1){
|
|
score += classModel.getQuestionScore();
|
|
}
|
|
if (classModel.getIsTask()==1){
|
|
score += classModel.getTaskScore();
|
|
}
|
|
if (classModel.getIsMedicalcase()==1){
|
|
score += classModel.getMedicalcaseScore();
|
|
}
|
|
if (classModel.getIsExperience()==1){
|
|
score += classModel.getExperienceScore();
|
|
}
|
|
if (classModel.getIsExam()==1){
|
|
score += classModel.getExamScore();
|
|
}
|
|
if (score==100){
|
|
return classEntityService.editClassModel(classModel);
|
|
}else {
|
|
return R.error("请设置各模块占比总和为100");
|
|
}
|
|
}
|
|
|
|
//获取模型可选课程
|
|
@RequestMapping("/getClassModelCourseList")
|
|
public R getClassModelCourseList(@RequestBody Map<String,Object> params){
|
|
List<CourseEntity> courseList = classEntityService.getClassModelCourseList(params);
|
|
return R.ok().put("courseList",courseList);
|
|
}
|
|
|
|
//获取主任下的班级模型
|
|
@RequestMapping("/getClassModelByUserid")
|
|
public R getClassModelByUserid(@RequestBody Map<String,Object> params){
|
|
List<ClassModel> classModelList = classEntityService.getClassModelByUserid(params);
|
|
return R.ok().put("classModelList",classModelList);
|
|
}
|
|
|
|
//获取主任下的班级
|
|
@RequestMapping("/getClassByDirectorid")
|
|
public R getClassByDirectorid(@RequestBody Map<String,Object> params){
|
|
return R.ok().put("classEntityList",classEntityService.getClassByDirectorid(params));
|
|
}
|
|
|
|
//获取班级列表
|
|
@RequestMapping("/getClassList")
|
|
public R getClassList(@RequestBody Map<String,Object> params){
|
|
Page classList = classEntityService.getClassList(params);
|
|
return R.ok().put("page",classList);
|
|
}
|
|
|
|
//新增班级
|
|
@RequestMapping("/addClass")
|
|
public R addClass(@RequestBody ClassEntity classEntity){
|
|
return classEntityService.addClass(classEntity);
|
|
}
|
|
|
|
//开班
|
|
@RequestMapping("/openClass")
|
|
public R openClass(@RequestBody Map<String,Object> params){
|
|
return classEntityService.openClass(params);
|
|
}
|
|
|
|
//修改班级
|
|
@RequestMapping("/editClass")
|
|
public R editClass(@RequestBody Map<String,Object> params){
|
|
if (classEntityService.editClass(params)){
|
|
return R.ok();
|
|
}else {
|
|
return R.error("修改出错");
|
|
}
|
|
}
|
|
|
|
//设置班委
|
|
@RequestMapping("/setUserRole")
|
|
public R setUserRole(@RequestBody Map<String,Object> params){
|
|
return classEntityService.setUserRole(params);
|
|
}
|
|
|
|
//获取用户在班级中角色
|
|
@RequestMapping("/getUserRole")
|
|
public R getUserRole(@RequestBody Map<String,Object> params){
|
|
return R.ok().put("result",classEntityService.getUserRole(params));
|
|
}
|
|
|
|
//获取用户拥有角色类型
|
|
@RequestMapping("/getRoleType")
|
|
public R getRoleType(){
|
|
return R.ok().put("result",classEntityService.getRoleType());
|
|
}
|
|
|
|
//删除班级
|
|
@RequestMapping("/delClass")
|
|
public R delClass(@RequestBody Map<String,Object> params){
|
|
return classEntityService.delClass(params);
|
|
}
|
|
|
|
//获取班级详情
|
|
@RequestMapping("/getClassInfo")
|
|
public R getClassInfo(@RequestBody Map<String,Object> params){
|
|
return R.ok().put("result",classEntityService.getClassInfo(params));
|
|
}
|
|
|
|
//同一小班未开班小班
|
|
@RequestMapping("/getNoOpenClassSameClass")
|
|
public R getNoOpenClassSameClass(@RequestBody Map<String,Object> params){
|
|
return R.ok().put("result",classEntityService.getNoOpenClassSameClass(params));
|
|
}
|
|
|
|
//查询未加入小班
|
|
@RequestMapping("/getClassNoUser")
|
|
public R getClassNoUser(){
|
|
return R.ok().put("result",classEntityService.getClassNoUser());
|
|
}
|
|
|
|
//查询包含课程的小班(登陆人未加入)
|
|
@RequestMapping("/getClassByCourseIdNoUser")
|
|
public R getClassByCourseIdNoUser(@RequestBody Map<String,Object> params){
|
|
return R.ok().put("result",classEntityService.getClassByCourseIdNoUser(params));
|
|
}
|
|
|
|
//查询登陆人已加入小班
|
|
@RequestMapping("/getClassByUser")
|
|
public R getClassByUser(@RequestBody Map<String,Object> params){
|
|
return R.ok().put("result",classEntityService.getClassByUser(params));
|
|
}
|
|
|
|
//加入小班前查询用户买课情况
|
|
@RequestMapping("/getUserCourseBuy")
|
|
public R getUserCourseBuy(@RequestBody Map<String,Object> params){
|
|
return classEntityService.getUserCourseBuy(params);
|
|
}
|
|
|
|
//加入小班
|
|
@RequestMapping("/joinClass")
|
|
public R joinClass(@RequestBody Map<String,Object> params){
|
|
return classEntityService.joinClass(params);
|
|
}
|
|
|
|
//退出小班
|
|
@RequestMapping("/quitClass")
|
|
public R quitClass(@RequestBody Map<String,Object> params){
|
|
classEntityService.quitClass(params);
|
|
return R.ok();
|
|
}
|
|
|
|
//我的小班列表
|
|
@RequestMapping("/MyClassList")
|
|
public R MyClassList(@RequestBody Map<String,Object> params){
|
|
return R.ok().put("result",classEntityService.MyClassList(params));
|
|
}
|
|
|
|
//新增班级任务医案心得
|
|
@RequestMapping("/addClassTask")
|
|
public R addClassTask(@RequestBody ClassTask classTask){
|
|
classEntityService.addClassTask(classTask);
|
|
return R.ok();
|
|
}
|
|
|
|
//删除任务
|
|
@RequestMapping("/delClassTask")
|
|
public R delClassTask(@RequestBody Map<String,Object> params){
|
|
classEntityService.delClassTask(params);
|
|
return R.ok();
|
|
}
|
|
|
|
//生成班级任务
|
|
@RequestMapping("/generateClassTask")
|
|
public R generateClassTask(@RequestBody Map<String,Object> params){
|
|
classEntityService.generateClassTask(params);
|
|
return R.ok();
|
|
}
|
|
|
|
//获取班级任务列表
|
|
@RequestMapping("/getClassTaskList")
|
|
public R getClassTaskList(@RequestBody Map<String,Object> params){
|
|
Page classTaskList = classEntityService.getClassTaskList(params);
|
|
return R.ok().put("page",classTaskList);
|
|
}
|
|
|
|
//获取班级任务列表(学员)
|
|
@RequestMapping("/getClassTaskListStudent")
|
|
public R getClassTaskListStudent(@RequestBody Map<String,Object> params){
|
|
Page classTaskList = classEntityService.getClassTaskListStudent(params);
|
|
return R.ok().put("page",classTaskList);
|
|
}
|
|
|
|
//编辑班级任务医案心得
|
|
@RequestMapping("/editClassTask")
|
|
public R editClassTask(@RequestBody ClassTask classTask){
|
|
classEntityService.editClassTask(classTask);
|
|
return R.ok();
|
|
}
|
|
|
|
//获取任务详情
|
|
@RequestMapping("/getClassTaskInfo")
|
|
public R getClassTaskInfo(@RequestBody Map<String,Object> params){
|
|
return R.ok().put("result",classEntityService.getClassTaskInfo(params));
|
|
}
|
|
|
|
//获取任务详情学员
|
|
@RequestMapping("/getClassTaskInfoStudent")
|
|
public R getClassTaskInfoStudent(@RequestBody Map<String,Object> params){
|
|
ClassTask classTask = classEntityService.getClassTaskInfoStudent(params);
|
|
return R.ok().put("classTask",classTask);
|
|
}
|
|
|
|
//新增作业
|
|
@RequestMapping("/addClassTaskAndQuesReply")
|
|
public R addClassTaskAndQuesReply(@RequestBody ClassTaskAndQuesReply classTaskAndQuesReply){
|
|
ClassEntity classEntity = classEntityService.getById(classTaskAndQuesReply.getClassId());
|
|
if ("3".equals(classEntity.getState())) {
|
|
return R.error("考试周禁止提交作业");
|
|
}
|
|
int res = classEntityService.addClassTaskAndQuesReply(classTaskAndQuesReply);
|
|
if (res==2){
|
|
return R.error("已提交");
|
|
}else if (res==1){
|
|
return R.ok();
|
|
}else {
|
|
return R.error("提交失败");
|
|
}
|
|
}
|
|
|
|
//通过任务获取作业列表
|
|
@RequestMapping("/getReplyListByTaskId")
|
|
public R getReplyListByTaskId(@RequestBody Map<String,Object> params){
|
|
Page classTaskAndQuesReplyList = classEntityService.getReplyListByTaskId(params);
|
|
return R.ok().put("page",classTaskAndQuesReplyList);
|
|
}
|
|
|
|
//通过任务获取作业列表(学员)
|
|
@RequestMapping("/getReplyListByTaskIdStudent")
|
|
public R getReplyListByTaskIdStudent(@RequestBody Map<String,Object> params){
|
|
Page classTaskAndQuesReplyList = classEntityService.getReplyListByTaskIdStudent(params);
|
|
return R.ok().put("page",classTaskAndQuesReplyList);
|
|
}
|
|
|
|
//心得评分
|
|
@RequestMapping("/editTaskScore")
|
|
public R editTaskScore(@RequestBody Map<String,Object> params){
|
|
return classEntityService.editTaskScore(params);
|
|
}
|
|
|
|
//打分
|
|
@RequestMapping("/editScore")
|
|
public R editScore(@RequestBody Map<String,Object> params){
|
|
return classEntityService.editScore(params);
|
|
}
|
|
|
|
//编辑作业
|
|
@RequestMapping("/editClassTaskAndQuesReply")
|
|
public R editClassTaskAndQuesReply(@RequestBody ClassTaskAndQuesReply classTaskAndQuesReply){
|
|
classEntityService.editClassTaskAndQuesReply(classTaskAndQuesReply);
|
|
return R.ok();
|
|
}
|
|
|
|
//作业详情
|
|
@RequestMapping("/getClassTaskAndQuesReplyInfo")
|
|
public R getClassTaskAndQuesReplyInfo(@RequestBody Map<String,Object> params){
|
|
ClassTaskAndQuesReply classTaskAndQuesReply = classEntityService.getClassTaskAndQuesReplyInfo(params);
|
|
return R.ok().put("classTaskAndQuesReply", classTaskAndQuesReply);
|
|
}
|
|
|
|
//课后题详情
|
|
@RequestMapping("/getQuesReplyInfo")
|
|
public R getQuesReplyInfo(@RequestBody Map<String,Object> params){
|
|
ClassTaskAndQuesReply classTaskAndQuesReply = classEntityService.getQuesReplyInfo(params);
|
|
return R.ok().put("classTaskAndQuesReply", classTaskAndQuesReply);
|
|
}
|
|
|
|
//思考题列表
|
|
@RequestMapping("/getThinkQuestionList")
|
|
public R getThinkQuestionList(@RequestBody Map<String,Object> params){
|
|
return R.ok().put("thinkQuestionList",classEntityService.getThinkQuestionList(params));
|
|
}
|
|
|
|
//思考题列表(学员)
|
|
@RequestMapping("/getThinkQuestionListStudent")
|
|
public R getThinkQuestionListStudent(@RequestBody Map<String,Object> params){
|
|
return R.ok().put("getThinkQuestionListStudent",classEntityService.getThinkQuestionListStudent(params));
|
|
}
|
|
|
|
//学员成绩
|
|
@RequestMapping("/getUserScore")
|
|
public R getUserScore(@RequestBody Map<String,Object> params){
|
|
return R.ok().put("result",classEntityService.getUserScore(params));
|
|
}
|
|
|
|
//学员成绩列表
|
|
@RequestMapping("/userScoreList")
|
|
public R userScoreList(@RequestBody Map<String,Object> params){
|
|
return R.ok().put("result",classEntityService.userScoreList(params));
|
|
}
|
|
|
|
//结班
|
|
@RequestMapping("/closeClass")
|
|
@Transactional
|
|
public R closeClass(@RequestBody Map<String,Object> params){
|
|
//结班限制
|
|
R r = classEntityService.closeClass(params);
|
|
//结班后给合格学员发放证书
|
|
if ("0".equals(r.get("code").toString())){
|
|
ClassEntity classEntity = classEntityService.getById(params.get("classId").toString());
|
|
List<Map<String,Object>> userScoreList = classEntityService.userScoreList(params);
|
|
for (Map<String, Object> userScoreMap : userScoreList) {
|
|
if (new BigDecimal(userScoreMap.get("userScore").toString()).compareTo(new BigDecimal(60))>=0){
|
|
UserCertificate userCertificate = new UserCertificate();
|
|
userCertificate.setTitle(classEntity.getTitle());
|
|
String type = "B";
|
|
if (new BigDecimal(userScoreMap.get("userScore").toString()).compareTo(new BigDecimal(70))>=0){
|
|
type = "A";
|
|
}
|
|
userCertificate.setType(type);
|
|
MyUserEntity user = (MyUserEntity)userScoreMap.get("user");
|
|
userCertificate.setUserId(user.getId());
|
|
userCertificate.setClassId(classEntity.getId());
|
|
//查询小班下得课程信息
|
|
List<Map<String,Object>> classCourseInfoLlist = classEntityService.classCourseInfoClassId(classEntity.getId(),0);
|
|
for (Map<String,Object> classCourseInfo:classCourseInfoLlist){
|
|
if (StringUtils.isNotEmpty(classCourseInfo.get("titleAbbr").toString())
|
|
&&StringUtils.isNotEmpty(classCourseInfo.get("courseETitle").toString())){
|
|
String certificateNo = classEntityService.getNextCertificateNo(type,classCourseInfo.get("titleAbbr").toString());
|
|
userCertificate.setCertificateNo(certificateNo);
|
|
userCertificate.setCourseId((Integer) classCourseInfo.get("courseId"));
|
|
if (StringUtils.isNotEmpty(user.getPhoto())&&StringUtils.isNotEmpty(user.getName())){
|
|
String startYear = DateUtil.year(classEntity.getStartTime())+"";
|
|
String startMonth = DateUtil.month(classEntity.getStartTime())+1+"";
|
|
String startDay = DateUtil.dayOfMonth(classEntity.getStartTime())+"";
|
|
String endYear = DateUtil.year(classEntity.getEndTime())+"";
|
|
String endMonth = DateUtil.month(classEntity.getEndTime())+1+"";
|
|
String endDay = DateUtil.dayOfMonth(classEntity.getEndTime())+"";
|
|
double keshiTotal = (double)classCourseInfo.get("keshi");
|
|
String keshi = (keshiTotal+"").replace(".0","");
|
|
String courseTitle = classCourseInfo.get("courseTitle").toString();
|
|
if (courseTitle.contains("【")){
|
|
courseTitle = courseTitle.substring(0,courseTitle.indexOf("【"));
|
|
}
|
|
String[] des = {startYear,startMonth,startDay,endYear,endMonth,endDay,
|
|
classEntity.getTitle(),courseTitle,keshi};
|
|
String[] edes = {classCourseInfo.get("courseETitle").toString(),keshi};
|
|
String url = userCertificateService.generateCertificate(type,certificateNo,user.getPhoto(),user.getName(),
|
|
des, edes, endYear,endMonth,endDay);
|
|
userCertificate.setCertificateUrl(url);
|
|
}
|
|
userCertificateService.save(userCertificate);
|
|
}else {
|
|
R.error("课程未设置英文名或缩写");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return R.ok();
|
|
}else {
|
|
return r;
|
|
}
|
|
}
|
|
|
|
//生成证书图片
|
|
@RequestMapping("/generateCertificateClass")
|
|
public R generateCertificateClass(@RequestBody Map<String,Object> params) {
|
|
MyUserEntity user = ShiroUtils.getUser();
|
|
String photoUrl = user.getPhoto();//证书人照片
|
|
String realName = user.getName();//真实姓名
|
|
UserCertificate userCertificate = userCertificateService.getById(params.get("id").toString());
|
|
String type = userCertificate.getType();//证书类型A a证 B b证 ZK自考
|
|
if ("ZK".equals(type)){
|
|
CourseEntity courseEntity = courseService.getById(userCertificate.getCourseId());
|
|
String courseTitle = userCertificate.getTitle();
|
|
ClassExamUser classExamUser = classExamUserService.getOne(new LambdaQueryWrapper<ClassExamUser>()
|
|
.eq(ClassExamUser::getUserId,ShiroUtils.getUId())
|
|
.eq(ClassExamUser::getRelationId,userCertificate.getCourseId()));
|
|
String endYear = DateUtil.year(classExamUser.getEndTime())+"";
|
|
String endMonth = DateUtil.month(classExamUser.getEndTime())+1+"";
|
|
String endDay = DateUtil.dayOfMonth(classExamUser.getEndTime())+"";
|
|
String[] description= {endYear,endMonth,endDay,courseTitle};
|
|
String[] edes = {courseEntity.getEtitle()};
|
|
String certificateNo = userCertificate.getCertificateNo();//证书编号
|
|
String url = userCertificateService.generateCertificate(type,certificateNo,photoUrl,realName, description, edes, endYear,endMonth,endDay);
|
|
userCertificate.setCertificateUrl(url);
|
|
userCertificateService.updateById(userCertificate);
|
|
}else {
|
|
ClassEntity classEntity = classEntityService.getById(userCertificate.getClassId());
|
|
String startYear = DateUtil.year(classEntity.getStartTime())+"";
|
|
String startMonth = DateUtil.month(classEntity.getStartTime())+1+"";
|
|
String startDay = DateUtil.dayOfMonth(classEntity.getStartTime())+"";
|
|
String endYear = DateUtil.year(classEntity.getEndTime())+"";
|
|
String endMonth = DateUtil.month(classEntity.getEndTime())+1+"";
|
|
String endDay = DateUtil.dayOfMonth(classEntity.getEndTime())+"";
|
|
List<Map<String,Object>> list = classEntityService.classCourseInfoClassId(classEntity.getId(),userCertificate.getCourseId());
|
|
for (Map<String,Object> map:list){
|
|
double keshiTotal = (double)map.get("keshi");
|
|
String keshi = (keshiTotal+"").replace(".0","");
|
|
String courseTitle = map.get("courseTitle").toString();
|
|
if (courseTitle.contains("【")){
|
|
courseTitle = courseTitle.substring(0,courseTitle.indexOf("【"));
|
|
}
|
|
String[] des = {startYear,startMonth,startDay,endYear,endMonth,endDay,
|
|
classEntity.getTitle(),courseTitle,keshi};
|
|
String[] edes = {map.get("courseETitle").toString(),keshi};
|
|
String certificateNo = userCertificate.getCertificateNo();
|
|
String url = userCertificateService.generateCertificate(type,certificateNo,photoUrl,realName,des, edes, endYear,endMonth,endDay);
|
|
userCertificate.setCertificateUrl(url);
|
|
userCertificateService.updateById(userCertificate);
|
|
}
|
|
}
|
|
return R.ok();
|
|
}
|
|
|
|
//获取小班证书
|
|
@RequestMapping("/getUserCertificateByClassId")
|
|
public R getUserCertificateByClassId(@RequestBody Map<String,Object> params) {
|
|
LambdaQueryWrapper<UserCertificate> wrapper = new LambdaQueryWrapper<>();
|
|
if (StringUtils.isNotBlank(params.get("classId").toString())){
|
|
wrapper.eq(UserCertificate::getClassId,params.get("classId"));
|
|
}
|
|
wrapper.eq(UserCertificate::getUserId,params.get("userId"));
|
|
List<UserCertificate> userCertificate = userCertificateService.list(wrapper);
|
|
return R.ok().put("userCertificate",userCertificate);
|
|
}
|
|
|
|
|
|
|
|
}
|