package com.qxueyou.scc.evaluate.service.impl;
|
|
import java.math.BigDecimal;
|
import java.math.BigInteger;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.stream.Collectors;
|
|
import org.apache.commons.beanutils.BeanUtils;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.logging.log4j.LogManager;
|
import org.apache.logging.log4j.Logger;
|
import org.apache.tools.ant.taskdefs.Concat;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import com.querydsl.core.QueryResults;
|
import com.querydsl.core.Tuple;
|
import com.querydsl.core.types.Predicate;
|
import com.qxueyou.scc.admin.classes.model.QClsClass;
|
import com.qxueyou.scc.admin.classes.model.QClsClassReSubject;
|
import com.qxueyou.scc.admin.teacher.service.ITeacherService;
|
import com.qxueyou.scc.base.model.Pager;
|
import com.qxueyou.scc.base.model.Result;
|
import com.qxueyou.scc.base.model.ResultJson;
|
import com.qxueyou.scc.base.service.impl.CommonAppService;
|
import com.qxueyou.scc.base.util.ClientUtils;
|
import com.qxueyou.scc.base.util.CollectionUtils;
|
import com.qxueyou.scc.base.util.QueryDslOptionBuilder;
|
import com.qxueyou.scc.base.util.TraceUtils;
|
import com.qxueyou.scc.evaluate.dao.EvaluateRepository;
|
import com.qxueyou.scc.evaluate.service.IEvaluateService;
|
import com.qxueyou.scc.evaluate.service.IEvaluateTemplateService;
|
import com.qxueyou.scc.exercise.model.ExerciseGroup;
|
import com.qxueyou.scc.exercise.model.ExerciseItem;
|
import com.qxueyou.scc.exercise.model.ExerciseItemAnswerU;
|
import com.qxueyou.scc.exercise.model.ExerciseItemOption;
|
import com.qxueyou.scc.exercise.model.ExerciseItemScore;
|
import com.qxueyou.scc.exercise.model.ExerciseObjectImg;
|
import com.qxueyou.scc.exercise.model.ExerciseRecord;
|
import com.qxueyou.scc.exercise.model.QExerciseGroup;
|
import com.qxueyou.scc.exercise.model.QExerciseItemAnswerU;
|
import com.qxueyou.scc.exercise.model.QExerciseRecord;
|
import com.qxueyou.scc.exercise.service.IExerciseService;
|
import com.qxueyou.scc.exercise.util.ExerciseUtils;
|
import com.qxueyou.scc.msg.model.MsgInfo;
|
import com.qxueyou.scc.msg.service.IMsgInfoService;
|
import com.qxueyou.scc.school.model.EvaluateStuStudentV;
|
import com.qxueyou.scc.school.model.QEvaluateStuStudentV;
|
import com.qxueyou.scc.school.model.QSchEvaRecordRe;
|
import com.qxueyou.scc.school.model.QSchEvaluate;
|
import com.qxueyou.scc.school.model.QSchEvaluateTemplate;
|
import com.qxueyou.scc.school.model.SchEvaRecordRe;
|
import com.qxueyou.scc.school.model.SchEvaluate;
|
import com.qxueyou.scc.school.model.SchEvaluateDetail;
|
import com.qxueyou.scc.school.model.SchEvaluateTemplate;
|
import com.qxueyou.scc.school.model.TeachEvaScoreData;
|
import com.qxueyou.scc.school.model.TeachEvaScoreResult;
|
import com.qxueyou.scc.teach.student.model.QStuStudent;
|
import com.qxueyou.scc.teach.student.model.StuStudent;
|
import com.qxueyou.scc.teach.subject.model.QSubject;
|
import com.qxueyou.scc.teach.subject.model.Subject;
|
import com.qxueyou.scc.user.model.QUser;
|
|
@Service
|
public class EvaluateService extends CommonAppService implements IEvaluateService {
|
|
private final Logger log = LogManager.getLogger(EvaluateService.class);
|
|
@Autowired
|
EvaluateRepository evaRepository;
|
|
@Autowired
|
IEvaluateTemplateService templateService;
|
|
@Autowired
|
ITeacherService teacherService;
|
|
@Autowired
|
IExerciseService exerciseService;
|
|
@Autowired
|
IMsgInfoService msgInfoService;
|
|
/**
|
* 查询列表数据
|
* @param pageNum
|
* @param pageSize
|
* @return
|
*/
|
@Override
|
public ResultJson queryList(Integer pageNum, Integer pageSize, String keyword, String sort) {
|
|
QSchEvaluate qEva = QSchEvaluate.schEvaluate;
|
QSchEvaluateTemplate template = QSchEvaluateTemplate.schEvaluateTemplate;
|
QExerciseGroup group = QExerciseGroup.exerciseGroup;
|
QSubject subject = QSubject.subject;
|
QClsClass clsClass = QClsClass.clsClass;
|
QStuStudent stuStudent = QStuStudent.stuStudent;
|
// 搜索名
|
keyword = StringUtils.isBlank(keyword) ? null : "%"+keyword+"%";
|
|
// 获取查询结果集合
|
QueryResults<Tuple> results = this.getQueryFactory()
|
.select(qEva, group, subject)
|
.from(qEva, template, group, subject)
|
.where(new QueryDslOptionBuilder()
|
.and(qEva.evalTemplateId::eq, template.evaluateTemplateId)
|
.and(template.groupId::eq, group.groupId)
|
.and(qEva.evalRangeId::like, subject.subjectId)
|
.and(qEva.createId::eq, ClientUtils.getUserId())
|
.and(qEva.evaluateName::like, keyword)
|
.and(qEva.deleteFlag::eq, false)
|
.build()
|
)
|
.orderBy(qEva.createTime.desc())
|
.fetchResults();
|
QueryResults<Tuple> results2 = this.getQueryFactory()
|
.select(qEva, group, clsClass)
|
.from(qEva, template, group, clsClass)
|
.where(new QueryDslOptionBuilder()
|
.and(qEva.evalTemplateId::eq, template.evaluateTemplateId)
|
.and(template.groupId::eq, group.groupId)
|
.and(qEva.evalRangeId::like, clsClass.classId)
|
.and(qEva.createId::eq, ClientUtils.getUserId())
|
.and(qEva.evaluateName::like, keyword)
|
.and(qEva.deleteFlag::eq, false)
|
.build()
|
)
|
.orderBy(qEva.createTime.desc())
|
.fetchResults();
|
|
QueryResults<Tuple> results3 = this.getQueryFactory()
|
.select(qEva, group, stuStudent)
|
.from(qEva, template, group, stuStudent)
|
.where(new QueryDslOptionBuilder()
|
.and(qEva.evalTemplateId::eq, template.evaluateTemplateId)
|
.and(template.groupId::eq, group.groupId)
|
.and(qEva.evalRangeId::like,stuStudent.userId)
|
.and(qEva.createId::eq, ClientUtils.getUserId())
|
.and(qEva.evaluateName::like, keyword)
|
.and(qEva.deleteFlag::eq, false)
|
.build()
|
)
|
.orderBy(qEva.createTime.desc())
|
.fetchResults();
|
// 封装参数
|
List<Map<String, Object>> resultLst =
|
results.getResults()
|
.stream()
|
.map(tuple -> {
|
Map<String, Object> map = new HashMap<String, Object>(2);
|
map.put("evaluateId", tuple.get(qEva).getEvaluateId());
|
map.put("evaluateName", tuple.get(qEva).getEvaluateName());
|
map.put("evalRangeId", tuple.get(qEva).getEvalRangeId());
|
map.put("evalRangeType", tuple.get(qEva).getEvalRangeType());
|
map.put("evalRangeName", tuple.get(subject).getName());
|
map.put("evalRangeCount", tuple.get(qEva).getEvalRangeCount());
|
map.put("evalObjectName", tuple.get(qEva).getEvalObjectName());
|
map.put("status", tuple.get(qEva).getStatus());
|
map.put("endTime", tuple.get(qEva).getEndTime());
|
map.put("createTime", tuple.get(qEva).getCreateTime());
|
map.put("groupId", tuple.get(group).getGroupId());
|
map.put("exerCount", tuple.get(group).getAllCount());
|
map.put("evaluateCount", this.getEvaluateCount(tuple.get(qEva).getEvaluateId()));//已评估人数
|
map.put("evaluateAllCount", this
|
.queryEvaluateAllCount(tuple.get(qEva).getEvalRangeType(), tuple.get(qEva).getEvalRangeId().split(",")));//应评估人数
|
return map;
|
}).collect(Collectors.toList());
|
|
resultLst.addAll(
|
results2.getResults()
|
.stream()
|
.map(tuple -> {
|
Map<String, Object> map = new HashMap<String, Object>(2);
|
map.put("evaluateId", tuple.get(qEva).getEvaluateId());
|
map.put("evaluateName", tuple.get(qEva).getEvaluateName());
|
map.put("evalRangeId", tuple.get(qEva).getEvalRangeId());
|
map.put("evalRangeType", tuple.get(qEva).getEvalRangeType());
|
map.put("evalRangeName", tuple.get(clsClass).getName());
|
map.put("evalRangeCount", tuple.get(qEva).getEvalRangeCount());
|
map.put("evalObjectName", tuple.get(qEva).getEvalObjectName());
|
map.put("status", tuple.get(qEva).getStatus());
|
map.put("endTime", tuple.get(qEva).getEndTime());
|
map.put("createTime", tuple.get(qEva).getCreateTime());
|
map.put("groupId", tuple.get(group).getGroupId());
|
map.put("exerCount", tuple.get(group).getAllCount());
|
map.put("evaluateCount", this.getEvaluateCount(tuple.get(qEva).getEvaluateId()));//已评估人数
|
map.put("evaluateAllCount", this
|
.queryEvaluateAllCount(tuple.get(qEva).getEvalRangeType(), tuple.get(qEva).getEvalRangeId().split(",")));//应评估人数
|
return map;
|
}).collect(Collectors.toList()));
|
resultLst.addAll(
|
results3.getResults()
|
.stream()
|
.map(tuple -> {
|
Map<String, Object> map = new HashMap<String, Object>(2);
|
map.put("evaluateId", tuple.get(qEva).getEvaluateId());
|
map.put("evaluateName", tuple.get(qEva).getEvaluateName());
|
map.put("evalRangeId", tuple.get(qEva).getEvalRangeId());
|
map.put("evalRangeType", tuple.get(qEva).getEvalRangeType());
|
map.put("evalRangeName", tuple.get(stuStudent).getName());
|
map.put("evalRangeCount", tuple.get(qEva).getEvalRangeCount());
|
map.put("evalObjectName", tuple.get(qEva).getEvalObjectName());
|
map.put("status", tuple.get(qEva).getStatus());
|
map.put("endTime", tuple.get(qEva).getEndTime());
|
map.put("createTime", tuple.get(qEva).getCreateTime());
|
map.put("groupId", tuple.get(group).getGroupId());
|
map.put("exerCount", tuple.get(group).getAllCount());
|
map.put("evaluateCount", this.getEvaluateCount(tuple.get(qEva).getEvaluateId()));//已评估人数
|
map.put("evaluateAllCount", this
|
.queryEvaluateAllCount(tuple.get(qEva).getEvalRangeType(), tuple.get(qEva).getEvalRangeId().split(",")));//应评估人数
|
return map;
|
}).collect(Collectors.toList()));
|
|
return new ResultJson(true, "success",
|
CollectionUtils.newObjectMap("allCount",results.getTotal()+results2.getTotal()+results3.getTotal(),"datas",resultLst));
|
}
|
|
/**
|
* 获取范围选择
|
*
|
* type: lesson:课程 class:班级 person:人员
|
*
|
* @return
|
*/
|
@Override
|
public ResultJson queryRangeList(String type,String searchName) {
|
|
List<Tuple> tupleLst = null;
|
// 搜索名
|
searchName = StringUtils.isBlank(searchName) ? null : "%"+searchName+"%";
|
|
if(ClientUtils.isAdmin()){// 管理员
|
|
tupleLst = getAdminRangeList(type,searchName);
|
}else{// 老师
|
|
tupleLst = getTeacherRangeList(type,searchName);
|
}
|
|
// 统一处理返回数据
|
List<Map<String,Object>> resultLst = tupleLst.stream()
|
.map(tuple -> {
|
Map<String,Object> map = new HashMap<String,Object>(2);
|
map.put("name", tuple.get(0, String.class));
|
map.put("id", tuple.get(1, String.class));
|
return map;
|
}).collect(Collectors.toList());
|
|
return new ResultJson(true, "success", resultLst);
|
}
|
|
/**
|
* 获取管理员范围选择
|
* @param type
|
* @return
|
*/
|
private List<Tuple> getAdminRangeList(String type,String searchName){
|
QSubject subject = QSubject.subject;
|
QClsClass cls = QClsClass.clsClass;
|
QUser user = QUser.user;
|
List<Tuple> tupleLst = null;
|
|
if(SchEvaluate.EVALUATE_RANGE_LESSON.equals(type)){//课程
|
|
tupleLst = this.getQueryFactory().select(subject.name.as("name"),subject.subjectId.as("id")).distinct()
|
.from(subject)
|
.where(subject.type.eq(Subject.TYPE_ORG_SUBJECT)
|
.and(subject.status.eq(Subject.STATUS_ISSUED))
|
.and(subject.origSubjectId.isNull())
|
.and(subject.deleteFlag.isFalse()))
|
.orderBy(subject.createTime.desc())
|
.fetch();
|
|
}else if(SchEvaluate.EVALUATE_RANGE_CLASS.equals(type)){//班级
|
|
tupleLst = this.getQueryFactory().select(cls.name.as("name"),cls.classId.as("id")).distinct()
|
.from(cls)
|
.where( new QueryDslOptionBuilder()
|
.and(cls.name::like, searchName)
|
.and(cls.deleteFlag::eq, false)
|
.build())
|
.orderBy(cls.createTime.desc())
|
.fetch();
|
}else if(SchEvaluate.EVALUATE_RANGE_PERSON.equals(type)){//人员
|
QStuStudent stu = QStuStudent.stuStudent;
|
|
tupleLst = this.getQueryFactory().select(user.name.as("name"),user.userId.as("id")).distinct()
|
.from(stu, user)
|
.where(new QueryDslOptionBuilder()
|
.and(stu.name::like, searchName)
|
.and(stu.deleteFlag::eq, false).and(user.userId::eq, stu.userId).and(user.deleteFlag::eq, false)
|
.and(stu.status::eq, StuStudent.STATUS_ACTIVE)
|
.build())
|
.orderBy(stu.createTime.desc())
|
.fetch();
|
}
|
|
return tupleLst;
|
}
|
|
/**
|
* 获取老师范围选择
|
* @param type
|
* @return
|
*/
|
private List<Tuple> getTeacherRangeList(String type,String searchName){
|
QSubject subject = QSubject.subject;
|
QClsClassReSubject re = QClsClassReSubject.clsClassReSubject;
|
QClsClass cls = QClsClass.clsClass;
|
|
List<Tuple> tupleLst = null;
|
String teacherId = teacherService.getTeacherIdByUserId(ClientUtils.getUserId());
|
|
if(SchEvaluate.EVALUATE_RANGE_LESSON.equals(type)){//课程
|
|
tupleLst = this.getQueryFactory().select(subject.name.as("name"),subject.subjectId.as("id")).distinct()
|
.from(subject)
|
.where(subject.createId.eq(ClientUtils.getUserId())
|
.and(subject.type.eq(Subject.TYPE_ORG_SUBJECT))
|
.and(subject.status.eq(Subject.STATUS_ISSUED))
|
.and(subject.origSubjectId.isNull())
|
.and(subject.deleteFlag.isFalse()))
|
.orderBy(subject.createTime.desc())
|
.fetch();
|
|
}else if(SchEvaluate.EVALUATE_RANGE_CLASS.equals(type)){//班级
|
|
tupleLst = this.getQueryFactory().select(cls.name.as("name"),cls.classId.as("id")).distinct()
|
.from(subject, re, cls)
|
.where(new QueryDslOptionBuilder()
|
.and(subject.subjectId::eq, re.subjectId)
|
.and(re.classId::eq, cls.classId)
|
.and(subject.teacherId::eq, teacherId)
|
.and(subject.name::like, searchName)
|
.and(subject.status::eq, Subject.STATUS_ISSUED)
|
.and(subject.deleteFlag::eq, false)
|
.and(cls.deleteFlag::eq, false)
|
.build()).groupBy(cls.classId)
|
.orderBy(subject.createTime.desc())
|
.fetch();
|
|
}else if(SchEvaluate.EVALUATE_RANGE_PERSON.equals(type)){//人员
|
QStuStudent stu = QStuStudent.stuStudent;
|
|
tupleLst = this.getQueryFactory().select(stu.name.as("name"),stu.userId.as("id")).distinct()
|
.from(stu,cls,subject, re)
|
.where(new QueryDslOptionBuilder()
|
.and(stu.classId::like, cls.classId)
|
.and(stu.status::eq, StuStudent.STATUS_ACTIVE)
|
.and(stu.name::like, searchName)
|
.and(stu.deleteFlag::eq, false)
|
.and(subject.subjectId::eq, re.subjectId)
|
.and(re.classId::eq, cls.classId)
|
.and(subject.teacherId::eq, teacherId)
|
.and(subject.name::like, searchName)
|
.and(subject.status::eq, Subject.STATUS_ISSUED)
|
.and(subject.deleteFlag::eq, false)
|
.and(cls.deleteFlag::eq, false)
|
.build()
|
).groupBy(stu.userId)
|
.orderBy(stu.createTime.desc())
|
.fetch();
|
}
|
|
return tupleLst;
|
}
|
|
/**
|
* 后台新增评估
|
* @param eva
|
* @return
|
*/
|
@Override
|
public ResultJson addOrUpdateEvaluate(SchEvaluate eva) {
|
String evaluateId = eva.getEvaluateId();
|
String groupId = null;
|
if(StringUtils.isBlank(evaluateId)){// 新增
|
//1、插入组
|
ExerciseGroup obj = this.insertExerciseGroup(eva.getEvaluateName(),
|
ExerciseGroup.TYPE_EXERCISE_TEACH_EVALUATE);
|
|
//2、插入评估模板
|
SchEvaluateTemplate objTemplate = new SchEvaluateTemplate();
|
TraceUtils.setCreateTrace(objTemplate);
|
objTemplate.setEvaluateTemplateName(eva.getEvaluateName());
|
objTemplate.setGroup_name(obj.getName());
|
objTemplate.setGroupId(obj.getGroupId());
|
objTemplate.setOrgId(ClientUtils.getOrgId());
|
objTemplate.setOrgName(ClientUtils.getOrgName());
|
this.save(objTemplate);
|
|
// 3、插入评估表
|
eva.setEvalTemplateId(objTemplate.getEvaluateTemplateId());
|
eva.setEvalTemplateName(objTemplate.getEvaluateTemplateName());
|
eva.setEvaluateCount(BigInteger.ZERO);
|
eva.setScore(BigDecimal.ZERO);
|
eva.setStatus((short)0);
|
eva.setDeleteFlag(false);
|
TraceUtils.setCreateTrace(eva);
|
evaRepository.save(eva);
|
|
evaluateId = eva.getEvaluateId();
|
groupId = obj.getGroupId();
|
}else{// 编辑
|
SchEvaluate newEva = this.read(SchEvaluate.class, eva.getEvaluateId());
|
|
newEva.setEvaluateName(eva.getEvaluateName());
|
newEva.setEvalObjectName(eva.getEvalObjectName());
|
newEva.setEndTime(eva.getEndTime());
|
newEva.setEvalRangeType(eva.getEvalRangeType());
|
newEva.setEvalRangeId(eva.getEvalRangeId());
|
newEva.setEvalRangeName(eva.getEvalRangeName());
|
TraceUtils.setUpdateTrace(newEva);
|
evaRepository.save(newEva);
|
}
|
|
return new ResultJson(true, "success", CollectionUtils.newObjectMap("evaluateId", evaluateId, "groupId", groupId));
|
}
|
|
/**
|
* ：后台 插入评估模板时调用
|
*
|
* @param name
|
* @param type
|
* @return
|
*/
|
public ExerciseGroup insertExerciseGroup(String name, short type) {
|
|
ExerciseGroup obj = new ExerciseGroup();
|
TraceUtils.setCreateTrace(obj);
|
obj.setName(name);
|
obj.setType(type);
|
obj.setClassId(ClientUtils.getClassId());
|
obj.setOrgId(ClientUtils.getOrgId());
|
obj.setAllCount(BigInteger.ZERO);
|
this.save(obj);
|
|
// 保存
|
return obj;
|
}
|
|
/**
|
* 查询基本信息
|
*/
|
@Override
|
public ResultJson queryBaseInfo(String evaluateId) {
|
|
SchEvaluate eva = evaRepository.getOne(evaluateId);
|
QSchEvaluate qEva = QSchEvaluate.schEvaluate;
|
QSchEvaluateTemplate template = QSchEvaluateTemplate.schEvaluateTemplate;
|
QExerciseGroup group = QExerciseGroup.exerciseGroup;
|
|
// 获取查询结果集合
|
ExerciseGroup g = this.getQueryFactory()
|
.select(group)
|
.from(qEva, template, group)
|
.where(new QueryDslOptionBuilder()
|
.and(qEva.evalTemplateId::eq, template.evaluateTemplateId)
|
.and(template.groupId::eq,group.groupId)
|
.and(qEva.evaluateId::eq,evaluateId)
|
.and(qEva.deleteFlag::eq,false)
|
.build()
|
)
|
.fetchOne();
|
|
return new ResultJson(true, "success",
|
CollectionUtils.newObjectMap("evaluateName",eva.getEvaluateName(),
|
"evaluateId",eva.getEvaluateId(),
|
"evalObjectName",eva.getEvalObjectName(),
|
"endTime",eva.getEndTime(),
|
"createTime",eva.getCreateTime(),
|
"evalRangeType",eva.getEvalRangeType(),
|
"evaluateCount",g.getAllCount(),
|
"evalRangeId",eva.getEvalRangeId(),
|
"evalRangeName",eva.getEvalRangeName()));
|
}
|
|
/**
|
* 删除
|
*/
|
@Override
|
public ResultJson delete(String evaluateIds){
|
QSchEvaluate qEva = QSchEvaluate.schEvaluate;
|
|
this.getQueryFactory()
|
.update(qEva)
|
.set(qEva.deleteFlag, true)
|
.where(qEva.evaluateId.in(evaluateIds.split(",")))
|
.execute();
|
|
return new ResultJson(true, "success");
|
}
|
|
/**
|
* 激活
|
*/
|
@Override
|
public ResultJson doActive(String evaluateIds){
|
|
QSchEvaluate qEva = QSchEvaluate.schEvaluate;
|
|
this.getQueryFactory()
|
.update(qEva)
|
.set(qEva.status, SchEvaluate.STATUS_EVA)
|
.where(qEva.evaluateId.in(evaluateIds.split(",")))
|
.execute();
|
|
if(StringUtils.isNotEmpty(evaluateIds)){
|
String [] arrIds = evaluateIds.split(",");
|
for(String evaluateId:arrIds){
|
this.doSendhMsg(evaluateId);
|
}
|
}
|
|
return new ResultJson(true, "success");
|
}
|
|
//发布消息
|
private void doSendhMsg(String evaluateId){
|
SchEvaluate evaluate = this.read(SchEvaluate.class,evaluateId);
|
|
List<Map<String,Object>> lst= this.queryNotAnswerEvaLst(evaluateId, new ArrayList<String>(1));
|
|
List<String> lstUserIds = null;
|
if(lst!=null && lst.size()>0){
|
lstUserIds = new ArrayList<String>(lst.size());
|
for(Map<String,Object> map:lst){
|
lstUserIds.add((String)map.get("userId"));
|
}
|
|
Map<String,String> attrs = CollectionUtils.newStringMap("evaluateId",evaluate.getEvaluateId(),"evaluateName",evaluate.getEvaluateName(),
|
"templateId",evaluate.getEvalTemplateId(),"evalRangeName",evaluate.getEvalRangeName(),"creator",evaluate.getCreator());
|
|
msgInfoService.doSendTextMsgToUsersLoop(lstUserIds, MsgInfo.TYPE_EVALUATE, "发布了问卷调查", attrs);
|
}
|
}
|
|
/**
|
*回退
|
*/
|
@Override
|
public ResultJson doWithdraw(String evaluateIds){
|
QSchEvaluate qEva = QSchEvaluate.schEvaluate;
|
|
this.getQueryFactory()
|
.update(qEva)
|
.set(qEva.status, SchEvaluate.STATUS_NOT_EVA)
|
.where(qEva.evaluateId.in(evaluateIds.split(",")))
|
.execute();
|
|
return new ResultJson(true, "success");
|
}
|
|
/**
|
* 复制
|
*/
|
@Override
|
public ResultJson doCopy(SchEvaluate eva){
|
try {
|
SchEvaluate schEva = evaRepository.getOne(eva.getEvaluateId());
|
SchEvaluateTemplate oldTemplate = this.read(SchEvaluateTemplate.class, schEva.getEvalTemplateId());
|
|
// 1、生成习题组
|
String newGroupId = exerciseService.doCopyExerciseByEvaluate(oldTemplate.getGroupId());
|
|
// 2、生成模板
|
SchEvaluateTemplate newTemplate = new SchEvaluateTemplate();
|
|
BeanUtils.copyProperties(newTemplate, oldTemplate);
|
newTemplate.setEvaluateTemplateId(null);
|
newTemplate.setGroupId(newGroupId);
|
TraceUtils.setCreateTrace(newTemplate);
|
this.save(newTemplate);
|
|
// 3、生成评估表
|
SchEvaluate newEva = new SchEvaluate();
|
BeanUtils.copyProperties(newEva, eva);
|
newEva.setEvaluateId(null);
|
newEva.setEvalTemplateId(newTemplate.getEvaluateTemplateId());
|
newEva.setEvalTemplateName(newTemplate.getEvaluateTemplateName());
|
newEva.setEvaluateCount(BigInteger.ZERO);
|
newEva.setScore(BigDecimal.ZERO);
|
newEva.setStatus((short)0);
|
newEva.setDeleteFlag(false);
|
TraceUtils.setCreateTrace(newEva);
|
this.save(newEva);
|
|
return new ResultJson(true, "success", CollectionUtils.newObjectMap("evaluateId", newEva.getEvaluateId(), "groupId", newGroupId));
|
|
} catch (Exception e) {
|
log.error("doCopy评估复制：复制练习BeanUtils.copyProperties()方法copy失败", e);
|
}
|
|
return new ResultJson(false);
|
}
|
|
/**
|
* 查看结果 问卷整体情况
|
* @param evaluateId
|
* @param groupId
|
* @param evalRangeType
|
* @return
|
*/
|
@Override
|
public ResultJson queryEvaluateDetail(String evaluateId,String groupId){
|
|
// 1、查询已提交问卷list
|
List<Map<String, Object>> answerUserLst = queryAnswerEvaLst(evaluateId);
|
|
// 已经答题过的学员id
|
List<String> userAnswerList = new ArrayList<String>(answerUserLst.size());
|
for(Map<String,Object> map:answerUserLst){
|
userAnswerList.add(String.valueOf(map.get("userId")));
|
}
|
|
// 2、查询未提交答案list
|
List<Map<String,Object>> notAnswerUserLst = this.queryNotAnswerEvaLst(evaluateId, userAnswerList);
|
|
|
return new ResultJson(true, "success",
|
CollectionUtils.newObjectMap("answerUserLst",answerUserLst,
|
"notAnswerUserLst",notAnswerUserLst));
|
}
|
|
/**
|
* 查询已答题的学员list
|
* @param evaluateId
|
* @return
|
*/
|
private List<Map<String, Object>> queryAnswerEvaLst(String evaluateId) {
|
|
QExerciseRecord record = QExerciseRecord.exerciseRecord;
|
QSchEvaRecordRe reEva = QSchEvaRecordRe.schEvaRecordRe;
|
|
List<Map<String,Object>> answerUserLst = this.getQueryFactory()
|
.select(record).from(record, reEva)
|
.where(record.recordId.eq(reEva.exerciseRecordId)
|
.and(reEva.evaluateId.eq(evaluateId))
|
.and(record.deleteFlag.eq(false)))
|
.orderBy(record.submitTime.desc())
|
.fetch()
|
.stream()
|
.map(tuple -> {
|
Map<String,Object> map = new HashMap<String,Object>(4);
|
map.put("recordId", tuple.getRecordId());
|
map.put("userId", tuple.getUserId());
|
map.put("userName", tuple.getUserName());
|
map.put("submitTime", tuple.getSubmitTime());
|
return map;
|
}).collect(Collectors.toList());
|
|
return answerUserLst;
|
}
|
|
/**
|
* 查询未答题的学员list
|
* @param rangeType
|
* @param evalRangeIds
|
* @param userAnswerList
|
* @return
|
*/
|
private List<Map<String,Object>> queryNotAnswerEvaLst(String evaluateId,List<String> userAnswerList ){
|
|
SchEvaluate eva = this.read(SchEvaluate.class, evaluateId);
|
String[] evalRangeIds = eva.getEvalRangeId().split(",");
|
String rangeType = eva.getEvalRangeType();
|
|
QClsClassReSubject re = QClsClassReSubject.clsClassReSubject;
|
QStuStudent stu = QStuStudent.stuStudent;
|
QSubject qSubject = QSubject.subject;
|
|
Predicate predicate = null;
|
if(SchEvaluate.EVALUATE_RANGE_LESSON.equals(rangeType)){//课程
|
|
predicate = stu.classId.in(getQueryFactory().select(re.classId).from(re,qSubject)
|
.where(qSubject.origSubjectId.in(evalRangeIds).and(re.subjectId.eq(qSubject.subjectId))
|
.and(qSubject.deleteFlag.isFalse()).and(re.deleteFlag.eq(false))));
|
}else if(SchEvaluate.EVALUATE_RANGE_CLASS.equals(rangeType)){//班级
|
|
predicate = stu.classId.in(evalRangeIds);
|
}else if(SchEvaluate.EVALUATE_RANGE_PERSON.equals(rangeType)){//人员
|
|
predicate = stu.userId.in(evalRangeIds);
|
}
|
|
List<Map<String,Object>> notAnswerUserLst = this.getQueryFactory().select(stu.userId, stu.name).distinct()
|
.from(stu)
|
.where(stu.userId.notIn(userAnswerList)// 过滤掉已经答题过的学员
|
.and(stu.deleteFlag.eq(false))
|
.and(predicate))
|
.orderBy(stu.createTime.desc())
|
.fetch()
|
.stream()
|
.map(tuple -> {
|
Map<String,Object> map = new HashMap<String,Object>(4);
|
map.put("recordId", null);
|
map.put("userId", tuple.get(0,String.class));
|
map.put("userName", tuple.get(1,String.class));
|
map.put("submitTime", null);
|
return map;
|
}).collect(Collectors.toList());
|
|
return notAnswerUserLst;
|
}
|
|
|
/** ------前端 ---------------------------start------------------------------------------------------------------ */
|
|
/**
|
* 提交答案
|
* @param score
|
* @return
|
*/
|
@Override
|
public ResultJson doSubmitTeachEvalScoreData(TeachEvaScoreResult scoreResult, String userId) {
|
|
List<TeachEvaScoreData> lstScore = scoreResult.getItems();
|
String evaluateId = scoreResult.getEvaluateId();
|
|
// 1.操作ExerciseRecord做题记录
|
ExerciseRecord record = this.doOperExerciseRecord(scoreResult);
|
|
if(null == record){
|
return new ResultJson(false,"您已经提交，不能重复提交");
|
}
|
String exerciseRecordId = record.getRecordId();
|
|
if(!scoreResult.getItems().isEmpty()){
|
// 2.记录练习答案 ExerciseItemAnswerU
|
this.doOperExerciseItemAnswerUBatch(lstScore, exerciseRecordId);
|
}
|
|
// 3.插入评估记录关联表
|
this.doOperSchEvaRecordRe(exerciseRecordId, evaluateId);
|
|
// 4.更新评估表的完成人数
|
SchEvaluate eval = this.updateEvaluateCount(evaluateId);
|
|
if(!scoreResult.getItems().isEmpty()){
|
// 5.插入评估明细表
|
this.insertEvaluateDetailBatch(lstScore,evaluateId);
|
}
|
|
return new ResultJson(true, "操作成功",
|
CollectionUtils.newObjectMap("doNumber", eval.getEvaluateCount(), "recordId", exerciseRecordId));
|
}
|
|
|
/**
|
* 操作本次做题记录
|
* @return
|
*/
|
public ExerciseRecord doOperExerciseRecord(TeachEvaScoreResult scoreResult) {
|
|
String hql = "select count(r.recordId) from SchEvaRecordRe re, ExerciseRecord r "
|
+ " where re.exerciseRecordId=r.recordId and re.evaluateId=? and r.userId=? and r.deleteFlag is false";
|
|
int count = this.findCount(hql, CollectionUtils.newList(scoreResult.getEvaluateId(), ClientUtils.getUserId()));
|
|
if(count > 0){
|
return null;
|
}
|
|
String doCount = String.valueOf(scoreResult.getItems().size());
|
|
// 2.查询总题目数
|
ExerciseGroup group = this.findUnique("select g from ExerciseGroup g,SchEvaluate e,SchEvaluateTemplate t "
|
+ "where g.groupId=t.groupId and e.evalTemplateId=t.evaluateTemplateId and e.evaluateId=?"
|
+ " and g.deleteFlag is false and e.deleteFlag is false ",
|
CollectionUtils.newList(scoreResult.getEvaluateId()), ExerciseGroup.class);
|
BigInteger allCount = group.getAllCount();
|
|
// 3.查询做题记录obj
|
BigDecimal completionRate = ExerciseUtils.parseStrToBigDecimal(doCount, String.valueOf(allCount));
|
|
ExerciseRecord record = new ExerciseRecord();
|
record.setExerciseGroupId(group.getGroupId());
|
record.setUserId(ClientUtils.getUserId());
|
record.setDeleteFlag(false);
|
record.setScore(scoreResult.getScore());
|
record.setTitleMaxNumber(scoreResult.getCurrTitleNum());
|
record.setStatus(ExerciseRecord.STATUS_SUBMIT);
|
record.setSubmitTime(new Date(System.currentTimeMillis()));
|
record.setCompletionRate(completionRate);
|
record.setDoCount(new BigInteger(doCount));
|
TraceUtils.setCreateTrace(record);
|
this.save(record);
|
|
return record;
|
}
|
|
/**
|
* 批量增加或修改练习记录答案
|
* @return
|
*/
|
public Result doOperExerciseItemAnswerUBatch(List<TeachEvaScoreData> lstScore, String exerciseRecordId) {
|
String userId = ClientUtils.getUserId();
|
|
List<ExerciseItemAnswerU> lstNewAnswerU = new ArrayList<ExerciseItemAnswerU>(lstScore.size());
|
// 组装答案记录
|
ExerciseItemAnswerU answerU = null;
|
for(TeachEvaScoreData score:lstScore){
|
if(StringUtils.isBlank(score.getAnswer())){
|
continue;
|
}
|
answerU = new ExerciseItemAnswerU();
|
|
answerU.setExerciseItemId(score.getExerciseId());
|
answerU.setExerciseRecordId(exerciseRecordId);
|
answerU.setAnswer(score.getAnswer());
|
answerU.setUserId(userId);
|
answerU.setDeleteFlag(false);
|
TraceUtils.setCreateTrace(answerU);
|
lstNewAnswerU.add(answerU);
|
}
|
|
// 批量保存
|
this.saveOrUpdateAll(lstNewAnswerU);
|
|
return new Result(true);
|
}
|
|
/**
|
* 批量增加或修改评估明细记录
|
* @return
|
*/
|
public Result insertEvaluateDetailBatch(List<TeachEvaScoreData> lstScore,String evaluateId) {
|
|
Map<String, Object> argsMap = new HashMap<String, Object>(lstScore.size());
|
|
Object[] args = new Object[lstScore.size()];
|
for(int i=0; i<lstScore.size(); i++){
|
args[i] = lstScore.get(i).getExerciseId();
|
}
|
argsMap.put("exerciseIds", args);
|
|
String hql_score = "from ExerciseItemScore where exerciseItemId in (:exerciseIds) and deleteFlag is false ";
|
List<ExerciseItemScore> lstscores = this.findByComplexHql(hql_score, argsMap, ExerciseItemScore.class);
|
Map<String, String> scoreMap = new HashMap<String,String>(lstscores.size());
|
for(ExerciseItemScore score:lstscores){
|
scoreMap.put(score.getExerciseItemId()+score.getExerciseItemAnswer(), score.getScore());
|
}
|
|
String userId = ClientUtils.getUserId();
|
String userName = ClientUtils.getUserName();
|
|
List<SchEvaluateDetail> lstDetail = new ArrayList<SchEvaluateDetail>(lstScore.size());
|
SchEvaluateDetail record = null;
|
for(TeachEvaScoreData score:lstScore){
|
record = new SchEvaluateDetail();
|
record.setEvaluateId(evaluateId);
|
if(scoreMap.get(score.getExerciseId()+score.getAnswer()) == null){
|
record.setScore(BigDecimal.ZERO);
|
}else{
|
record.setScore(new BigDecimal(scoreMap.get(score.getExerciseId()+score.getAnswer())));
|
}
|
record.setEvaluaterId(userId);
|
record.setEvaluater(userName);
|
record.setDeleteFlag(false);
|
TraceUtils.setCreateTrace(record);
|
|
lstDetail.add(record);
|
}
|
|
// 批量保存
|
this.saveOrUpdateAll(lstDetail);
|
|
return new Result(true);
|
}
|
|
/**
|
* 新增评估与记录关联表
|
* @param groupId
|
* @return
|
*/
|
public Result doOperSchEvaRecordRe(String recordId, String evaluateId) {
|
|
String hql = "from SchEvaRecordRe where evaluateId=? and exerciseRecordId=?";
|
|
List<SchEvaRecordRe> recordLst = this.find(hql,
|
CollectionUtils.newList(evaluateId, recordId), SchEvaRecordRe.class);
|
|
if(!recordLst.isEmpty()){
|
return new Result(true);
|
}
|
|
SchEvaRecordRe record = new SchEvaRecordRe();
|
record.setEvaluateId(evaluateId);
|
record.setExerciseRecordId(recordId);
|
//记录答题所在班级
|
if(null != ClientUtils.getUserInfo()){
|
record.setClassId(ClientUtils.getClassId());
|
record.setOrgId(ClientUtils.getOrgId());
|
}
|
|
this.save(record);
|
|
return new Result(true);
|
}
|
|
/**
|
* 更新评估表记录
|
* @return
|
*/
|
public SchEvaluate updateEvaluateCount(String evaluateId) {
|
|
SchEvaluate record = this.read(SchEvaluate.class, evaluateId);
|
|
if(record == null){
|
return null;
|
}
|
|
record.setEvaluateCount(BigInteger.valueOf(this.getEvaluateCount(evaluateId)));
|
TraceUtils.setUpdateTrace(record);
|
|
// 保存
|
this.save(record);
|
|
return record;
|
}
|
|
/**
|
* 查询问卷统计
|
* @param groupId
|
* @param evaluateId
|
* @return
|
*/
|
@Override
|
public ResultJson queryEvaluateStatis(String groupId, String evaluateId) {
|
|
List<ExerciseItem> items = exerciseService.readExerciseItems4Evaluate(groupId);
|
|
SchEvaluate objSchEvaluate = this.read(SchEvaluate.class, evaluateId);
|
|
QExerciseRecord record = QExerciseRecord.exerciseRecord;
|
QExerciseItemAnswerU answerU = QExerciseItemAnswerU.exerciseItemAnswerU;
|
QSchEvaRecordRe re = QSchEvaRecordRe.schEvaRecordRe;
|
QUser qUser = QUser.user;
|
|
for (ExerciseItem objExerciseItem : items) {
|
|
List<Tuple> lstTuple = this.getQueryFactory().select(answerU, qUser)
|
.from(record,answerU,re,qUser)
|
.where(record.recordId.eq(answerU.exerciseRecordId)
|
.and(record.recordId.eq(re.exerciseRecordId))
|
.and(re.evaluateId.eq(evaluateId)).and(qUser.userId.eq(record.userId))
|
.and(answerU.exerciseItemId.eq(objExerciseItem.getExerciseId()))
|
.and(answerU.deleteFlag.eq(false))
|
.and(record.deleteFlag.eq(false))
|
).orderBy(answerU.createTime.desc()).fetch();
|
|
if(lstTuple != null && !lstTuple.isEmpty()) {
|
List<ExerciseItemAnswerU> lstExerciseItemAnswerU = new ArrayList<>();
|
for(Tuple tuple : lstTuple) {
|
ExerciseItemAnswerU objExerciseItemAnswerU = tuple.get(answerU);
|
objExerciseItemAnswerU.setImgPath(tuple.get(qUser).getImgPath());
|
lstExerciseItemAnswerU.add(objExerciseItemAnswerU);
|
}
|
|
// 查询答案
|
objExerciseItem.setExerciseItemAnswerU(lstExerciseItemAnswerU);
|
}
|
}
|
objSchEvaluate.setEvaluateCount(BigInteger.valueOf(this.getEvaluateCount(evaluateId)));
|
// 查询应评估总人数
|
objSchEvaluate.setEvaluateAllCount(BigInteger.valueOf(this
|
.queryEvaluateAllCount(objSchEvaluate.getEvalRangeType(),objSchEvaluate.getEvalRangeId().split(","))));
|
|
//拼装前端所需要的数据
|
Map<String, Object> resultMap =
|
ExerciseUtils.packageExerciseDetail(items, objSchEvaluate);
|
|
return new ResultJson(true, "success", resultMap);
|
}
|
|
/**
|
* 查询应评估人数
|
* @param rangeType
|
* @param evalRangeIds
|
* @return
|
*/
|
private long queryEvaluateAllCount(String rangeType, String[] evalRangeIds){
|
|
QClsClassReSubject re = QClsClassReSubject.clsClassReSubject;
|
QStuStudent stu = QStuStudent.stuStudent;
|
QSubject qSubject = QSubject.subject;
|
|
Predicate predicate = null;
|
if(SchEvaluate.EVALUATE_RANGE_LESSON.equals(rangeType)){//课程
|
|
predicate = stu.classId.in(getQueryFactory().select(re.classId).from(re,qSubject)
|
.where(qSubject.origSubjectId.in(evalRangeIds).and(re.subjectId.eq(qSubject.subjectId))
|
.and(qSubject.deleteFlag.isFalse()).and(re.deleteFlag.eq(false))));
|
}else if(SchEvaluate.EVALUATE_RANGE_CLASS.equals(rangeType)){//班级
|
|
predicate = stu.classId.in(evalRangeIds);
|
}else if(SchEvaluate.EVALUATE_RANGE_PERSON.equals(rangeType)){//人员
|
|
return evalRangeIds.length;
|
}
|
|
long allCount = this.getQueryFactory()
|
.from(stu)
|
.where(stu.deleteFlag.eq(false).and(predicate).and(stu.status.eq(StuStudent.STATUS_ACTIVE))).groupBy(stu.userId)
|
.fetchCount();
|
|
return allCount;
|
}
|
|
/**
|
* 获取问卷答卷人数
|
*
|
* @param schEvaluateId
|
* @param classId
|
* @return
|
*/
|
private long getEvaluateCount(String evaluateId){
|
QSchEvaRecordRe re = QSchEvaRecordRe.schEvaRecordRe;
|
QExerciseRecord record = QExerciseRecord.exerciseRecord;
|
|
long count = this.getQueryFactory().from(re,record)
|
.where(re.exerciseRecordId.eq(record.recordId)
|
.and(record.deleteFlag.eq(false))
|
.and(re.evaluateId.eq(evaluateId))
|
).groupBy(record.userId)
|
.fetchCount();
|
|
return count;
|
}
|
|
/**
|
* 查询学生评估list
|
* @return
|
*/
|
@Override
|
public ResultJson queryStuEvaluateList(Pager pager) {
|
|
QEvaluateStuStudentV view = QEvaluateStuStudentV.evaluateStuStudentV;
|
List<EvaluateStuStudentV> lstView = this.getQueryFactory()
|
.selectFrom(view)
|
.where(view.id.userId.eq(ClientUtils.getUserId())).limit(pager.getPageSize()).offset(pager.getOffset())
|
.orderBy(view.createTime.desc())
|
.fetch();
|
|
QSchEvaRecordRe re = QSchEvaRecordRe.schEvaRecordRe;
|
QExerciseRecord r= QExerciseRecord.exerciseRecord;
|
|
ExerciseRecord record = null;
|
for(EvaluateStuStudentV evaV:lstView){
|
|
record = this.getQueryFactory().select(r)
|
.from(re,r)
|
.where(re.exerciseRecordId.eq(r.recordId)
|
.and(re.evaluateId.eq(evaV.getId().getEvaluateId()))
|
.and(r.userId.eq(evaV.getId().getUserId()))
|
.and(r.deleteFlag.eq(false))
|
).groupBy(r.userId).fetchOne();
|
if(record != null) {
|
evaV.setExerciseRecordId(record.getRecordId());
|
evaV.setGroupId(record.getExerciseGroupId());
|
}
|
|
evaV.setEvaluateId(evaV.getId().getEvaluateId());
|
evaV.setUserId(evaV.getId().getUserId());
|
}
|
|
return new ResultJson(true,"success",lstView);
|
}
|
|
/**
|
* 查询学生评估count
|
* @return
|
*/
|
@Override
|
public Map<String, Object> queryStuEvaluateCount() {
|
|
QEvaluateStuStudentV view = QEvaluateStuStudentV.evaluateStuStudentV;
|
|
long allCount = this.getQueryFactory()
|
.selectFrom(view)
|
.where(view.id.userId.eq(ClientUtils.getUserId()))
|
.fetchCount();
|
QSchEvaRecordRe re = QSchEvaRecordRe.schEvaRecordRe;
|
QExerciseRecord r= QExerciseRecord.exerciseRecord;
|
|
long doCount = this.getQueryFactory().select(view).distinct()
|
.from(re,r, view)
|
.where(re.exerciseRecordId.eq(r.recordId)
|
.and(re.evaluateId.eq(view.id.evaluateId))
|
.and(r.userId.eq(ClientUtils.getUserId())).and(view.id.userId.eq(ClientUtils.getUserId()))
|
.and(r.deleteFlag.eq(false))
|
).fetchCount();
|
|
return CollectionUtils.newObjectMap("allCount", allCount, "doCount", doCount);
|
}
|
|
/**
|
* 获取评估题目
|
* @param templateId
|
* @param status
|
* @param exerciseRecordId
|
* @return
|
*/
|
@Override
|
public ResultJson doGetEvalExerItemResponseDataNew(String evaluateId) {
|
String groupId = this.findUnique("select t.groupId from SchEvaluateTemplate t,SchEvaluate e "
|
+ "where t.evaluateTemplateId=e.evalTemplateId and e.evaluateId=?",
|
CollectionUtils.newList(evaluateId),String.class);
|
|
// 2.查找评估组下所有对应的练习
|
String hql_item = "select item"
|
+ " from ExerciseItem item, ExerciseGroupItemRe re, ExerciseGroup g"
|
+ " where item.exerciseId=re.exerciseItemId "
|
+ " and re.exerciseGroupId=g.groupId"
|
+ " and g.groupId=? "
|
+ " and g.deleteFlag is false"
|
+ " and re.deleteFlag is false"
|
+ " and item.deleteFlag is false"
|
+ " order by re.itemOrder";
|
|
List<ExerciseItem> lstItems = this.find(hql_item, CollectionUtils.newList(groupId), ExerciseItem.class);
|
if(lstItems.isEmpty()){
|
return new ResultJson(false,"当前评估未添加题目");
|
}
|
//查询用户所填答案
|
List<ExerciseItemAnswerU> lstUserAnswer = null;
|
String exerciseRecordId = this.findUnique("select r.recordId from SchEvaRecordRe re, ExerciseRecord r "
|
+ "where re.exerciseRecordId=r.recordId and re.evaluateId=? and r.deleteFlag is false and r.userId = ?",
|
CollectionUtils.newList(evaluateId, ClientUtils.getUserId()), String.class);
|
if(StringUtils.isNoneBlank(exerciseRecordId)){
|
String hql_options = "select o from ExerciseItemAnswerU o where o.exerciseRecordId = ? and o.deleteFlag is false";
|
lstUserAnswer = this.find(hql_options, CollectionUtils.newList(exerciseRecordId), ExerciseItemAnswerU.class);
|
}
|
// 2.1.组装参数 用于查询问卷选项图片
|
Map<String, Object> argsImgMap = new HashMap<String, Object>();
|
String argImgs = "";
|
Map<String, Object> argsMap = new HashMap<String, Object>();
|
Object[] args = new Object[lstItems.size()];
|
for(int i=0; i<lstItems.size(); i++){
|
ExerciseItem objExerciseItem = lstItems.get(i);
|
args[i] = objExerciseItem.getExerciseId();
|
objExerciseItem.setAnswer(null);
|
List<ExerciseItemOption> options = objExerciseItem.getOptions();
|
if(options == null || options.isEmpty()){
|
continue;
|
}else{
|
for(int j=0; j<options.size(); j++){
|
argImgs = argImgs.concat(options.get(j).getOptionId().concat(j == (options.size() - 1)?"":";"));
|
}
|
}
|
}
|
argsMap.put("exerciseIds", args);
|
argsImgMap.put("optionIds", argImgs.split(";"));
|
// 2-3-1查询题目是否关联图片
|
String hql_itemImgs = "from ExerciseObjectImg where exerciseObjectId in (:exerciseIds) and deleteFlag is false and objectType=1 order by exerciseObjectId,imgOrder ";
|
List<ExerciseObjectImg> lstItemImgs = this.findByComplexHql(hql_itemImgs, argsMap, ExerciseObjectImg.class);
|
// 2-3-2查询题目选项是否关联图片
|
String hql_optionImgs = "from ExerciseObjectImg where exerciseObjectId in (:optionIds) and deleteFlag is false and objectType=2";
|
List<ExerciseObjectImg> lstOptionImgs = this.findByComplexHql(hql_optionImgs, argsImgMap, ExerciseObjectImg.class);
|
|
// 重新组装练习选项
|
ExerciseUtils.packageExerciseItem(lstItems, lstUserAnswer, lstOptionImgs);
|
|
Map<String, List<ExerciseObjectImg>> imgItemMap = ExerciseUtils.packageExerciseItemImg(lstItemImgs);
|
|
for(ExerciseItem item:lstItems){
|
// 4.5题目中是否有图片
|
if(imgItemMap.get(item.getExerciseId()) != null){
|
item.setImgs(imgItemMap.get(item.getExerciseId()));
|
}
|
}
|
|
|
return new ResultJson(true,"success",lstItems);
|
}
|
|
}
|
