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.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;
|
|
// ËÑË÷Ãû
|
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::eq,subject.subjectId)
|
.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());
|
|
|
return new ResultJson(true, "success",
|
CollectionUtils.newObjectMap("allCount",results.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);
|
}
|
|
}
|
