package com.qxueyou.scc.exercise.service.impl;
|
|
import java.io.BufferedReader;
|
import java.io.File;
|
import java.io.FileInputStream;
|
import java.io.FileNotFoundException;
|
import java.io.FileReader;
|
import java.io.FileWriter;
|
import java.io.IOException;
|
import java.lang.reflect.InvocationTargetException;
|
import java.math.BigDecimal;
|
import java.math.BigInteger;
|
import java.text.DecimalFormat;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
import org.apache.commons.beanutils.BeanUtils;
|
import org.apache.commons.io.FileUtils;
|
import org.apache.commons.io.IOUtils;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.logging.log4j.LogManager;
|
import org.apache.logging.log4j.Logger;
|
import org.apache.poi.POIXMLDocument;
|
import org.apache.poi.POIXMLTextExtractor;
|
import org.apache.poi.hwpf.extractor.WordExtractor;
|
import org.apache.poi.openxml4j.opc.OPCPackage;
|
import org.apache.poi.xwpf.extractor.XWPFWordExtractor;
|
import org.hibernate.SQLQuery;
|
import org.hibernate.Session;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Qualifier;
|
import org.springframework.data.redis.core.RedisTemplate;
|
import org.springframework.stereotype.Service;
|
|
import com.alibaba.fastjson.JSONArray;
|
import com.qxueyou.scc.admin.classes.model.ClsClass;
|
import com.qxueyou.scc.base.dao.CommonDAO;
|
import com.qxueyou.scc.base.model.Result;
|
import com.qxueyou.scc.base.model.ResultJson;
|
import com.qxueyou.scc.base.service.ICacheService;
|
import com.qxueyou.scc.base.service.IFileUploadService;
|
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.TraceUtils;
|
import com.qxueyou.scc.base.util.UUIDUtils;
|
import com.qxueyou.scc.exercise.dao.ExerciseDAO;
|
import com.qxueyou.scc.exercise.model.ExerciseDeepAnalysis;
|
import com.qxueyou.scc.exercise.model.ExerciseGroup;
|
import com.qxueyou.scc.exercise.model.ExerciseGroupExtend;
|
import com.qxueyou.scc.exercise.model.ExerciseGroupItemRe;
|
import com.qxueyou.scc.exercise.model.ExerciseImportResult;
|
import com.qxueyou.scc.exercise.model.ExerciseItem;
|
import com.qxueyou.scc.exercise.model.ExerciseItemAnalisi;
|
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.ExerciseItemStatistics;
|
import com.qxueyou.scc.exercise.model.ExerciseObjectImg;
|
import com.qxueyou.scc.exercise.model.ExerciseOptionStatistics;
|
import com.qxueyou.scc.exercise.model.ExerciseParse;
|
import com.qxueyou.scc.exercise.model.ExerciseParseResult;
|
import com.qxueyou.scc.exercise.model.ExerciseReCourse;
|
import com.qxueyou.scc.exercise.model.ExerciseRecord;
|
import com.qxueyou.scc.exercise.model.QExerciseGroup;
|
import com.qxueyou.scc.exercise.model.QExerciseGroupItemRe;
|
import com.qxueyou.scc.exercise.model.QExerciseItem;
|
import com.qxueyou.scc.exercise.model.QExerciseItemAnalisi;
|
import com.qxueyou.scc.exercise.model.QExerciseItemAnswerU;
|
import com.qxueyou.scc.exercise.model.QExerciseItemOption;
|
import com.qxueyou.scc.exercise.model.QExerciseObjectImg;
|
import com.qxueyou.scc.exercise.service.IExerciseService;
|
import com.qxueyou.scc.exercise.service.impl.node.Doc;
|
import com.qxueyou.scc.exercise.util.ExerciseUtils;
|
import com.qxueyou.scc.org.model.OrgCharger;
|
import com.qxueyou.scc.school.model.SchClassSubject;
|
import com.qxueyou.scc.school.model.SchCourseware;
|
import com.qxueyou.scc.school.model.SchEvaluate;
|
import com.qxueyou.scc.school.service.ICourseWareService;
|
import com.qxueyou.scc.sys.model.SysFileUploadTrace;
|
import com.qxueyou.scc.sys.service.IOssService;
|
import com.qxueyou.scc.teach.subject.model.SubjectChapter;
|
import com.qxueyou.scc.user.model.UserRegistration;
|
|
/**
|
* 练习 实现service 练习后台
|
*
|
* @author zhiyong
|
*
|
*/
|
@Service
|
public class ExerciseService extends CommonAppService implements IExerciseService {
|
private ExerciseDAO exerDAO;
|
|
@Autowired
|
IOssService ossService;
|
|
@Autowired
|
ICacheService cacheService;
|
|
@Autowired
|
IFileUploadService fileUploadService;
|
|
@Autowired
|
private ICourseWareService courseWareService;
|
|
@SuppressWarnings("rawtypes")
|
@Autowired
|
private RedisTemplate redisTemplate;
|
|
|
private final String[] letter = "A B C D E F G H I J K L M N O P Q".split(" ");
|
|
private static Logger log = LogManager.getLogger("ExerciseService");
|
|
public ExerciseDAO getExerDAO() {
|
return exerDAO;
|
}
|
|
/**
|
* 依赖注入
|
*
|
* @param exerExtendDAO
|
*/
|
@Autowired(required = false)
|
public void setExerDAO(@Qualifier("exerciseDAO") ExerciseDAO exerDAO) {
|
this.exerDAO = exerDAO;
|
}
|
|
|
|
/*
|
* (non-Javadoc)
|
*
|
* @see com.iqtogether.qxueyou.exercise.service.IExerciseService#insertExerciseGroup(java.lang.String, short, java.lang.String, java.lang.String)
|
*/
|
@Override
|
public Result insertExerciseGroup(String name, short type, String lessonId, String chapterId) {
|
|
int iCount = 0;
|
if (type == 3) {
|
// 查询当前class存在的存在的顺序、随机练习或者 章节练习 个数
|
// 可能结果：0、 新增三种；1，新增两种（顺序随机），2，新增一种（章节），3的话，不增加
|
String hsql = "from ExerciseGroup where classId = ? and case when type = ? then 1 when type = ? then 1 when type = ? and "
|
+ " attribute1 = ? and attribute2 = ? then 1 else 0 end = 1 and deleteFlag is false";
|
iCount = findCount(hsql, CollectionUtils.newList(ClientUtils.getClassId(), ExerciseGroup.TYPE_EXERCISE_RANDOM, ExerciseGroup.TYPE_EXERCISE_SEQUENCE, ExerciseGroup.TYPE_CHAPTER_ITEM, lessonId, chapterId));
|
}
|
|
Result objResult = saveOrUpdateAll(initExerciseGroupList(name, type, lessonId, chapterId, iCount));
|
|
// 保存
|
return objResult;
|
}
|
|
/**
|
* 新增练习组
|
*
|
* @param name
|
* 练习组名称
|
* @param type
|
* 练习组类型
|
* @param lessonId
|
* 课程id
|
* @param chapterId
|
* 章节id
|
* @param 模拟考试
|
* 时间设置
|
* @return
|
*/
|
public Result insertExerciseGroup(String groupId,String name, short type, String lessonId, String chapterId, String attribute1, boolean repeatFlag) {
|
|
if(StringUtils.isNotBlank(groupId)){ // 更新
|
|
return updateExerciseGroup(groupId, name, type, lessonId, chapterId, attribute1, repeatFlag);
|
}else{ // 新增
|
|
return saveExerciseGroup(name, type, lessonId, chapterId, attribute1, repeatFlag);
|
}
|
}
|
|
public Result updateExerciseGroup(String groupId,String name, short type, String subjectId, String chapterId, String attribute1, boolean repeatFlag) {
|
ExerciseGroup group = read(ExerciseGroup.class, groupId);
|
|
if(type == ExerciseGroup.TYPE_CHAPTER_ITEM){ // 章节练习
|
|
group.setAttribute2(chapterId);
|
}
|
if (type == ExerciseGroup.TYPE_MOCK_EXAM) {// 模拟考试
|
// 添加练习组时间 、是否重做
|
addExerciseGroupExtendTime(groupId, attribute1, repeatFlag);
|
}
|
if (type == ExerciseGroup.TYPE_HOMEWORK) {// 家庭作业
|
// 添加是否重做
|
addExerciseGroupExtendTime(groupId, null, repeatFlag);
|
}
|
|
group.setName(name);
|
//group.setSubjectId(subjectId);
|
TraceUtils.setUpdateTrace(group);
|
|
return this.saveExerciseGroup(group);
|
}
|
|
public Result saveExerciseGroup(String name, short type, String lessonId, String chapterId, String attribute1, boolean repeatFlag) {
|
int iCount = 0;
|
if (type == ExerciseGroup.TYPE_EXERCISE_SEQUENCE) {
|
// 查询当前class存在的存在的顺序、随机练习或者 章节练习 个数
|
// 可能结果：0、 新增三种；1，新增两种（顺序随机），2，新增一种（章节），3的话，不增加
|
String hsql = "from ExerciseGroup where classId = ? and case when type = ? then 1 when type = ? then 1 when type = ? and "
|
+ " attribute1 = ? and attribute2 = ? then 1 else 0 end = 1 and deleteFlag is false";
|
iCount = findCount(hsql, CollectionUtils.newList(ClientUtils.getClassId(), ExerciseGroup.TYPE_EXERCISE_RANDOM, ExerciseGroup.TYPE_EXERCISE_SEQUENCE, ExerciseGroup.TYPE_CHAPTER_ITEM, lessonId, chapterId));
|
}
|
|
List<ExerciseGroup> lstExeGroup = initExerciseGroupList(name, type, lessonId, chapterId, iCount);
|
|
// 兼容1.0版本 模拟考试时间设置
|
for (ExerciseGroup group : lstExeGroup) {
|
|
group.setOrderNum(BigInteger.valueOf(SchCourseware.COURSEWARE_MAX_ORDER));
|
|
if (ExerciseGroup.TYPE_MOCK_EXAM == group.getType()) {
|
group.setAttribute1(attribute1);
|
}
|
|
this.saveExerciseGroup(group);
|
}
|
|
//Result objResult = saveOrUpdateAll(lstExeGroup);
|
|
if (type == ExerciseGroup.TYPE_MOCK_EXAM) {// 模拟考试
|
// 添加练习组时间 、是否重做
|
addExerciseGroupExtendTime(lstExeGroup.get(0).getGroupId(), attribute1, repeatFlag);
|
}
|
if (type == ExerciseGroup.TYPE_HOMEWORK) {// 家庭作业
|
// 添加是否重做
|
addExerciseGroupExtendTime(lstExeGroup.get(0).getGroupId(), null, repeatFlag);
|
}
|
|
// 保存
|
return new Result(true);
|
}
|
|
/**
|
* 新增题库
|
*
|
* @param name
|
* 练习组名称
|
* @param type
|
* 练习组类型
|
* @param lessonId
|
* 课程id
|
* @param chapterId
|
* 章节id
|
* @param 模拟考试
|
* 时间设置
|
* @return
|
*/
|
public Result insertOrgExercise(ExerciseGroup group, boolean repeatFlag) {
|
|
if(StringUtils.isNotBlank(group.getGroupId())){ // 更新
|
|
return updateOrgExerciseGroup(group, repeatFlag);
|
}else{ // 新增
|
|
return saveOrgExerciseGroup(group, repeatFlag);
|
}
|
}
|
|
public Result updateOrgExerciseGroup(ExerciseGroup group, boolean repeatFlag) {
|
|
ExerciseGroup oldGroup = read(ExerciseGroup.class, group.getGroupId());
|
|
if (oldGroup.getType() == ExerciseGroup.TYPE_MOCK_EXAM) {// 模拟考试
|
// 添加练习组时间 、是否重做
|
addExerciseGroupExtendTime(group.getGroupId(), group.getAttribute1(), repeatFlag);
|
}
|
if (oldGroup.getType() == ExerciseGroup.TYPE_HOMEWORK) {// 家庭作业
|
// 添加是否重做
|
addExerciseGroupExtendTime(group.getGroupId(), null, repeatFlag);
|
}
|
|
oldGroup.setName(group.getName());
|
TraceUtils.setUpdateTrace(oldGroup);
|
|
return this.saveExerciseGroup(oldGroup);
|
}
|
|
public Result saveOrgExerciseGroup(ExerciseGroup group, boolean repeatFlag) {
|
group.setGroupId(null);
|
TraceUtils.setCreateTrace(group);
|
group.setDeleteFlag(false);
|
group.setOrgId(ClientUtils.getOrgId());
|
group.setAllCount(BigInteger.ZERO);
|
this.saveExerciseGroup(group);
|
group.setOriginExerciseId(group.getGroupId());
|
this.saveExerciseGroup(group);
|
|
if (StringUtils.isNotBlank(group.getAttribute1())) {
|
addExerciseGroupExtendTime(group.getGroupId(), group.getAttribute1(), repeatFlag);
|
}
|
if (group.getType() == ExerciseGroup.TYPE_HOMEWORK) {// 家庭作业
|
// 添加是否重做
|
addExerciseGroupExtendTime(group.getGroupId(), null, repeatFlag);
|
}
|
|
this.insertReCourse(group.getCollegeCourseId(), group.getGroupId());
|
|
return new Result(true);
|
}
|
|
/**
|
* 拷贝练习
|
*
|
* @param id
|
* @param subjectId
|
* @param collegeCourseId
|
* @param chapterId
|
* @return
|
* @throws IllegalAccessException
|
* @throws InstantiationException
|
* @throws InvocationTargetException
|
* @throws NoSuchMethodException
|
*/
|
public Result doCopyExerciseGroup(String id, String subjectId, String collegeCourseId, String chapterId) throws IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchMethodException {
|
ExerciseGroup oldExercise = this.read(ExerciseGroup.class, id);
|
|
ExerciseGroup newGroup = new ExerciseGroup();
|
TraceUtils.setCreateTrace(newGroup);
|
newGroup.setGroupId(null);
|
newGroup.setAllCount(oldExercise.getAllCount());
|
newGroup.setClassId(oldExercise.getClassId());
|
newGroup.setAttribute1(oldExercise.getAttribute1());
|
newGroup.setAttribute2(oldExercise.getAttribute2());
|
newGroup.setEditFlag(oldExercise.getEditFlag());
|
newGroup.setOriginExerciseId(oldExercise.getGroupId());
|
newGroup.setOrderNum(BigInteger.valueOf(SchCourseware.COURSEWARE_MAX_ORDER));
|
newGroup.setDoCount("0");
|
newGroup.setType(oldExercise.getType());
|
newGroup.setOrgId(ClientUtils.getOrgId());
|
newGroup.setName(oldExercise.getName());
|
newGroup.setSubjectId(subjectId);
|
newGroup.setChapterId(chapterId);
|
newGroup.setCollegeCourseId(collegeCourseId);
|
|
this.saveExerciseGroup(newGroup);
|
|
//班级拷贝不需要新增关联表
|
if(StringUtils.isEmpty(ClientUtils.getClassId())){
|
newGroup.setOriginExerciseId(newGroup.getGroupId());
|
this.saveExerciseGroup(newGroup);
|
this.insertReCourse(collegeCourseId, newGroup.getGroupId());
|
}
|
|
// 扩展表： extend
|
this.doSaveCopyExtend(oldExercise,newGroup);
|
|
this.doCopyExerciseItem(newGroup.getGroupId(), oldExercise.getGroupId(), null, 1);//拷贝
|
|
return new Result(true);
|
}
|
|
/**
|
* 拷贝练习题
|
*
|
* @param items
|
* @param newGroupId
|
* @param oldGroupId
|
* @throws NoSuchMethodException
|
* @throws InvocationTargetException
|
* @throws InstantiationException
|
* @throws IllegalAccessException
|
*/
|
public void doCopyExerciseItem(String newGroupId, String oldGroupId, List<ExerciseItem> items, int type) throws IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchMethodException{
|
if(items == null || items.size() == 0){
|
items = this.find("select i from ExerciseItem i, ExerciseGroupItemRe r where i.deleteFlag is false AND r.exerciseGroupId = ?"+
|
" and r.exerciseItemId = i.exerciseId AND r.deleteFlag IS FALSE",
|
CollectionUtils.newList(oldGroupId), ExerciseItem.class);
|
}
|
if(items != null && !items.isEmpty()){
|
List<ExerciseItemAnalisi> analysisesNew = new ArrayList<>();
|
List<ExerciseGroupItemRe> reNew = new ArrayList<>();
|
List<ExerciseObjectImg> exerciseObjectImgNew = new ArrayList<>();
|
|
// 得到当前组题目的最大题号
|
int maxGroupItemOrder = queryExerciseGroupItemNo(newGroupId);
|
|
for(ExerciseItem objExerciseItem : items){
|
ExerciseGroupItemRe oldExerciseGroupItemRe = this.findUnique("from ExerciseGroupItemRe where deleteFlag is false and exerciseGroupId = ? and exerciseItemId = ?",
|
CollectionUtils.newList(oldGroupId, objExerciseItem.getExerciseId()), ExerciseGroupItemRe.class);
|
|
//临时对象
|
ExerciseItem tem = new ExerciseItem();
|
tem = (ExerciseItem) BeanUtils.cloneBean(objExerciseItem);
|
List<ExerciseObjectImg> exerciseObjectImg = this.find("from ExerciseObjectImg m where m.deleteFlag is false and m.exerciseObjectId = ?",
|
CollectionUtils.newList(objExerciseItem.getExerciseId()), ExerciseObjectImg.class);
|
ExerciseItemAnalisi analysises = this.findUnique("from ExerciseItemAnalisi m where m.deleteFlag is false and m.exerciseItemId = ?",
|
CollectionUtils.newList(objExerciseItem.getExerciseId()), ExerciseItemAnalisi.class);
|
List<ExerciseItemOption> options = objExerciseItem.getOptions();
|
tem.setOptions(null);
|
tem.setAnalysises(null);
|
// tem.setGroups(null);
|
tem.setScores(null);
|
|
ExerciseItem objExerciseItemNew = new ExerciseItem();
|
BeanUtils.copyProperties(objExerciseItemNew, tem);
|
objExerciseItemNew.setExerciseId(null);
|
//拷贝的练习不同步
|
objExerciseItemNew.setOrgiExerciseId(type == 1?null:StringUtils.isEmpty(objExerciseItem.getOrgiExerciseId())?objExerciseItem.getExerciseId():objExerciseItem.getOrgiExerciseId());
|
TraceUtils.setCreateTrace(objExerciseItemNew);
|
|
this.save(objExerciseItemNew);
|
|
String exerciseIdNew = objExerciseItemNew.getExerciseId();
|
|
for(ExerciseItemOption objExerciseItemOption : options){
|
ExerciseItemOption objExerciseItemOptionNew = new ExerciseItemOption();
|
BeanUtils.copyProperties(objExerciseItemOptionNew, objExerciseItemOption);
|
objExerciseItemOptionNew.setExerciseItemId(exerciseIdNew);
|
objExerciseItemOptionNew.setOptionId(null);
|
|
TraceUtils.setCreateTrace(objExerciseItemOptionNew);
|
|
this.save(objExerciseItemOptionNew);
|
//optionsNew.add(objExerciseItemOptionNew);
|
|
List<ExerciseObjectImg> optionObjectImgs = this.find("from ExerciseObjectImg m where m.deleteFlag is false and m.exerciseObjectId = ?",
|
CollectionUtils.newList(objExerciseItemOption.getOptionId()), ExerciseObjectImg.class);
|
if(optionObjectImgs != null && !optionObjectImgs.isEmpty()){
|
for(ExerciseObjectImg optionObjectImg : optionObjectImgs){
|
ExerciseObjectImg objExerciseObjectImgNew = new ExerciseObjectImg();
|
BeanUtils.copyProperties(objExerciseObjectImgNew, optionObjectImg);
|
objExerciseObjectImgNew.setExerciseObjectId(objExerciseItemOptionNew.getOptionId());
|
objExerciseObjectImgNew.setImgId(null);
|
|
TraceUtils.setCreateTrace(objExerciseObjectImgNew);
|
|
exerciseObjectImgNew.add(objExerciseObjectImgNew);
|
}
|
}
|
}
|
if(analysises != null){
|
ExerciseItemAnalisi objExerciseItemAnalisiNew = new ExerciseItemAnalisi();
|
BeanUtils.copyProperties(objExerciseItemAnalisiNew, analysises);
|
objExerciseItemAnalisiNew.setExerciseItemId(exerciseIdNew);
|
objExerciseItemAnalisiNew.setExerciseAnalisisId(null);
|
|
TraceUtils.setCreateTrace(objExerciseItemAnalisiNew);
|
|
analysisesNew.add(objExerciseItemAnalisiNew);
|
}
|
if(exerciseObjectImg != null && !exerciseObjectImg.isEmpty()){
|
for(ExerciseObjectImg objExerciseObjectImg : exerciseObjectImg){
|
ExerciseObjectImg objExerciseObjectImgNew = new ExerciseObjectImg();
|
BeanUtils.copyProperties(objExerciseObjectImgNew, objExerciseObjectImg);
|
objExerciseObjectImgNew.setExerciseObjectId(exerciseIdNew);
|
objExerciseObjectImgNew.setImgId(null);
|
|
TraceUtils.setCreateTrace(objExerciseObjectImgNew);
|
|
exerciseObjectImgNew.add(objExerciseObjectImgNew);
|
}
|
}
|
|
ExerciseGroupItemRe re = new ExerciseGroupItemRe();
|
re.setDeleteFlag(false);
|
re.setExerciseGroupId(newGroupId);
|
re.setExerciseItemId(exerciseIdNew);
|
re.setRelationId(null);
|
if(oldExerciseGroupItemRe != null){
|
re.setDocOrder(oldExerciseGroupItemRe.getDocOrder());
|
}
|
re.setItemOrder(++maxGroupItemOrder);
|
reNew.add(re);
|
}
|
|
this.saveOrUpdateAll(reNew);
|
//this.saveOrUpdateAll(optionsNew);
|
this.saveOrUpdateAll(analysisesNew);
|
this.saveOrUpdateAll(exerciseObjectImgNew);
|
|
//更新统计
|
this.updateGroupUpdateTimeByList(this.find("from ExerciseGroup where groupId = ?", CollectionUtils.newList(newGroupId), ExerciseGroup.class));
|
}
|
}
|
|
/**
|
* 插入练习和科目关联
|
*
|
* @param collegeCourseId
|
* @param handoutId
|
*/
|
private void insertReCourse(String collegeCourseId, String groupId){
|
// 序号
|
String hql = "select MAX(c.orderNum) from ExerciseReCourse c where c.deleteFlag is false and c.collegeCourseId = ? and orgId = ? ";
|
Integer iMax = this.findUnique(hql, CollectionUtils.newList(collegeCourseId, ClientUtils.getOrgId()), Integer.class);
|
|
if (iMax == null || iMax == 0) {
|
iMax = 1;
|
} else {
|
iMax = iMax + 1;
|
}
|
|
ExerciseReCourse course = new ExerciseReCourse();
|
TraceUtils.setCreateTrace(course);
|
course.setCollegeCourseId(collegeCourseId);
|
course.setDeleteFlag(false);
|
course.setGroupId(groupId);
|
course.setOrgId(ClientUtils.getOrgId());
|
course.setOrderNum(iMax);
|
save(course);
|
}
|
|
public Result insertAppointExercise(String groupIds[], String orgIds[], String classIds[]) {
|
|
if (null == groupIds || groupIds.length == 0) {
|
return new Result(false, "参数错误");
|
}
|
// 一次性查询groupId对应的collegeCourseId
|
String hql = " from ExerciseReCourse where groupId in (:groupIds) and deleteFlag is false";
|
Map<String, Object> argsMap = new HashMap<String, Object>();
|
argsMap.put("groupIds", groupIds);
|
List<ExerciseReCourse> courseList = findByComplexHql(hql, argsMap, ExerciseReCourse.class);
|
|
// 放入map中 KEY:groupId VALUE:collegeCourseId
|
Map<String, String> groupReCourse = new HashMap<String, String>();
|
for (ExerciseReCourse exerciseReCourse : courseList) {
|
groupReCourse.put(exerciseReCourse.getGroupId(), exerciseReCourse.getCollegeCourseId());
|
}
|
|
// 一次性查询classId对应的orgId
|
Map<String, String> classMap = new HashMap<String, String>();
|
if (classIds.length > 0) {
|
hql = " from ClsClass where classId in (:classIds) and deleteFlag is false";
|
argsMap = new HashMap<String, Object>();
|
argsMap.put("classIds", classIds);
|
List<ClsClass> classList = findByComplexHql(hql, argsMap, ClsClass.class);
|
|
// 放入map中 KEY:classId VALUE:orgId
|
|
for (ClsClass orgClass : classList) {
|
classMap.put(orgClass.getClassId(), orgClass.getOrgId());
|
}
|
}
|
|
// 一次性查询groupId对应的orderNum
|
Map<String, Integer> orderMap = new HashMap<String, Integer>();
|
|
hql = " from ExerciseReCourse where groupId in (:groupIds) and deleteFlag is false and orgId = :currOrgId";
|
argsMap = new HashMap<String, Object>();
|
argsMap.put("groupIds", groupIds);
|
argsMap.put("currOrgId", ClientUtils.getOrgId());
|
List<ExerciseReCourse> courseLst = findByComplexHql(hql, argsMap, ExerciseReCourse.class);
|
|
// 放入map中 KEY:classId VALUE:orgId
|
for (ExerciseReCourse c : courseLst) {
|
orderMap.put(c.getGroupId(), c.getOrderNum());
|
}
|
|
for (String groupId : groupIds) {
|
if (orgIds.length > 0) { // 指定给机构
|
insertOrgGroup(groupId, orgIds, groupReCourse.get(groupId),orderMap);
|
}
|
if (classIds.length > 0) { // 指定给班级
|
ExerciseGroup group = read(ExerciseGroup.class, groupId);
|
insertClassGroup(groupId, classIds, group, groupReCourse.get(groupId), classMap,orderMap);
|
}
|
}
|
return new Result(true);
|
}
|
|
/**
|
* 指定给机构
|
*
|
* @param groupId
|
* @param orgIds
|
* @param groupReCourse
|
* @return
|
*/
|
public void insertOrgGroup(String groupId, String orgIds[], String collegeCourseId,Map<String, Integer> orderMap) {
|
// 查询出所有不符合条件的数据
|
String hql = "select orgId from ExerciseReCourse where groupId = :groupId and deleteFlag is false and orgId in (:orgIds)";
|
Map<String, Object> args = new HashMap<String, Object>();
|
args.put("groupId", groupId);
|
args.put("orgIds", orgIds);
|
List<String> strings = findByComplexHql(hql, args, String.class);
|
List<String> orgList = new ArrayList<String>();
|
for (String orgId : orgIds) {
|
orgList.add(orgId);
|
}
|
// 剔除掉不符合条件的orgId
|
orgList.removeAll(strings);
|
if(orgList.isEmpty()){
|
return;
|
}
|
|
for (String orgId : orgList) {
|
ExerciseReCourse exerCourse = new ExerciseReCourse();
|
exerCourse.setExerciseCourseId(null);
|
exerCourse.setOrgId(orgId);
|
exerCourse.setGroupId(groupId);
|
exerCourse.setCollegeCourseId(collegeCourseId);
|
exerCourse.setDeleteFlag(false);
|
exerCourse.setOrderNum(orderMap.get(groupId));
|
TraceUtils.setCreateTrace(exerCourse);
|
save(exerCourse);
|
|
this.courseWareService.insertOrgCourseware(groupId, ClientUtils.getOrgId(), orgId, collegeCourseId);
|
}
|
|
}
|
/**
|
* 指定给班级
|
* @param groupId
|
* @param classIds
|
* @param group
|
* @param collegeCourseId
|
* @param classMap
|
*/
|
public void insertClassGroup(String groupId, String classIds[], ExerciseGroup group, String collegeCourseId, Map<String, String> classMap,Map<String, Integer> orderMap) {
|
//章节id
|
Map<String,SubjectChapter> origChapterMap = new HashMap<String, SubjectChapter>();
|
Map<String, String> subjectMap = new HashMap<String, String>();
|
String hql = "from ExerciseGroupExtend where deleteFlag is false and groupId=? ";
|
// 查询练习组扩展表
|
ExerciseGroupExtend extend = this.findUnique(hql, CollectionUtils.newList(groupId), ExerciseGroupExtend.class);
|
|
//hql = " from ExerciseGroupItemRe where exerciseGroupId = ? and deleteFlag is false ";
|
//List<ExerciseGroupItemRe> lstItem = find(hql, CollectionUtils.newList(groupId), ExerciseGroupItemRe.class);
|
|
// 查询出所有不符合条件的数据
|
hql = "select classId from ExerciseGroup where classId in (:classIds) and originExerciseId = :groupId and deleteFlag is false";
|
Map<String, Object> args = new HashMap<String, Object>();
|
args.put("classIds", classIds);
|
args.put("groupId", groupId);
|
List<String> strings = findByComplexHql(hql, args, String.class);
|
List<String> classList = new ArrayList<String>();
|
for (String classId : classIds) {
|
classList.add(classId);
|
}
|
// 剔除不符合的classId
|
classList.removeAll(strings);
|
if(classList.isEmpty()){
|
return;
|
}
|
if(StringUtils.isNotEmpty(group.getSubjectId())){
|
// 一次性查询班级ID对应的classSubjectId
|
hql = " from SchClassSubject where classId in(:classIds) and origSubjectId = :subjectId and deleteFlag is false";
|
args = new HashMap<String, Object>();
|
args.put("classIds", classList.toArray());
|
args.put("subjectId", group.getSubjectId());
|
List<SchClassSubject> lstClassSubject = findByComplexHql(hql, args, SchClassSubject.class);
|
for (SchClassSubject schClassSubject : lstClassSubject) {
|
subjectMap.put(schClassSubject.getClassId(), schClassSubject.getClassSubjectId());
|
}
|
}
|
for (String classId : classList) {
|
|
ExerciseGroup newGroup = new ExerciseGroup();
|
newGroup.setAllCount(group.getAllCount());
|
newGroup.setAttribute1(group.getAttribute1());
|
newGroup.setAttribute2(group.getAttribute2());
|
newGroup.setCollegeCourseId(collegeCourseId);
|
newGroup.setDeleteFlag(false);
|
newGroup.setDoCount(group.getDoCount());
|
newGroup.setName(group.getName());
|
newGroup.setOrgId(classMap.get(classId));
|
newGroup.setType(group.getType());
|
newGroup.setClassId(classId);
|
newGroup.setOriginExerciseId(groupId);
|
newGroup.setOrderNum(group.getOrderNum());
|
newGroup.setSubjectId(subjectMap.get(classId));
|
if(null != origChapterMap.get(classId)){
|
newGroup.setChapterId(origChapterMap.get(classId).getChapterId());
|
}else{
|
newGroup.setChapterId(null);
|
}
|
TraceUtils.setCreateTrace(newGroup);
|
this.saveExerciseGroup(newGroup);
|
|
if (extend != null) {
|
if (StringUtils.isNotBlank(extend.getExerciseTime())) {
|
addExerciseGroupExtendTime(newGroup.getGroupId(), extend.getExerciseTime(), extend.getRepeatFlag());
|
}
|
if (newGroup.getType() == ExerciseGroup.TYPE_HOMEWORK) {// 家庭作业
|
// 添加是否重做
|
addExerciseGroupExtendTime(newGroup.getGroupId(), null, extend.getRepeatFlag());
|
}
|
}
|
try {
|
|
this.doCopyExerciseItem(newGroup.getGroupId(), groupId, null, 2);
|
|
}catch (IllegalAccessException e) {
|
log.error("下发练习出错", e);
|
} catch (InvocationTargetException e) {
|
log.error("下发练习出错", e);
|
} catch (InstantiationException e) {
|
log.error("下发练习出错", e);
|
} catch (NoSuchMethodException e) {
|
log.error("下发练习出错", e);
|
}
|
}
|
}
|
|
|
|
/**
|
* 添加练习时间
|
*
|
* @param groupId
|
* @param exerciseTime
|
* @return
|
*/
|
public Result addExerciseGroupExtendTime(String groupId, String exerciseTime, boolean repeatFlag) {
|
|
String hql = "from ExerciseGroupExtend where deleteFlag is false and groupId=? ";
|
|
// 查询练习组扩展表
|
ExerciseGroupExtend extend = this.findUnique(hql, CollectionUtils.newList(groupId), ExerciseGroupExtend.class);
|
|
if (null == extend) {
|
extend = new ExerciseGroupExtend();
|
extend.setGroupId(groupId);
|
extend.setExerciseTime(exerciseTime);
|
extend.setRepeatFlag(repeatFlag);
|
|
insertExerciseGroupExtend(extend);
|
} else {
|
extend.setExerciseTime(exerciseTime);
|
extend.setRepeatFlag(repeatFlag);
|
updateExerciseGroupExtend(extend);
|
}
|
|
return new Result(true);
|
}
|
|
/**
|
* 新增练习扩展表
|
*
|
* @param extend
|
* @return
|
*/
|
public Result insertExerciseGroupExtend(ExerciseGroupExtend extend) {
|
|
extend.setDeleteFlag(false);
|
TraceUtils.setCreateTrace(extend);
|
this.save(extend);
|
|
return new Result(true);
|
}
|
|
/**
|
* 更新练习扩展表
|
*
|
* @param extend
|
* @return
|
*/
|
public Result updateExerciseGroupExtend(ExerciseGroupExtend extend) {
|
|
TraceUtils.setUpdateTrace(extend);
|
this.save(extend);
|
|
return new Result(true);
|
}
|
|
/*
|
* (non-Javadoc)
|
*
|
* @see com.iqtogether.qxueyou.exercise.service.IExerciseService#readExerciseItems(java.lang.String)
|
*/
|
@Override
|
public List<ExerciseItem> readExerciseItems(String groupId) {
|
ExerciseGroup group = read(ExerciseGroup.class, groupId);
|
List<ExerciseItem> lst = group.getItems();
|
TraceUtils.removeDelete(lst);
|
return lst;
|
}
|
|
/*
|
* (non-Javadoc)
|
*
|
* @see com.iqtogether.qxueyou.exercise.service.IExerciseService#readExerciseItems(java.lang.String) 20150901：增加排序，习题数据和前台app顺序默认一致，题号保持一致。随机练习处理
|
*/
|
@Override
|
public List<ExerciseItem> readExerciseItemsWithNo(String groupId) {
|
|
ExerciseGroup group = read(ExerciseGroup.class, groupId);
|
if (null == group) {
|
return null;
|
}
|
|
// 默认章节练习
|
String hql = "select item,re.docOrder,re.relationId " + "from ExerciseItem item,ExerciseGroupItemRe re " + "where re.exerciseGroupId=? " + "and re.exerciseItemId=item.exerciseId " + "and item.deleteFlag is false " + "and re.deleteFlag is false " + "order by re.itemOrder ";
|
|
// 随机练习,顺序练习
|
if (ExerciseGroup.TYPE_EXERCISE_RANDOM == group.getType() || ExerciseGroup.TYPE_EXERCISE_SEQUENCE == group.getType()) {
|
hql = "select item,re.docOrder,re.relationId " + "from ExerciseItem item,ExerciseGroupItemRe re " + "where re.exerciseGroupId=? and " + "re.exerciseItemId=item.exerciseId " + "and item.deleteFlag is false " + "and re.deleteFlag is false " + "order by item.chapterId, re.itemOrder ";
|
}
|
|
List<Object[]> objs = this.exerDAO.findwithRawResult(hql, CollectionUtils.newList(groupId));
|
|
List<ExerciseItem> items = new ArrayList<ExerciseItem>(objs.size());
|
|
ExerciseItem item;
|
ExerciseItem newitem;
|
if (null != objs && !objs.isEmpty()) {
|
for (int iNum = 0; iNum < objs.size(); iNum++) {
|
if (null == objs.get(iNum)) {
|
continue;
|
}
|
|
item = new ExerciseItem();
|
try {
|
newitem = (ExerciseItem) objs.get(iNum)[0];
|
newitem.setOptions(null);
|
newitem.setScores(null);
|
newitem.setAnalysises(null);
|
BeanUtils.copyProperties(item, newitem);
|
} catch (IllegalAccessException e) {
|
log.error(e, e);
|
} catch (InvocationTargetException e) {
|
log.error(e, e);
|
}
|
|
// 此序号和app一致
|
item.setItemNo(iNum + 1);
|
|
// 此序号和导入的doc文档一致，如果是导入的习题
|
if (null != objs.get(iNum)[1]) {
|
item.setDocNo((int) objs.get(iNum)[1]);
|
}
|
|
// 关联表ID
|
if (null != objs.get(iNum)[2]) {
|
item.setReId((String) objs.get(iNum)[2]);
|
}
|
|
items.add(item);
|
|
}
|
}
|
|
return items;
|
}
|
|
/**
|
* 查看问卷详情
|
*
|
* @param groupId
|
* 问题组id
|
* @param evaluateTemId
|
* 模板id
|
* @return
|
*/
|
@Override
|
public List<ExerciseItem> readExerciseItems4Evaluate(String groupId) {
|
|
ExerciseGroup group = this.read(ExerciseGroup.class, groupId);
|
if (null == group) {
|
new ResultJson(false, "习题组不存在");
|
}
|
|
QExerciseItem qItem = QExerciseItem.exerciseItem;
|
QExerciseGroupItemRe qRe = QExerciseGroupItemRe.exerciseGroupItemRe;
|
|
List<ExerciseItem> lstItems = this.getQueryFactory()
|
.select(qItem)
|
.from(qItem,qRe)
|
.where(qItem.exerciseId.eq(qRe.exerciseItemId)
|
.and(qRe.exerciseGroupId.eq(groupId))
|
.and(qItem.deleteFlag.eq(false))
|
.and(qRe.deleteFlag.eq(false)))
|
.orderBy(qRe.itemOrder.asc())
|
.fetch();
|
|
if(lstItems.isEmpty()){
|
return lstItems;
|
}
|
|
// 0.组装参数
|
Map<String, Object> argsMap = new HashMap<String, Object>();
|
Object[] args = new Object[lstItems.size()];
|
for(int i=0; i<lstItems.size(); i++){
|
args[i] = lstItems.get(i).getExerciseId();
|
}
|
argsMap.put("exerciseIds", args);
|
|
// 1.查询练习题目全站分析
|
String hql_analisis = "from ExerciseItemAnalisi where exerciseItemId in (:exerciseIds) and deleteFlag is false ";
|
List<ExerciseItemAnalisi> lstAnalisis = this.findByComplexHql(hql_analisis, argsMap, ExerciseItemAnalisi.class);
|
Map<String, ExerciseItemAnalisi> analisiMap = new HashMap<String, ExerciseItemAnalisi>(lstAnalisis.size());
|
for(ExerciseItemAnalisi analisis:lstAnalisis){
|
analisiMap.put(analisis.getExerciseItemId(), analisis);
|
}
|
|
// 2.查询练习题目答案选项
|
Map<String, List<ExerciseItemOption>> optionsMap = new HashMap<String, List<ExerciseItemOption>>(lstItems.size());
|
Map<String, String> answerMap = new HashMap<String, String>();
|
String hql_options = "from ExerciseItemOption where exerciseItemId in (:exerciseIds) and deleteFlag is false order by exerciseItemId, optionOrder ";
|
List<ExerciseItemOption> lstAllOptions = this.findByComplexHql(hql_options, argsMap, ExerciseItemOption.class);
|
// 2.1.组装参数 用于查询练习选项图片
|
Map<String, Object> argsImgMap = new HashMap<String, Object>();
|
Object[] argImgs = new Object[lstAllOptions.size()];
|
for(int i=0; i<lstAllOptions.size(); i++){
|
argImgs[i] = lstAllOptions.get(i).getOptionId();
|
}
|
argsImgMap.put("optionIds", argImgs);
|
|
// 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);
|
Map<String, List<ExerciseObjectImg>> imgItemMap = ExerciseUtils.packageExerciseItemImg(lstItemImgs);
|
|
Map<String, List<ExerciseObjectImg>> imgOptionMap = null;
|
if(argImgs.length > 0) {
|
// 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);
|
imgOptionMap = ExerciseUtils.packageExerciseItemImg(lstOptionImgs);
|
}
|
|
// 重新组装练习
|
ExerciseUtils.packageExerciseItem(optionsMap, answerMap, lstAllOptions, imgOptionMap);
|
|
|
// 4.重新组装返回结果
|
String exerciseId = null;
|
for(ExerciseItem item:lstItems){
|
// 4.0 分析结果
|
exerciseId = item.getExerciseId();
|
|
// 得到练习组id
|
if(StringUtils.isNotBlank(groupId)){
|
item.setExerciseGroupId(groupId);
|
}
|
|
// 4.3 题目选项
|
item.setOptions(optionsMap.get(exerciseId));
|
|
// 4.5题目中是否有图片
|
if(imgItemMap.get(exerciseId) != null){
|
item.setImgs(imgItemMap.get(exerciseId));
|
}
|
|
if(analisiMap.get(exerciseId) != null){
|
item.setAnalisis(analisiMap.get(exerciseId));
|
}
|
}
|
|
return lstItems;
|
}
|
|
/*
|
* (non-Javadoc)
|
*
|
* @see com.iqtogether.qxueyou.exercise.service.IExerciseService#insertExerciseItem(java.lang.String, com.iqtogether.qxueyou.exercise.model.ExerciseItem, java.util.List)
|
*/
|
@Override
|
public Result insertExerciseItem(String groupId, ExerciseItem item, List<ExerciseItemOption> lstOptions, String analysis) {
|
|
TraceUtils.setCreateTrace(lstOptions);
|
// 1. 保存习题
|
ExerciseGroup group = this.read(ExerciseGroup.class, groupId);
|
handlerExerciseItem(group, item);
|
save(item);
|
|
// 2. 保存习题和习题组关系
|
// 获取一个习题需要跟新的关系条数
|
List<ExerciseGroup> result = initExerciseGroup(groupId);
|
|
// 得到当前组题目的最大题号
|
int maxGroupItemOrder = queryExerciseGroupItemNo(groupId);
|
|
List<ExerciseGroupItemRe> groupRes = initExerciseGroupItemRe(result, item.getExerciseId(), getGroupReMaxOrder(groupId), ++maxGroupItemOrder );
|
|
// 得到最大的ORDER
|
saveOrUpdateAll(groupRes);
|
|
// 20150618：配合前台app，所有修改同时修改group表最后修改时间
|
updateGroupUpdateTimeByList(result);
|
|
// 3. 保存习题解析
|
ExerciseItemAnalisi analysisVO = new ExerciseItemAnalisi();
|
analysisVO.setAnalysis(analysis);
|
analysisVO.setAccuracy(BigDecimal.ZERO);
|
analysisVO.setSubmitCorrectNumber(BigInteger.ZERO);
|
analysisVO.setSubmitNumber(BigInteger.ZERO);
|
item.setAnalisis(analysisVO);
|
saveAnalysis(item);
|
|
|
// 4. 保存习题选项
|
for (ExerciseItemOption option : lstOptions) {
|
option.setExerciseItemId(item.getExerciseId());
|
save(option);
|
// 新增习题选项图片
|
updateExerOptionObjImgId(option);
|
}
|
item.setOptions(lstOptions);
|
|
// 新增习题图片
|
updateExerciseObjImgId(item);
|
|
//保存题目分数
|
List<ExerciseItemScore> lstExerciseItemScore = item.getScores();
|
if(lstExerciseItemScore!=null && lstExerciseItemScore.size()>0){
|
for (ExerciseItemScore score : lstExerciseItemScore) {
|
TraceUtils.setCreateTrace(score);
|
score.setGroupId(groupId);
|
score.setExerciseItemId(item.getExerciseId());
|
save(score);
|
}
|
}
|
|
// if(StringUtils.isEmpty(group.getClassId())){
|
// // 同步习题
|
// String hql = " from ExerciseGroup where originExerciseId = ? and deleteFlag is false and groupId != ?";
|
// List<ExerciseGroup> lstGroup = find(hql, CollectionUtils.newList(group.getOriginExerciseId(), groupId), ExerciseGroup.class);
|
// List<ExerciseItem> items = find("from ExerciseItem where exerciseId = ?", CollectionUtils.newList(item.getExerciseId()), ExerciseItem.class);
|
// for (ExerciseGroup exerciseGroup : lstGroup) {
|
// exerciseGroup.setAllCount(group.getAllCount());
|
// TraceUtils.setUpdateTrace(exerciseGroup);
|
// this.saveExerciseGroup(exerciseGroup);
|
// try {
|
// this.doCopyExerciseItem(exerciseGroup.getGroupId(), groupId, items, 2);
|
// } catch (IllegalAccessException | InstantiationException | InvocationTargetException
|
// | NoSuchMethodException e) {
|
// log.error("新增练习同步到班级错误", e);
|
// }
|
// }
|
// }
|
|
return new Result(true, item.getExerciseId());
|
}
|
|
/*
|
* (non-Javadoc)
|
*
|
* @see com.iqtogether.qxueyou.exercise.service.IExerciseService#insertExerciseItem(java.lang.String, com.iqtogether.qxueyou.exercise.model.ExerciseItem, java.util.List)
|
*/
|
@Override
|
public ResultJson insertExerciseItem4Evaluate(String groupId, ExerciseItem item,
|
List<ExerciseItemOption> lstOptions,String analysis,JSONArray titleImgs) {
|
// 1. 保存习题
|
TraceUtils.setCreateTrace(item);
|
this.save(item);
|
|
// 2、保存习题关联组
|
QExerciseGroupItemRe qRe =QExerciseGroupItemRe.exerciseGroupItemRe;
|
Integer maxGroupItemOrder =
|
this.getQueryFactory().select(qRe.itemOrder.max())
|
.from(qRe).where(qRe.deleteFlag.eq(false).and(qRe.exerciseGroupId.eq(groupId)))
|
.fetchOne();
|
|
if (maxGroupItemOrder == null) {
|
maxGroupItemOrder = 0;
|
}
|
|
ExerciseGroupItemRe re = new ExerciseGroupItemRe();
|
re.setExerciseGroupId(groupId);
|
re.setExerciseItemId(item.getExerciseId());
|
re.setItemOrder(maxGroupItemOrder);
|
re.setDeleteFlag(false);
|
this.save(re);
|
|
// 题目组题目个数+1
|
QExerciseGroup g = QExerciseGroup.exerciseGroup;
|
this.getQueryFactory()
|
.update(g)
|
.set(g.allCount, g.allCount.add(BigInteger.ONE))
|
.where(g.groupId.eq(groupId))
|
.execute();
|
|
|
// 3. 保存习题选项
|
for (int i = 0; i < lstOptions.size(); i++) {
|
ExerciseItemOption option = lstOptions.get(i);
|
option.setExerciseItemId(item.getExerciseId());
|
option.setOptionId(null);
|
option.setOptionOrder(letter[i]);
|
TraceUtils.setCreateTrace(option);
|
this.save(option);
|
|
// 更新选项图片
|
updateEvaExerOptionObjImgId(option);
|
|
ExerciseItemScore objExerciseItemScore = new ExerciseItemScore();
|
TraceUtils.setCreateTrace(objExerciseItemScore);
|
objExerciseItemScore.setAttribute1(option.getOptionId());
|
objExerciseItemScore.setExerciseItemId(item.getExerciseId());
|
objExerciseItemScore.setExerciseItemAnswer(letter[i]);
|
objExerciseItemScore.setScore(String.valueOf(option.getScore()));
|
this.save(objExerciseItemScore);
|
}
|
|
// 更新题目图片
|
this.updateEvaExerciseObjImgId(titleImgs,item.getExerciseId());
|
|
// 4. 保存习题解析
|
ExerciseItemAnalisi analysisVO = new ExerciseItemAnalisi();
|
analysisVO.setAnalysis(analysis);
|
analysisVO.setAccuracy(BigDecimal.ZERO);
|
analysisVO.setSubmitCorrectNumber(BigInteger.ZERO);
|
analysisVO.setSubmitNumber(BigInteger.ZERO);
|
TraceUtils.setCreateTrace(analysisVO);
|
analysisVO.setDeleteFlag(false);
|
analysisVO.setExerciseItemId(item.getExerciseId());
|
save(analysisVO);
|
|
return new ResultJson(true);
|
}
|
|
/**
|
* 更新习题选项图片对象结果
|
*
|
* @param optionId
|
* @param imgIds
|
* @return
|
*/
|
private Result updateExerciseObjImgId(ExerciseItem item) {
|
|
List<ExerciseObjectImg> imgs = item.getImgs();
|
if (imgs == null || imgs.isEmpty()) {
|
return new Result(false);
|
}
|
Object[] imgIds = new Object[imgs.size()];
|
for (int i = 0; i < imgs.size(); i++) {
|
imgIds[i] = imgs.get(i).getImgId();
|
}
|
String hql = "update ExerciseObjectImg set exerciseObjectId='" + item.getExerciseId() + "' where imgId=? and deleteFlag is false";
|
|
this.bulkUpdateInLoop(hql, imgIds);
|
|
return new Result(true);
|
}
|
|
/**
|
* 更新习题选项图片对象结果
|
*
|
* @param optionId
|
* @param imgIds
|
* @return
|
*/
|
private Result updateExerOptionObjImgId(ExerciseItemOption option) {
|
|
List<ExerciseObjectImg> imgs = option.getImgs();
|
if (imgs == null || imgs.isEmpty()) {
|
return new Result(false);
|
}
|
Object[] imgIds = new Object[imgs.size()];
|
for (int i = 0; i < imgs.size(); i++) {
|
imgIds[i] = imgs.get(i).getImgId();
|
}
|
String hql = "update ExerciseObjectImg set exerciseObjectId='" + option.getOptionId() + "' where imgId=? and deleteFlag is false";
|
|
this.bulkUpdateInLoop(hql, imgIds);
|
|
return new Result(true);
|
}
|
|
/**
|
* 处理exerciseItem
|
*
|
* @param groupId
|
* @param item
|
*/
|
private void handlerExerciseItem(ExerciseGroup group, ExerciseItem item) {
|
// 如果是章节练习，将章节写到exerciseItem
|
if (ExerciseGroup.TYPE_CHAPTER_ITEM == group.getType()) {
|
item.setChapterId(group.getAttribute2());
|
}
|
TraceUtils.setCreateTrace(item);
|
}
|
|
private int getGroupReMaxOrder(String groupId) {
|
String hql = "select max(itemOrder) from ExerciseGroupItemRe where deleteFlag is false and exerciseGroupId = ? ";
|
Integer maxOrder = this.findUnique(hql, CollectionUtils.newList(groupId), Integer.class);
|
if (null == maxOrder) {
|
maxOrder = 0;
|
}
|
return maxOrder + 1;
|
}
|
|
/**
|
* 刪除练习关联表数据
|
*
|
* @param reIds
|
* @return
|
*/
|
private Result deleteExerciseGroupRe(String[] reIds) {
|
|
String hql = "update ExerciseGroupItemRe set deleteFlag=1 where relationId=? ";
|
|
this.bulkUpdateInLoop(hql, reIds);
|
|
return new Result(true);
|
}
|
|
/**
|
* 删除练习题：只删除关系 (统一班级下，顺序随机 同步删除)
|
*
|
* @param exerciceIds
|
* @param reIds
|
* @param groupId
|
* @return
|
*/
|
@SuppressWarnings("unchecked")
|
public Result deleteExerciseItems(String[] exerciceIds, String[] reIds, String groupId) {
|
ExerciseGroup group = this.read(ExerciseGroup.class, groupId);
|
|
// 1.更新组练习数量值 总量减去本次删除个数
|
group.setAllCount(group.getAllCount().subtract(new BigInteger(String.valueOf(exerciceIds.length))));
|
TraceUtils.setUpdateTrace(group);
|
this.save(group);
|
|
// 2.删除练习组关联表数据
|
deleteExerciseGroupRe(reIds);
|
|
// 3.重新排序此组的字段
|
updateExerciseItemNewNo(groupId);
|
|
//清除缓存
|
redisTemplate.delete(groupId);
|
return new Result(true);
|
}
|
|
/**
|
* 重新排序
|
*
|
* @param groupId
|
* @return
|
*/
|
private Result updateExerciseItemNewNo(String groupId) {
|
// 升序排序
|
String hql = "from ExerciseGroupItemRe re " + "where re.exerciseGroupId=? " + "and re.deleteFlag is false " + "order by re.itemOrder asc ";
|
|
List<ExerciseGroupItemRe> lstRe = this.find(hql, CollectionUtils.newList(groupId), ExerciseGroupItemRe.class);
|
|
if (lstRe.isEmpty()) {
|
return null;
|
}
|
|
// 重新排序
|
for (int i = 0; i < lstRe.size(); i++) {
|
lstRe.get(i).setItemOrder(i + 1);
|
}
|
|
this.saveOrUpdateAll(lstRe);
|
|
return new Result(true);
|
}
|
|
/**
|
* 根据groupId 和 itemId 读取 ExerciseGroupItemRe
|
*
|
* @param groupId
|
* @param itemId
|
* @return
|
*/
|
/*
|
* private ExerciseGroupItemRe readItemRe(String groupId,String itemId){
|
*
|
* String hql = "from ExerciseGroupItemRe where exerciseGroupId = ? and exerciseItemId = ? "; ExerciseGroupItemRe itemRe = this.findUnique(hql, CollectionUtils.newList( groupId,itemId), ExerciseGroupItemRe.class);
|
*
|
* return itemRe; }
|
*/
|
|
/**
|
* 查询最近的记录
|
*
|
* @param hql
|
* @param page
|
* @param args
|
* @return
|
*/
|
/*
|
* (non-Javadoc)
|
*
|
* @see com.iqtogether.qxueyou.exercise.service.IExerciseService#importItems(java.lang.String, java.lang.String)
|
*/
|
@Override
|
public Result doImportItems(String groupId, File file) {
|
|
List<ExerciseItem> items = null;
|
|
try {
|
items = parseFile(file);
|
} catch (Exception e) {
|
log.error(e, e);
|
return new Result(false, "读取文档失败");
|
}
|
|
insertItems(groupId, items);
|
|
// 4.20150618：配合前台app，所有修改同时修改group表最后修改时间
|
List<ExerciseGroup> result = initExerciseGroup(groupId);
|
updateGroupUpdateTimeByList(result);
|
FileUtils.deleteQuietly(file.getParentFile());
|
return new Result(true, "已导入" + items.size() + "道习题");
|
}
|
|
/**
|
* 插入习题
|
*
|
* @param items
|
*/
|
private void insertItems(String groupId, List<ExerciseItem> items) {
|
|
int i = 0;
|
|
// 获取一个习题需要跟新的关系条数
|
List<ExerciseGroup> result = initExerciseGroup(groupId);
|
|
ExerciseGroup group = this.read(ExerciseGroup.class, groupId);
|
|
// 得到当前组题目的最大题号
|
int maxGroupItemOrder = queryExerciseGroupItemNo(groupId);
|
|
/*String hql = " from ExerciseGroup where originExerciseId = ? and deleteFlag is false and groupId != ?";
|
List<ExerciseGroup> lstGroup = find(hql, CollectionUtils.newList(group.getOriginExerciseId(), groupId), ExerciseGroup.class);*/
|
|
for (ExerciseItem item : items) {
|
|
TraceUtils.setCreateTrace(item);
|
item.setDeleteFlag(false);
|
// 1. 习题
|
handlerExerciseItem(group, item);
|
save(item);
|
|
// 2. 保存习题组-习题关系(练习和非练习)
|
List<ExerciseGroupItemRe> groupRes = initExerciseGroupItemRe(result, item.getExerciseId(), item.getItemNo() == null ? i++ : item.getItemNo(), ++maxGroupItemOrder );
|
saveOrUpdateAll(groupRes);
|
|
if(StringUtils.isEmpty(group.getClassId())){
|
// 同步习题
|
String hql = " from ExerciseGroup where originExerciseId = ? and deleteFlag is false and groupId != ?";
|
List<ExerciseGroup> lstGroup = find(hql, CollectionUtils.newList(group.getOriginExerciseId(), groupId), ExerciseGroup.class);
|
List<ExerciseItem> lstItems = find("from ExerciseItem where exerciseId = ?", CollectionUtils.newList(item.getExerciseId()), ExerciseItem.class);
|
for (ExerciseGroup exerciseGroup : lstGroup) {
|
exerciseGroup.setAllCount(group.getAllCount());
|
TraceUtils.setUpdateTrace(exerciseGroup);
|
this.saveExerciseGroup(exerciseGroup);
|
try {
|
this.doCopyExerciseItem(exerciseGroup.getGroupId(), groupId, lstItems, 2);
|
} catch (IllegalAccessException | InstantiationException | InvocationTargetException
|
| NoSuchMethodException e) {
|
log.error("新增练习同步到班级错误", e);
|
}
|
}
|
}
|
// 3. 保存习题解析
|
if (item.getAnalisis() != null) {
|
saveAnalysis(item);
|
}
|
|
// 4. 保存习题选项
|
for (ExerciseItemOption option : item.getOptions()) {
|
TraceUtils.setCreateTrace(option);
|
option.setDeleteFlag(false);
|
option.setExerciseItemId(item.getExerciseId());
|
save(option);
|
}
|
}
|
|
}
|
|
/**
|
* 保存习题解析
|
*
|
* @param item
|
*/
|
private void saveAnalysis(ExerciseItem item) {
|
ExerciseItemAnalisi analysis = item.getAnalisis();
|
if(StringUtils.isEmpty(analysis.getExerciseAnalisisId())){
|
TraceUtils.setCreateTrace(analysis);
|
analysis.setDeleteFlag(false);
|
analysis.setExerciseItemId(item.getExerciseId());
|
save(analysis);
|
}else{
|
TraceUtils.setUpdateTrace(analysis);
|
this.save(analysis);
|
}
|
}
|
|
/**
|
* 解析word
|
*
|
* @param groupId
|
* 习题组id
|
* @param file
|
* word文件绝对路径
|
* @return
|
* @throws RuntimeException
|
*/
|
private List<ExerciseItem> parseFile(File file) throws Exception {
|
|
Handler handler = new Handler();
|
|
// from office to txt,docx:自带序号无法解析出来,doc可以
|
|
String txtFilePath = transformDocToTxt(file);
|
|
FileReader reader = null;
|
BufferedReader br = null;
|
try {
|
reader = new FileReader(txtFilePath);
|
br = new BufferedReader(reader);
|
|
String currLine = "";
|
while ((currLine = br.readLine()) != null) {
|
handler.parse(currLine);
|
}
|
} catch (Exception e) {
|
throw new Exception("读取文档失败", e);
|
} finally {
|
IOUtils.closeQuietly(br);
|
IOUtils.closeQuietly(reader);
|
}
|
|
Doc doc = handler.result();
|
return doc.convertExerciseItems();
|
}
|
|
/**
|
* 从office转换到txt：2007转换：自带序号格式会丢失；2003会解析出来
|
*
|
* @param file
|
* office文档
|
* @return
|
*/
|
private String transformDocToTxt(File file) {
|
FileInputStream fis = null;
|
FileWriter writer = null;
|
String strText = "";
|
|
try {
|
String fileExtention = fileExtension(file.getName());
|
fis = new FileInputStream(file.getAbsolutePath());
|
|
if ("doc".equals(fileExtention)) {
|
WordExtractor extractor = new WordExtractor(fis);
|
// 获取Word文件中的文本+自带序号
|
strText = extractor.getText();
|
extractor.close();
|
} else if ("docx".equals(fileExtention)) {
|
OPCPackage opcPackage = POIXMLDocument.openPackage(file.getAbsolutePath());
|
POIXMLTextExtractor extractor = new XWPFWordExtractor(opcPackage);
|
// 只能获取Word文件中的文本，不能取到office序号
|
strText = extractor.getText();
|
extractor.close();
|
} else {
|
throw new RuntimeException("文件格式错误, 请上传word文档（.doc及.docx）格式", null);
|
}
|
|
// 将得到的文本全角转半角
|
strText = formatFullToHalf(strText);
|
|
// 解决空格保存为txt的时候，乱码为？
|
byte bytes[] = { (byte) 0xC2, (byte) 0xA0 };
|
String UTFSpace = new String(bytes, "UTF-8");
|
strText = strText.replaceAll(UTFSpace, " ");
|
|
File txtFile = new File(file.getParentFile().getAbsolutePath() + "/" + file.getName().substring(0, file.getName().lastIndexOf(".")) + ".txt");
|
writer = new FileWriter(txtFile, true);
|
writer.write(strText);
|
|
return txtFile.getAbsolutePath();
|
|
} catch (FileNotFoundException e) {
|
throw new RuntimeException("office文档未找到", e);
|
} catch (IOException e) {
|
throw new RuntimeException("office文档读取失败", e);
|
} catch (Exception e) {
|
throw new RuntimeException(e.getMessage(), e);
|
} finally {
|
IOUtils.closeQuietly(writer);
|
IOUtils.closeQuietly(fis);
|
}
|
}
|
|
/**
|
* 全角转半角
|
*
|
* @param oriText
|
* @return
|
*/
|
private String formatFullToHalf(String oriText) {
|
if (null == oriText || oriText.length() <= 0) {
|
return "";
|
}
|
|
char[] charArray = oriText.toCharArray();
|
// 对全角字符转换的char数组遍历
|
for (int i = 0; i < charArray.length; ++i) {
|
int charIntValue = (int) charArray[i];
|
|
// 如果符合转换关系,将对应下标之间减掉偏移量65248;如果是空格的话,直接做转换
|
if (charIntValue >= 65281 && charIntValue <= 65374) {
|
charArray[i] = (char) (charIntValue - 65248);
|
} else if (charIntValue == 12288) {
|
charArray[i] = (char) 32;
|
} else if (charIntValue == 58033) {
|
// 空格
|
charArray[i] = (char) 32;
|
} else if (charIntValue == 65380) {
|
// 顿号
|
charArray[i] = (char) 12289;
|
} else if (charIntValue == 65377) {
|
// 句号
|
charArray[i] = (char) 12290;
|
}
|
}
|
return new String(charArray);
|
|
}
|
|
/**
|
* 解析文件后缀
|
*
|
* @param filename
|
* @return
|
*/
|
private String fileExtension(String filename) {
|
|
return filename.substring(filename.lastIndexOf('.') + 1, filename.length());
|
}
|
|
/*
|
* (non-Javadoc)
|
*
|
* @see com.iqtogether.qxueyou.exercise.service.IExerciseService#updateExerciseItem(com.iqtogether.qxueyou.exercise.model.ExerciseItem, java.util.List)
|
*/
|
@Override
|
public Result updateExerciseItem(ExerciseItem item, List<ExerciseItemOption> lstOptions, String analysis) {
|
//先删除所有的option，然后恢复已有的option
|
this.bulkUpdate("update ExerciseItemOption set deleteFlag = true where exerciseItemId=?", new String[]{item.getExerciseId()});
|
// 保存Option
|
String answer = "";
|
if(lstOptions!=null){
|
for (ExerciseItemOption option : lstOptions) {
|
if(option.getChecked()){
|
if(item.getType()==ExerciseItem.TYPE_TRUE_OR_FALSE){
|
answer = answer.concat(option.getContent()).concat(",");
|
}else{
|
answer = answer.concat(option.getOptionOrder()).concat(",");
|
}
|
}
|
option.setExerciseItemId(item.getExerciseId());
|
|
if(StringUtils.isNotEmpty(option.getOptionId())){
|
option.setDeleteFlag(false);
|
TraceUtils.setCreateTrace(option);
|
}else{
|
TraceUtils.setCreateTrace(option);
|
}
|
save(option);
|
}
|
}
|
|
|
// 保存item
|
if(StringUtils.isNotBlank(answer)){
|
item.setAnswer(answer.substring(0,answer.length()-1));
|
}
|
TraceUtils.setCreateTrace(item);
|
save(item);
|
|
// 保存解析
|
updateItemAnalysis(item, analysis);
|
|
// 配合前台app，所有修改同时修改group表最后修改时间
|
// updateGroupUpdateTimeByList(initUpdateExerciseGroup(item.getExerciseId()));
|
|
//保存题目分数
|
List<ExerciseItemScore> lstExerciseItemScore = item.getScores();
|
if(lstExerciseItemScore!=null && lstExerciseItemScore.size()>0){
|
for (ExerciseItemScore score : lstExerciseItemScore) {
|
TraceUtils.setCreateTrace(score);
|
score.setGroupId(item.getExerciseGroupId());
|
save(score);
|
}
|
}
|
return new Result(true, item.getExerciseId());
|
}
|
|
/*
|
* 评价模块修改题目
|
*/
|
@Override
|
public ResultJson updateExerciseItem4Evaluate(ExerciseItem item,
|
List<ExerciseItemOption> lstOptions, String analysis) {
|
|
TraceUtils.setUpdateTrace(item);
|
|
|
/* // 先移除全部习题
|
QExerciseItemOption qOption = QExerciseItemOption.exerciseItemOption;
|
this.getQueryFactory()
|
.update(qOption)
|
.set(qOption.deleteFlag, true)
|
.where(qOption.exerciseItemId.eq(item.getExerciseId()))
|
.execute();
|
|
// 移除全部分数
|
QExerciseItemScore qScore = QExerciseItemScore.exerciseItemScore;
|
this.getQueryFactory()
|
.update(qScore)
|
.set(qScore.deleteFlag, true)
|
.where(qScore.exerciseItemId.eq(item.getExerciseId()))
|
.execute();*/
|
|
// 先移除全部习题
|
String hql = "update ExerciseItemOption set DELETE_FLAG = 1 where EXERCISE_ITEM_ID = ?";
|
super.bulkUpdateInLoop(hql, new String[] { item.getExerciseId() });
|
// 移除全部分数
|
String hql2 = "update ExerciseItemScore set DELETE_FLAG = 1 where EXERCISE_ITEM_ID = ?";
|
super.bulkUpdateInLoop(hql2, new String[] { item.getExerciseId() });
|
|
// 1.保存item
|
this.save(item);
|
if(lstOptions != null && lstOptions.size() > 0) {
|
TraceUtils.setCreateTrace(lstOptions);
|
for (int i = 0; i < lstOptions.size(); i++) {
|
ExerciseItemOption option = lstOptions.get(i);
|
option.setExerciseItemId(item.getExerciseId());
|
if (StringUtils.isNotBlank(option.getOptionId()) && option.getOptionId().startsWith("#")) {
|
option.setOptionId(null);
|
}
|
option.setOptionOrder(letter[i]);
|
save(option);
|
|
ExerciseItemScore objExerciseItemScore = new ExerciseItemScore();
|
TraceUtils.setCreateTrace(objExerciseItemScore);
|
objExerciseItemScore.setAttribute1(option.getOptionId());
|
objExerciseItemScore.setExerciseItemId(item.getExerciseId());
|
objExerciseItemScore.setExerciseItemAnswer(letter[i]);
|
objExerciseItemScore.setScore(String.valueOf(option.getScore()));
|
objExerciseItemScore.setExerciseItemScoreId(option.getExerciseItemScoreId());
|
save(objExerciseItemScore);
|
}
|
}
|
|
// 4. 更新习题解析
|
QExerciseItemAnalisi analysisVO = QExerciseItemAnalisi.exerciseItemAnalisi;
|
this.getQueryFactory()
|
.update(analysisVO)
|
.set(analysisVO.analysis, analysis)
|
.set(analysisVO.updateTime, new Date(System.currentTimeMillis()))
|
.where(analysisVO.exerciseItemId.eq(item.getExerciseId()))
|
.execute();
|
|
return new ResultJson(true);
|
}
|
|
/**
|
* 更新解析
|
*
|
* @param item
|
* @param analysis
|
*/
|
private void updateItemAnalysis(ExerciseItem item, String analysis) {
|
if (item.getAnalisis() == null) {
|
ExerciseItemAnalisi analysisVO = new ExerciseItemAnalisi();
|
|
TraceUtils.setCreateTrace(analysisVO);
|
analysisVO.setDeleteFlag(false);
|
|
analysisVO.setAnalysis(analysis);
|
analysisVO.setAccuracy(BigDecimal.ZERO);
|
analysisVO.setSubmitCorrectNumber(BigInteger.ZERO);
|
analysisVO.setSubmitNumber(BigInteger.ZERO);
|
|
item.setAnalisis(analysisVO);
|
|
saveAnalysis(item);
|
} else {
|
ExerciseItemAnalisi analysisVO = item.getAnalisis();
|
TraceUtils.setCreateTrace(analysisVO);
|
analysisVO.setAnalysis(analysis);
|
|
save(analysisVO);
|
}
|
}
|
|
/**
|
* 组装ExerciseGroup的list,传入一个groupid，得到同时需要修改的一个或者多个group对象
|
*
|
* @param groupId
|
* 主键
|
* @return
|
*/
|
@Override
|
public List<ExerciseGroup> initExerciseGroup(String groupId) {
|
// 0.获取groupID对应的type，如果是习题（顺机序、随和章节，需要按不同情况同时更新）
|
// 1.如果是章节练习，需要同步修改顺序随机练习
|
// 2.如果是顺序，需同步修改随机；如果是随机练习亦然
|
ExerciseGroup group = read(ExerciseGroup.class, groupId);
|
List<ExerciseGroup> result = new ArrayList<ExerciseGroup>();
|
short sType = 0;
|
if (group != null) {
|
sType = group.getType();
|
String hsql = "";
|
if (sType == ExerciseGroup.TYPE_CHAPTER_ITEM || sType == ExerciseGroup.TYPE_EXERCISE_RANDOM || sType == ExerciseGroup.TYPE_EXERCISE_SEQUENCE) {
|
hsql = "from ExerciseGroup where classId = ? and (type = ? or type = ?) and deleteFlag is false ";
|
result = find(hsql, CollectionUtils.newList(ClientUtils.getClassId(), ExerciseGroup.TYPE_EXERCISE_SEQUENCE, ExerciseGroup.TYPE_EXERCISE_RANDOM), ExerciseGroup.class);
|
}
|
if (sType != ExerciseGroup.TYPE_EXERCISE_SEQUENCE && sType != ExerciseGroup.TYPE_EXERCISE_RANDOM) {
|
result.add(group);
|
}
|
}
|
return result;
|
}
|
|
/**
|
* 组装ExerciseGroup的list,传入一个groupid，得到同时需要修改的一个或者多个group对象
|
*
|
* @param groupId
|
* 主键
|
* @return
|
*/
|
public List<ExerciseGroup> initUpdateExerciseGroup(String exerciseId) {
|
// 修改关联的exerciseId，deleteflag is false（暂时全部处理）
|
List<ExerciseGroup> lstGroup = new ArrayList<ExerciseGroup>();
|
|
String hql = "select e.exerciseGroupId from ExerciseGroupItemRe e where deleteFlag is false and e.exerciseItemId = ? ";
|
List<Object> groupId = find(hql, CollectionUtils.newList(exerciseId), Object.class);
|
|
if (null != groupId && !groupId.isEmpty()) {
|
String hql0 = " from ExerciseGroup e where e.deleteFlag is false and e.groupId in ( ";
|
for (int i = 0; i < groupId.size(); i++) {
|
if (i == groupId.size() - 1) {
|
hql0 = hql0.concat(" ? ) ");
|
} else {
|
hql0 = hql0.concat(" ?, ");
|
}
|
}
|
lstGroup = find(hql0, groupId, ExerciseGroup.class);
|
}
|
|
return lstGroup;
|
}
|
|
/**
|
* 批量删除ExerciseGroup，删除逻辑：如果是练习，顺序和随机练习时同步删除的(此处代码)
|
*
|
* @param groupId
|
* 主键，多个id时以","分隔
|
* @return
|
*/
|
public Result deleteExerciseGroup(String groupId) {
|
|
// 逻辑删除，只需要修改exercise_group、exercise_item的删除标识即可
|
if (StringUtils.isNotBlank(groupId)) {
|
// 需要删除的练习组
|
Object[] arrGroupId = groupId.split(",");
|
// 存储顺序练习或者随机练习
|
List<ExerciseGroup> lstResults = initDeleteExerciseGroup(arrGroupId);
|
|
// 需要删除的练习类型下的练习题
|
//List<ExerciseItem> lstItem = initDeleteExerciseItem(lstResults);
|
|
// 删除习题组,修改习题组最后修改时间
|
if (lstResults != null) {
|
for (ExerciseGroup group : lstResults) {
|
group.setDeleteFlag(true);
|
|
TraceUtils.setUpdateTrace(group);
|
this.saveExerciseGroup(group);
|
// group.setUpdateTime(new Date(System.currentTimeMillis()));
|
}
|
}
|
|
/*// 删除习题
|
if (lstItem != null) {
|
for (ExerciseItem item : lstItem) {
|
item.setDeleteFlag(true);
|
}
|
saveOrUpdateAll(lstItem);
|
}*/
|
// 20150618：配合前台app，所有修改同时修改group表最后修改时间
|
//updateGroupUpdateTimeByList(lstResults);
|
}
|
return new Result(true);
|
}
|
|
/**
|
* 组装练习组
|
*
|
* @param name
|
* 练习名称
|
* @param type
|
* 练习组类型
|
* @param lessonId
|
* 课程
|
* @param chapterId
|
* 章节
|
* @return
|
*/
|
private List<ExerciseGroup> initExerciseGroupList(String name, short type, String lessonId, String chapterId, int iCount) {
|
List<ExerciseGroup> lstExerciseGroup = new ArrayList<ExerciseGroup>();
|
List<Short> lstType = new ArrayList<Short>();
|
|
// iCount:0、 新增三种(选择了章节)，增加两种：没有选择章节；1，新增两种（顺序随机），2，新增一种（章节），3的话，不增加
|
if (type == ExerciseGroup.TYPE_EXERCISE_SEQUENCE) {
|
if (iCount == 0) {
|
lstType.add(type);
|
lstType.add(ExerciseGroup.TYPE_EXERCISE_RANDOM);
|
if (StringUtils.isNotBlank(lessonId) && StringUtils.isNotBlank(chapterId)) {
|
lstType.add(ExerciseGroup.TYPE_CHAPTER_ITEM);
|
}
|
} else if (iCount == 1) {
|
lstType.add(type);
|
lstType.add(ExerciseGroup.TYPE_EXERCISE_RANDOM);
|
} else if (iCount == 2) {
|
lstType.add(ExerciseGroup.TYPE_CHAPTER_ITEM);
|
} else if (iCount == 3 && StringUtils.isNotBlank(chapterId)) {// 等于3，章节练习，顺序练习，随机练习都有，增加章节练习
|
lstType.add(ExerciseGroup.TYPE_CHAPTER_ITEM);
|
}
|
} else {
|
lstType.add(type);
|
}
|
|
for (short iType : lstType) {
|
lstExerciseGroup.add(initExerciseGroup(name, iType, lessonId, chapterId));
|
}
|
return lstExerciseGroup;
|
}
|
|
/**
|
* 组装练习
|
*
|
* @param name
|
* 练习名称
|
* @param type
|
* 练习类型
|
* @param lessonId
|
* 课程
|
* @param chapterId
|
* 章节
|
* @return
|
*/
|
private ExerciseGroup initExerciseGroup(String name, short type, String lessonId, String chapterId) {
|
// 构建实体
|
ExerciseGroup objExerciseGroup = new ExerciseGroup();
|
|
TraceUtils.setCreateTrace(objExerciseGroup);
|
objExerciseGroup.setDeleteFlag(false);
|
objExerciseGroup.setAllCount(BigInteger.ZERO);
|
objExerciseGroup.setSubjectId(lessonId);
|
objExerciseGroup.setChapterId(chapterId);
|
if (ExerciseGroup.TYPE_EXERCISE_RANDOM == type) {
|
objExerciseGroup.setName("随机练习");
|
} else if (ExerciseGroup.TYPE_EXERCISE_SEQUENCE == type) {
|
objExerciseGroup.setName("顺序练习");
|
} else {
|
objExerciseGroup.setName(name);
|
}
|
|
objExerciseGroup.setType(type);
|
objExerciseGroup.setClassId(ClientUtils.getClassId());
|
objExerciseGroup.setOrgId(ClientUtils.getOrgId());
|
objExerciseGroup.setCollegeCourseId(ClientUtils.getCourseId());
|
// 章节练习需要存储
|
if (type == ExerciseGroup.TYPE_CHAPTER_ITEM) {
|
// 章节练习存放lessonId
|
//objExerciseGroup.setAttribute1(lessonId);
|
// 章节练习存放chapterID
|
objExerciseGroup.setAttribute2(chapterId);
|
}
|
return objExerciseGroup;
|
}
|
|
/**
|
* 组装关联信息
|
*
|
* @param lstGroup
|
* 练习组
|
* @param itemId
|
* 练习题id
|
* @param itemOrder
|
* 练习题序号
|
* @return
|
*/
|
private List<ExerciseGroupItemRe> initExerciseGroupItemRe(List<ExerciseGroup> lstGroup, String itemId, int docOrder,int maxGroupItemOrder) {
|
|
List<ExerciseGroupItemRe> lstExerciseGroupItemRe = new ArrayList<ExerciseGroupItemRe>();
|
|
for (ExerciseGroup group : lstGroup) {
|
ExerciseGroupItemRe re = new ExerciseGroupItemRe();
|
re.setExerciseGroupId(group.getGroupId());
|
re.setExerciseItemId(itemId);
|
re.setItemOrder(maxGroupItemOrder);
|
re.setDeleteFlag(false);
|
if (docOrder > -1) {
|
re.setDocOrder(docOrder);
|
}
|
lstExerciseGroupItemRe.add(re);
|
}
|
return lstExerciseGroupItemRe;
|
}
|
|
/**
|
* 查询当前组的最大题号
|
*
|
* @param groupId
|
* @return
|
*/
|
private int queryExerciseGroupItemNo(String groupId) {
|
|
String hql = "select max(itemOrder) from ExerciseGroupItemRe t where deleteFlag is false and exerciseGroupId=?";
|
|
Integer itemOrder = this.findUnique(hql, CollectionUtils.newList(groupId), Integer.class);
|
|
if (itemOrder == null) {
|
return 0;
|
}
|
|
return itemOrder;
|
}
|
|
/**
|
* 组装需要删除的练习组
|
*
|
* @param lstResult
|
* 存储非顺序 练习非随机练习
|
* @param lstResults
|
* 存储顺序练习或者随机练习
|
* @param arrGroupId
|
* groupid的数组
|
*/
|
private List<ExerciseGroup> initDeleteExerciseGroup(Object[] arrGroupId) {
|
List<ExerciseGroup> lstResults = new ArrayList<ExerciseGroup>();
|
List<ExerciseGroup> lstResult = new ArrayList<ExerciseGroup>();
|
String hsql = " from ExerciseGroup where groupId in ( ";
|
for (int i = 0; i < arrGroupId.length - 1; i++) {
|
hsql = hsql.concat("? , ");
|
}
|
hsql = hsql.concat("? ) ");
|
List<ExerciseGroup> result = find(hsql, CollectionUtils.newList(arrGroupId), ExerciseGroup.class);
|
// 一个班级只有一个顺序练习和一个随机练习
|
int iNumber = 0;
|
for (ExerciseGroup group : result) {
|
if (group.getType() == ExerciseGroup.TYPE_EXERCISE_SEQUENCE || group.getType() == ExerciseGroup.TYPE_EXERCISE_RANDOM) {
|
iNumber++;
|
lstResults.add(group);
|
} else {
|
lstResult.add(group);
|
}
|
}
|
// 一个班级只选择了顺序或者只选择了随机，两个类型都需要删除
|
if (iNumber == 1) {
|
hsql = "from ExerciseGroup where type in (?,?) and classId = ? and deleteFlag is false ";
|
lstResults = find(hsql, CollectionUtils.newList(ExerciseGroup.TYPE_EXERCISE_SEQUENCE, ExerciseGroup.TYPE_EXERCISE_RANDOM, lstResults.get(0).getClassId()), ExerciseGroup.class);
|
}
|
lstResults.addAll(lstResult);
|
|
return lstResults;
|
}
|
|
/**
|
* 获取需要删除的练习题(删除习题组时调用)
|
*
|
* @param lstResults
|
* 需要删除的练习组
|
*//*
|
private List<ExerciseItem> initDeleteExerciseItem(List<ExerciseGroup> lstResults) {
|
String hsql = "from ExerciseItem where exerciseId in ( select exerciseItemId from ExerciseGroupItemRe " + " where deleteFlag is false and exerciseGroupId in ( ";
|
List<Object> arrGroupId = new ArrayList<Object>();
|
for (int i = 0; i < lstResults.size(); i++) {
|
if (i != lstResults.size() - 1) {
|
hsql = hsql.concat("? , ");
|
}
|
arrGroupId.add(lstResults.get(i).getGroupId());
|
}
|
|
// 需要删除的练习题（为练习类型时）
|
hsql = hsql.concat("? ) group by exerciseItemId having count(1) = 3 )");
|
|
// 这个SQL特别慢
|
List<ExerciseItem> lstItem = find(hsql, arrGroupId, ExerciseItem.class);
|
List<ExerciseItem> lstItems = new ArrayList<ExerciseItem>();
|
|
// 剔除顺序，随机、章节练习
|
List<Object> lstParams = new ArrayList<Object>();
|
for (ExerciseGroup group : lstResults) {
|
if (group.getType() != ExerciseGroup.TYPE_EXERCISE_SEQUENCE && group.getType() != ExerciseGroup.TYPE_CHAPTER_ITEM && group.getType() != ExerciseGroup.TYPE_EXERCISE_RANDOM) {
|
lstParams.add(group.getGroupId());
|
}
|
}
|
if (!lstParams.isEmpty()) {
|
hsql = "from ExerciseItem where exerciseId in ( select exerciseItemId from ExerciseGroupItemRe where deleteFlag is false and exerciseGroupId in ( ";
|
for (int i = 0; i < lstParams.size() - 1; i++) {
|
hsql = hsql.concat("? , ");
|
}
|
hsql =hsql.concat( "? ) )");
|
lstItems = find(hsql, lstParams, ExerciseItem.class);
|
}
|
// 需要删除的习题
|
if (lstItem != null) {
|
lstItem.addAll(lstItems);
|
}
|
return lstItem;
|
}*/
|
|
/**
|
* ：后台 插入评估模板时调用
|
*
|
* @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());
|
save(obj);
|
|
// 保存
|
return obj;
|
}
|
|
/**
|
* 查询练习列表，还需查询联系下面习题个数
|
*
|
* @param hql
|
* @param args
|
* @return
|
*/
|
public List<ExerciseGroup> queryExerciceGroupList(String hql, List<Object> args) {
|
return exerDAO.queryExerciceGroupList(hql, args);
|
}
|
|
/**
|
* 所有练习修改操作需要同时修改group的updateTime
|
*
|
* @param lstGroup
|
*/
|
private void updateGroupUpdateTimeByList(List<ExerciseGroup> lstGroup) {
|
if (null != lstGroup && !lstGroup.isEmpty()) {
|
for (ExerciseGroup obj : lstGroup) {
|
int iExerciseCount = this.findCount("select count(1) from ExerciseGroupItemRe where deleteFlag is false and exerciseGroupId = ?",
|
CollectionUtils.newList(obj.getGroupId()));
|
obj.setAllCount(BigInteger.valueOf(iExerciseCount));
|
obj.setUpdateTime(new Date());
|
this.saveExerciseGroup(obj);
|
}
|
//saveOrUpdateAll(lstGroup);
|
}
|
}
|
|
/**
|
* 后台：批量删除ExerciseGroup
|
*
|
* @param groupId
|
* 主键，多个id时以","分隔
|
* @param type
|
* 多个type时以","分隔
|
* @return
|
*/
|
public Result deleteExerciseGroup(String groupId, String type, String deleteType,Integer delAll, String orgIds[], String classIds[]) {
|
if (StringUtils.isBlank(groupId) || StringUtils.isBlank(type)) {
|
return new Result(true);
|
}
|
String[] groupIds = groupId.split(",");
|
String[] types = type.split(",");
|
if (groupIds.length != types.length) {
|
return new Result(false);
|
}
|
if ("org".equals(deleteType)) {
|
//管理员删除练习
|
deleteOrgGroup(groupIds,delAll,orgIds,classIds);
|
return new Result(true);
|
}
|
// 删除逻辑：练习和其他分开处理(SQL执行简单)
|
// 删除练习：随机和顺序是一致的；如果只删除随机或者顺序，只删除章节，则只删除习题组；如果只删除章节：同样只删除组
|
// 删除时：顺序或者随机+章节：删除组+章节对应的习题
|
boolean randomFlag = false;
|
boolean chapterFlag = false;
|
|
if (type.indexOf(String.valueOf(ExerciseGroup.TYPE_EXERCISE_RANDOM)) != -1
|
|| type.indexOf(String.valueOf(ExerciseGroup.TYPE_EXERCISE_SEQUENCE)) != -1) {
|
randomFlag = true;
|
}
|
if (type.indexOf(String.valueOf(ExerciseGroup.TYPE_CHAPTER_ITEM)) != -1) {
|
chapterFlag = true;
|
}
|
|
// 拆除子方法
|
Result result = deleteChildExerciseGroup(groupIds, types, randomFlag, chapterFlag);
|
|
if(!result.isSuccess()){
|
return result;
|
}
|
|
return new Result(true);
|
|
}
|
|
/**
|
* 拆除子方法
|
* @param groupIds
|
* @param types
|
* @param randomFlag
|
* @param chapterFlag
|
* @return
|
*/
|
private Result deleteChildExerciseGroup(String[] groupIds, String[] types,
|
boolean randomFlag, boolean chapterFlag) {
|
// 1. 无练习
|
if (!randomFlag && !chapterFlag) {
|
return deleteExercise(groupIds, groupIds);
|
}
|
// 2. 有随机有章节
|
if (randomFlag && chapterFlag) {
|
return deleteExerciseAll(groupIds);
|
}
|
// 3.1. 随机、章节只有一种,删除组:第一种情况：保证顺序随机一致；第二种：删除章节
|
if (randomFlag) {
|
return deleteExerciseSequence(groupIds, types);
|
}
|
return deleteExerciseChapter(groupIds, types);
|
}
|
|
private void deleteOrgGroup(String groupIds[],Integer delAll, String orgIds[], String classIds[]){
|
for (String string : groupIds) {
|
if ((orgIds != null && orgIds.length != 0) || (classIds != null && classIds.length != 0)) {
|
//删除要回撤的练习
|
deleteAppoint(string,orgIds,classIds);
|
}else{
|
String hql = " from ExerciseReCourse where groupId = ? and deleteFlag is false and orgId = ?";
|
ExerciseReCourse erc = findUnique(hql, CollectionUtils.newList(string, ClientUtils.getOrgId()), ExerciseReCourse.class);
|
if (erc != null) {
|
erc.setDeleteFlag(true);
|
TraceUtils.setUpdateTrace(erc);
|
save(erc);
|
|
this.courseWareService.deleteOrgCourseware(erc.getGroupId(), erc.getOrgId());
|
}
|
/*ExerciseGroup group = this.read(ExerciseGroup.class, string);
|
if(group != null){
|
TraceUtils.setUpdateTrace(group);
|
group.setDeleteFlag(true);
|
this.saveExerciseGroup(group);
|
}*/
|
if(delAll==1){
|
//删除下级
|
deleteSub(string,ClientUtils.getOrgId());
|
}
|
}
|
|
}
|
}
|
|
|
@SuppressWarnings("unchecked")
|
private void deleteSub(String groupId,String currOrgId){
|
// 机构层级视频是没有重新new ，查询出机构下级ID再删关联表
|
String sql = " select oa.organization_id from organization as oa,organization ob " +
|
" where " +
|
" ob.ORGANIZATION_ID = ? " +
|
" and " +
|
" oa.org_code like CONCAT(ob.org_code,'%' ) " +
|
" and oa.delete_flag is false and ob.delete_flag is false "+
|
" order by oa.level,oa.org_code asc " ;
|
|
List<String> orgIds = this.findBySql(sql, CollectionUtils.newList(currOrgId));
|
|
String hql = " from ExerciseReCourse where groupId = :groupId and deleteFlag is false and orgId in (:orgIds)";
|
Map<String,Object> map = new HashMap<String, Object>();
|
map.put("groupId", groupId);
|
map.put("orgIds", orgIds.toArray());
|
List<ExerciseReCourse> groupCourses = findByComplexHql(hql, map, ExerciseReCourse.class);
|
for (ExerciseReCourse groupCourse : groupCourses) {
|
groupCourse.setDeleteFlag(true);
|
TraceUtils.setUpdateTrace(groupCourse);
|
this.save(groupCourse);
|
}
|
|
// 班主任层面视频指定过后都是new 出来的，通过originVideoId 可以查出所有指定过去的视频
|
hql = "select classId from ClsClass where orgId in (:orgIds) and deleteFlag is false";
|
map = new HashMap<String, Object>();
|
map.put("orgIds", orgIds.toArray());
|
List<String> clsIds = findByComplexHql(hql, map, String.class);
|
if(!clsIds.isEmpty()){
|
hql = " from ExerciseGroup where originExerciseId = :groupId and deleteFlag is false and groupId!=originExerciseId and classId in (:classIds)";
|
map = new HashMap<String, Object>();
|
map.put("groupId", groupId);
|
map.put("classIds", clsIds.toArray());
|
List<ExerciseGroup> lstExerciseGroup = findByComplexHql(hql, map, ExerciseGroup.class);
|
for (ExerciseGroup group : lstExerciseGroup) {
|
group.setDeleteFlag(true);
|
TraceUtils.setUpdateTrace(group);
|
this.saveExerciseGroup(group);
|
}
|
}
|
}
|
|
private Result deleteAppoint(String groupId,String orgIds[],String classIds[]){
|
Map<String, Object> args = new HashMap<String, Object>();
|
// 删除需要回撤的机构视频
|
if (orgIds.length != 0) {
|
|
String hql = " from ExerciseReCourse where groupId = :groupId and deleteFlag is false and orgId in (:orgIds) and orgId != :currOrgId";
|
args = new HashMap<String, Object>();
|
args.put("groupId", groupId);
|
args.put("orgIds", orgIds);
|
args.put("currOrgId", ClientUtils.getOrgId());
|
List<ExerciseReCourse> courses = findByComplexHql(hql, args, ExerciseReCourse.class);
|
for (ExerciseReCourse exercise : courses) {
|
TraceUtils.setUpdateTrace(exercise);
|
exercise.setDeleteFlag(true);
|
save(exercise);
|
|
this.courseWareService.deleteOrgCourseware(exercise.getGroupId(), exercise.getOrgId());
|
}
|
}
|
|
// 删除需要回撤的班主任视频
|
if (classIds.length != 0) {
|
args = new HashMap<String, Object>();
|
args.put("groupId", groupId);
|
args.put("classIds", classIds);
|
String hql = " from ExerciseGroup where originExerciseId = :groupId and deleteFlag is false and classId in (:classIds)";
|
List<ExerciseGroup> groups = findByComplexHql(hql, args, ExerciseGroup.class);
|
for (ExerciseGroup group : groups) {
|
TraceUtils.setUpdateTrace(group);
|
group.setDeleteFlag(true);
|
this.saveExerciseGroup(group);
|
}
|
|
}
|
|
return new Result(true);
|
}
|
|
/**
|
* 有顺序和章节练习时的删除逻辑
|
*
|
* @param groupIds
|
* @param types
|
* @return
|
*/
|
private Result deleteExerciseAll(String[] groupIds) {
|
String hql = "select groupId from ExerciseGroup where deleteFlag is false and classId = ? and type in (?,?) ";
|
List<String> exeGroupId = find(hql, CollectionUtils.newList(ClientUtils.getClassId(), ExerciseGroup.TYPE_EXERCISE_RANDOM, ExerciseGroup.TYPE_EXERCISE_SEQUENCE), String.class);
|
// 组
|
exeGroupId.addAll(Arrays.asList(groupIds));
|
|
return deleteExercise((String[]) exeGroupId.toArray(new String[exeGroupId.size()]), groupIds);
|
}
|
|
/**
|
* 只有順序或者随机时删除逻辑
|
*
|
* @param groupIds
|
* @param types
|
* @return
|
*/
|
private Result deleteExerciseSequence(String[] groupIds, String[] types) {
|
String hql = "select groupId from ExerciseGroup where deleteFlag is false and classId = ? and type in (?,?) ";
|
List<String> exeGroupId = find(hql, CollectionUtils.newList(ClientUtils.getClassId(), ExerciseGroup.TYPE_EXERCISE_RANDOM, ExerciseGroup.TYPE_EXERCISE_SEQUENCE), String.class);
|
// 1.组
|
exeGroupId.addAll(Arrays.asList(groupIds));
|
|
// 2.删除题,不处理练习
|
for (int i = 0; i < types.length; i++) {
|
if (types[i] == String.valueOf(ExerciseGroup.TYPE_EXERCISE_RANDOM) || types[i] == String.valueOf(ExerciseGroup.TYPE_EXERCISE_SEQUENCE)) {
|
groupIds[i] = "";
|
}
|
}
|
return deleteExercise((String[]) exeGroupId.toArray(new String[exeGroupId.size()]), groupIds);
|
}
|
|
/**
|
* 只有章节练习是的删除逻辑
|
*
|
* @param groupIds
|
* @param types
|
* @return
|
*/
|
private Result deleteExerciseChapter(String[] groupIds, String[] types) {
|
// 1.组 groupIds
|
// 2.删除题,不处理练习
|
String[] groupItemIds = new String[groupIds.length];
|
for (int i = 0; i < types.length; i++) {
|
if (types[i] == String.valueOf(ExerciseGroup.TYPE_CHAPTER_ITEM)) {
|
groupItemIds[i] = "";
|
} else {
|
groupItemIds[i] = groupIds[i];
|
}
|
}
|
return deleteExercise(groupIds, groupItemIds);
|
}
|
|
/**
|
* 后台：执行删除习题组操作
|
*
|
* @param groupIds
|
* 删除组的组id
|
* @param groupItemIds
|
* 需要删除题的组id
|
* @return
|
*/
|
private Result deleteExercise(String[] groupIds, String[] groupItemIds) {
|
// 1.删除组
|
bulkUpdateInLoop("update ExerciseGroup set deleteFlag = true where groupId = ? ", groupIds);
|
// 1.删除课件
|
bulkUpdateInLoop("update SchCourseware set deleteFlag = true where id = ? ", groupIds);
|
|
// 2.删除题
|
bulkUpdateInLoop("update ExerciseGroupItemRe set deleteFlag = true "
|
+ " where exerciseGroupId = ? and deleteFlag = false ", groupItemIds);
|
|
return new Result(true);
|
}
|
|
/**
|
* 发送练习系统通知
|
*
|
* @param notice
|
* @return
|
*
|
* private Result sendSysMsg(ExerciseGroup group){
|
*
|
* ONSMsg msg = new ONSMsg(onsProducer.getTopic());
|
*
|
* msg.put("msgType", "SYS_EXER_SAVE"); msg.put("groupId", group.getGroupId()); msg.put("classId", ClientUtils.getClassId());
|
*
|
* try {
|
*
|
* onsProducer.sendMsg(msg);
|
*
|
* return new Result(true);
|
*
|
* } catch (Exception e) { log.error("call DocdealMsgSendService fail.userId: " + group.getGroupId(), e); }
|
*
|
* return new Result(false); }
|
*/
|
|
/**
|
* 添加练习图片
|
*
|
* @param imgPath
|
* @param imgObjId
|
* @param imgObjType
|
* @return
|
*/
|
public List<Map<String, Object>> doAddExerciseObjImg(String[] imgPath, String imgObjId, int imgObjType) {
|
|
String hql = "from ExerciseObjectImg where deleteFlag is false and exerciseObjectId=? and objectType=? order by imgOrder desc";
|
// 查询此练习是否已经存在记录
|
List<ExerciseObjectImg> lstObjImg = this.find(hql, CollectionUtils.newList(imgObjId, imgObjType), ExerciseObjectImg.class);
|
|
int imgOrder = 1;
|
if (!lstObjImg.isEmpty()) {
|
imgOrder = lstObjImg.get(0).getImgOrder() + 1;
|
}
|
|
List<ExerciseObjectImg> lstImg = new ArrayList<ExerciseObjectImg>(imgPath.length);
|
ExerciseObjectImg img = new ExerciseObjectImg();
|
img.setObjectType(imgObjType);
|
img.setImgPath(imgPath[0]);
|
img.setExerciseObjectId(imgObjId);
|
img.setImgOrder(imgOrder);
|
img.setDeleteFlag(false);
|
TraceUtils.setCreateTrace(img);
|
lstImg.add(img);
|
|
for (int i = 1; i < imgPath.length; i++) {
|
img.setImgPath(imgPath[i]);
|
img.setImgOrder(imgOrder++);
|
lstImg.add(img);
|
}
|
|
this.saveOrUpdateAll(lstImg);
|
|
List<Map<String, Object>> lstResult = new ArrayList<Map<String, Object>>(lstImg.size());
|
Map<String, Object> resultMap = null;
|
for (ExerciseObjectImg obj : lstImg) {
|
resultMap = new HashMap<String, Object>(2);
|
resultMap.put("imgId", obj.getImgId());
|
resultMap.put("imgPath", obj.getImgPath());
|
lstResult.add(resultMap);
|
}
|
return lstResult;
|
}
|
|
/**
|
* 删除图片
|
*/
|
public Result dodelExerciseObjImg(String imgId) {
|
|
ExerciseObjectImg img = this.read(ExerciseObjectImg.class, imgId);
|
img.setDeleteFlag(true);
|
TraceUtils.setUpdateTrace(img);
|
this.save(img);
|
|
return new Result(true);
|
}
|
|
/**
|
* 导入习题：深度解析word文档
|
*
|
* @param groupId
|
* 习题组Id
|
* @param file
|
* @param uuid
|
* @return
|
*/
|
public Result doDeepAnalysisDoc(String groupId,String fullPath){
|
|
return insertDeepAnalysis(fullPath,groupId);
|
|
}
|
|
/**
|
* 新增深度解析记录
|
*
|
* @param destPath
|
* 文件路径
|
* @param groupId
|
* 习题组ID
|
* @return
|
*/
|
private Result insertDeepAnalysis(String destPath, String groupId) {
|
ExerciseDeepAnalysis objDeepAna = new ExerciseDeepAnalysis();
|
TraceUtils.setCreateTrace(objDeepAna);
|
objDeepAna.setDocPath(destPath);
|
|
objDeepAna.setUserId(ClientUtils.getUserId());
|
objDeepAna.setUserAccount(ClientUtils.getUserAccount());
|
objDeepAna.setOrgId(ClientUtils.getOrgId());
|
objDeepAna.setOrgName(ClientUtils.getOrgName());
|
objDeepAna.setClassId(ClientUtils.getClassId());
|
objDeepAna.setClassName(ClientUtils.getClassName());
|
|
String hql = " from OrgCharger o where o.deleteFlag is false and o.userId = ? ";
|
OrgCharger charger = this.findUnique(hql, CollectionUtils.newList(ClientUtils.getUserId()), OrgCharger.class);
|
|
objDeepAna.setChargerId(charger.getChargerId());
|
objDeepAna.setChargerName(charger.getName());
|
|
objDeepAna.setStatus(ExerciseDeepAnalysis.STATUS_TODO);
|
|
objDeepAna.setExerciseGroupId(groupId);
|
objDeepAna.setExerciseGroupName(this.read(ExerciseGroup.class, groupId).getName());
|
|
objDeepAna.setSubmitTime(new Date(System.currentTimeMillis()));
|
|
this.insert(objDeepAna);
|
|
return new Result(true);
|
}
|
|
/**
|
* 导入习题,将解析结果返回到前台
|
*
|
* @param groupId
|
* 习题组ID
|
* @param file
|
* @return
|
*/
|
public ExerciseParseResult doParseItems(String groupId, String fullPath , String module ) {
|
|
//取得当前上传文件类型
|
String filePart[] = fullPath.split("\\.");
|
String fileType = filePart[filePart.length -1];
|
String uuid = UUIDUtils.generateUUID();
|
String filePath = ExerciseService.class.getClassLoader().getResource("../uploads").getPath().concat("exercise/"+ uuid + "/" + uuid + "."+fileType);
|
File file = fileUploadService.doGetOssFile(fullPath, filePath, module,ClientUtils.getUserId());
|
|
ExerciseParseResult objResult = null ;
|
|
try {
|
objResult = parseWordFile(file);
|
} catch (Exception e) {
|
log.error(e, e);
|
if ("文件格式错误, 请上传word文档（.doc及.docx）格式".equals(e.getMessage())) {
|
return new ExerciseParseResult(false, e.getMessage());
|
}
|
return new ExerciseParseResult(false, "读取文档失败");
|
}
|
|
//更新上传文件使用轨迹
|
fileUploadService.updateUploadTrace(fullPath, module, SysFileUploadTrace.FILE_USE, groupId);
|
|
objResult.setItemCount(objResult.getLstItems().size());
|
objResult.setLstItems(null);
|
objResult.setParseFlag(true);
|
|
if( null != file ){
|
fileUploadService.doDeleteTempOssFile(file.getParentFile(), module, ClientUtils.getUserId());
|
}
|
|
return objResult;
|
}
|
|
/**
|
* 解析word
|
*
|
* @param groupId
|
* 习题组id
|
* @param file
|
* word文件绝对路径
|
* @return
|
* @throws RuntimeException
|
*/
|
private ExerciseParseResult parseWordFile(File file) throws Exception {
|
|
ExerciseParseResult parseResult = new ExerciseParseResult();
|
|
ArrayList<ExerciseImportResult> lstResult = new ArrayList<ExerciseImportResult>();
|
|
Handler handler = new Handler();
|
|
// from office to txt,docx:自带序号无法解析出来,doc可以
|
String txtFilePath = transformDocToTxt(file);
|
|
FileReader reader = null;
|
BufferedReader br = null;
|
try {
|
reader = new FileReader(txtFilePath);
|
br = new BufferedReader(reader);
|
|
String currLine = "";
|
ExerciseImportResult objResult;
|
while ((currLine = br.readLine()) != null) {
|
|
ExerciseParse objParser = handler.parse(currLine);
|
|
int iResultType = objParser.getParseResult();
|
|
objResult = new ExerciseImportResult();
|
objResult.setLineText(objParser.getParseLine());
|
objResult.setType(iResultType);
|
if (Handler.HANDLER_RESULT_CONTINUE == iResultType) {
|
objResult.setLastParse(objParser.getParseType());
|
}
|
lstResult.add(objResult);
|
|
}
|
} catch (Exception e) {
|
throw new Exception("读取文档失败", e);
|
} finally {
|
IOUtils.closeQuietly(br);
|
IOUtils.closeQuietly(reader);
|
}
|
|
Doc doc = handler.result();
|
|
parseResult.setLstItems(doc.convertExerciseItems());
|
parseResult.setLstResult(lstResult);
|
|
return parseResult;
|
}
|
|
/**
|
* 导入习题 校验习题，将解析结果返回到前台
|
*
|
* @param content
|
* 习题文本内容
|
* @return
|
*/
|
public ExerciseParseResult validateExercise(String content) {
|
|
ExerciseParseResult parseResult = parsePlainText(content);
|
parseResult.setLstItems(null);
|
|
return parseResult;
|
|
}
|
|
/**
|
* 导入习题：将传回的文本内容解析出来
|
*
|
* @param content
|
* 习题文本内容
|
* @return
|
*/
|
private ExerciseParseResult parsePlainText(String content) {
|
|
ExerciseParseResult parseResult = new ExerciseParseResult();
|
Handler handler = new Handler();
|
ArrayList<ExerciseImportResult> lstResult = new ArrayList<ExerciseImportResult>();
|
List<ExerciseItem> items = null;
|
|
String[] arrLine = content.split("\n");
|
|
ExerciseImportResult objResult;
|
for (String line : arrLine) {
|
ExerciseParse objParser = handler.parse(line);
|
|
int iResultType = objParser.getParseResult();
|
|
objResult = new ExerciseImportResult();
|
objResult.setLineText(objParser.getParseLine());
|
objResult.setType(iResultType);
|
if (Handler.HANDLER_RESULT_CONTINUE == iResultType) {
|
objResult.setLastParse(objParser.getParseType());
|
}
|
lstResult.add(objResult);
|
}
|
|
Doc doc = handler.result();
|
|
items = doc.convertExerciseItems();
|
|
parseResult.setLstItems(items);
|
parseResult.setLstResult(lstResult);
|
parseResult.setItemCount(items.size());
|
parseResult.setParseFlag(true);
|
|
return parseResult;
|
}
|
|
/**
|
* 导入习题模块 ：导入习题，将解析结果返回到前台
|
*
|
* @param content
|
* 文本内容
|
* @param groupId
|
* 习题组ID
|
* @return
|
*/
|
// public ExerciseParseResult doImportExercise(String content, String groupId) {
|
//
|
// ExerciseParseResult parseResult = parsePlainText(content);
|
//
|
// List<ExerciseItem> lstItems = parseResult.getLstItems();
|
//
|
// if (null == lstItems || lstItems.isEmpty()) {
|
// return parseResult;
|
// }
|
//
|
// insertItems(groupId, lstItems);
|
//
|
// // 修改习题组最后修改时间
|
// List<ExerciseGroup> result = initExerciseGroup(groupId);
|
// updateGroupUpdateTimeByList(result);
|
//
|
// // 减少返回数据
|
// parseResult.setLstItems(null);
|
// ONSMsg msg = new ONSMsg(onsProducer.getTopic());
|
// msg.put("msgType", "SYS_EXER_SAVE");
|
// msg.put("groupId", groupId);
|
// msg.put("classId", ClientUtils.getClassId());
|
// msg.put("actionType", "new");
|
// try {
|
// onsProducer.sendMsg(msg);
|
// } catch (Exception e) {
|
// log.error("exercise.sendMsg.groupId: " + groupId, e);
|
// }
|
// return parseResult;
|
// }
|
|
/**
|
* 拷贝练习题
|
*
|
* @param newGroupId
|
* @param oldGroupId
|
*/
|
public void doCopyExerciseItem(String newGroupId, String oldGroupId) {
|
//改用存储过程
|
Session session = getCommonDAO().getSessionFactory().getCurrentSession();
|
SQLQuery query = session.createSQLQuery("{call copy_exercise_item(?,?)}");
|
query.setString(0, newGroupId);
|
query.setString(1, oldGroupId);
|
|
//执行
|
query.executeUpdate();
|
}
|
|
/**
|
* 复制历史练习
|
*
|
* @param fromClassId
|
* @return
|
*/
|
public Result executeCopyExercise(String groupId, String subjectId, String subjectName, String chapterId) {
|
|
try {
|
ExerciseGroup source = this.read(ExerciseGroup.class, groupId);
|
|
doCopyExercise(source, subjectId, subjectName, chapterId);
|
} catch (IllegalAccessException e) {
|
log.error(e, e);
|
return new Result(false);
|
} catch (InvocationTargetException e) {
|
log.error(e, e);
|
return new Result(false);
|
}
|
|
return new Result(true);
|
}
|
|
/**
|
* 复制习题
|
*
|
* @param sourceGroup
|
* @param sequenceGroup
|
* @param randomGroup
|
* @return
|
* @throws IllegalAccessException
|
* @throws InvocationTargetException
|
*/
|
private Result doCopyExercise(ExerciseGroup sourceGroup, String subjectId, String subjectName, String chapterId) throws IllegalAccessException, InvocationTargetException {
|
|
ExerciseGroup targetGroup = new ExerciseGroup();
|
|
// 主表：组
|
doSaveCopyGroup(sourceGroup, targetGroup, subjectId, subjectName, chapterId);
|
|
// 关联表： 组 习题
|
doSaveCopyRe(sourceGroup, targetGroup);
|
|
// 扩展表： extend
|
doSaveCopyExtend(sourceGroup,targetGroup);
|
|
return new Result(true);
|
|
}
|
|
private Result doSaveCopyExtend(ExerciseGroup sourceGroup, ExerciseGroup targetGroup) throws IllegalAccessException, InvocationTargetException{
|
|
String hql = "from ExerciseGroupExtend where deleteFlag is false and groupId = ? ";
|
List<ExerciseGroupExtend> lstSourceExtends = this.find(hql, CollectionUtils.newList(sourceGroup.getGroupId()), ExerciseGroupExtend.class);
|
int iCount = this.findCount(hql, CollectionUtils.newList(targetGroup.getGroupId()));
|
if(iCount > 0){
|
return new Result(true);
|
}
|
List<ExerciseGroupExtend> lstTargetExtends = new ArrayList<ExerciseGroupExtend>(lstSourceExtends.size());
|
for (ExerciseGroupExtend et : lstSourceExtends) {
|
|
ExerciseGroupExtend objExtend = new ExerciseGroupExtend();
|
BeanUtils.copyProperties(objExtend, et);
|
TraceUtils.setCreateTrace(objExtend);
|
objExtend.setGroupExtendId(null);
|
objExtend.setDoCount(BigInteger.ZERO);
|
objExtend.setClassAccuracy(BigDecimal.ZERO);
|
objExtend.setCorrectCount(BigInteger.ZERO);
|
objExtend.setSubmitNumber(BigInteger.ZERO);
|
|
objExtend.setGroupId(targetGroup.getGroupId());
|
|
lstTargetExtends.add(objExtend);
|
|
}
|
|
this.saveOrUpdateAll(lstTargetExtends);
|
|
return new Result(true);
|
}
|
|
/**
|
* 复制习题时，保存习题组
|
*
|
* @param sourceGroup
|
* @param targetGroup
|
* @throws InvocationTargetException
|
* @throws IllegalAccessException
|
*/
|
private Result doSaveCopyGroup(ExerciseGroup sourceGroup, ExerciseGroup targetGroup, String subjectId, String subjectName, String chapterId) throws IllegalAccessException, InvocationTargetException {
|
|
BeanUtils.copyProperties(targetGroup, sourceGroup);
|
|
targetGroup.setGroupId(null);
|
targetGroup.setItems(null);
|
targetGroup.setRecords(null);
|
targetGroup.setClassId(ClientUtils.getClassId());
|
targetGroup.setSubjectId(subjectId);
|
targetGroup.setChapterId(chapterId);
|
targetGroup.setStatus(ExerciseGroup.STATUS_DRAFT);
|
targetGroup.setCollegeCourseId(ClientUtils.getCourseId());
|
TraceUtils.setCreateTrace(targetGroup);
|
targetGroup.setOrderNum(BigInteger.valueOf(SchCourseware.COURSEWARE_MAX_ORDER));
|
|
this.saveExerciseGroup(targetGroup);
|
|
return new Result(true);
|
}
|
|
/**
|
* 复制练习时 保存习题关联
|
*
|
* @param sourceGroup
|
* @param targetGroup
|
* @throws IllegalAccessException
|
* @throws InvocationTargetException
|
*/
|
private Result doSaveCopyRe(ExerciseGroup sourceGroup, ExerciseGroup targetGroup) throws IllegalAccessException, InvocationTargetException {
|
|
String hql = " from ExerciseGroupItemRe where deleteFlag is false and exerciseGroupId = ? ";
|
List<ExerciseGroupItemRe> lstSourceGroupRe = this.find(hql, CollectionUtils.newList(sourceGroup.getGroupId()), ExerciseGroupItemRe.class);
|
|
List<ExerciseGroupItemRe> lstTargetItemRe = new ArrayList<ExerciseGroupItemRe>(lstSourceGroupRe.size());
|
for (ExerciseGroupItemRe it : lstSourceGroupRe) {
|
|
ExerciseGroupItemRe ojbItemRe = new ExerciseGroupItemRe();
|
BeanUtils.copyProperties(ojbItemRe, it);
|
|
ojbItemRe.setRelationId(null);
|
ojbItemRe.setExerciseGroupId(targetGroup.getGroupId());
|
lstTargetItemRe.add(ojbItemRe);
|
|
}
|
|
this.saveOrUpdateAll(lstTargetItemRe);
|
|
return new Result(true);
|
}
|
|
/**
|
* 学员得分详情列表
|
*
|
* @param groupId
|
* @return
|
*/
|
@SuppressWarnings("unchecked")
|
@Override
|
public List<Map<String, Object>> resultList(String groupId) {
|
ExerciseGroup exeGroup = read(ExerciseGroup.class, groupId);
|
|
String hql_u = " from UserRegistration where deleteFlag is false and classId = ? and status = ? ";
|
List<UserRegistration> userRegLst = find(hql_u, CollectionUtils.newList(ClientUtils.getClassId(),UserRegistration.STATUS_ACTIVE),UserRegistration.class);
|
Map<String, UserRegistration> userMap = new HashMap<String, UserRegistration>();
|
for (UserRegistration u : userRegLst) {
|
userMap.put(u.getUserId(), u);
|
}
|
|
String hql_re = "select r.accuracy,r.update_Time,r.user_Id from (select * from Exercise_Record "
|
+ "where delete_Flag is false and accuracy <= 100 and exercise_Group_Id = ?";
|
|
if (exeGroup.getType() == ExerciseGroup.TYPE_HOMEWORK || exeGroup.getType() == ExerciseGroup.TYPE_MOCK_EXAM) {
|
hql_re = hql_re.concat(" and status=" + ExerciseRecord.STATUS_SUBMIT);
|
}
|
|
hql_re = hql_re.concat(" order by accuracy desc ) r group by r.user_Id ");
|
|
if (exeGroup.getType() == ExerciseGroup.TYPE_CHAPTER_ITEM || exeGroup.getType() == ExerciseGroup.TYPE_EXERCISE_TOPIC) {
|
|
hql_re = hql_re.concat( " order by r.accuracy desc,r.status desc");
|
} else {
|
|
hql_re = hql_re.concat(" order by r.status desc,r.accuracy desc");
|
}
|
|
List<Object[]> reLst = findBySql(hql_re, CollectionUtils.newList(groupId));
|
Map<String, Object[]> recordMap = new HashMap<String, Object[]>();
|
for (Object[] obj : reLst) {
|
recordMap.put(String.valueOf(obj[2]) , obj);
|
}
|
|
// 组装为Map
|
List<Map<String, Object>> lstMap = new ArrayList<Map<String, Object>>(userRegLst.size());
|
Map<String, Object> map = null;
|
|
int rank = 1;
|
|
for (Object[] record : reLst) {
|
map = new HashMap<String, Object>(5);
|
UserRegistration re = userMap.get(record[2]);
|
if(null != re){
|
map.put("accuracy",record[0]);
|
map.put("time", record[1]);
|
map.put("name", re.getUserName());
|
map.put("mobilePhone", re.getMobilePhone());
|
map.put("salesCode", re.getSalesCode());
|
map.put("createTime", re.getUpdateTime());
|
map.put("rank", rank);
|
rank++;
|
lstMap.add(map);
|
}
|
}
|
for (UserRegistration user : userRegLst) {
|
map = new HashMap<String, Object>(5);
|
Object[] re = recordMap.get(user.getUserId());
|
if(null == re){
|
map.put("accuracy",0);
|
map.put("time", null);
|
map.put("name", user.getUserName());
|
map.put("mobilePhone", user.getMobilePhone());
|
map.put("salesCode", user.getSalesCode());
|
map.put("createTime", user.getUpdateTime());
|
map.put("rank", rank);
|
rank++;
|
lstMap.add(map);
|
}
|
}
|
|
return lstMap;
|
}
|
|
/**
|
* 初始化平均成绩和最高成绩
|
*
|
* @param groupId
|
* @return
|
*/
|
@Override
|
public Map<String, Object> initScore(String groupId) {
|
|
ExerciseGroup exeGroup = read(ExerciseGroup.class, groupId);
|
|
String hql_u = " from UserRegistration where deleteFlag is false and classId = ? and status = ? ";
|
List<UserRegistration> userRegLst = find(hql_u, CollectionUtils.newList(ClientUtils.getClassId(),UserRegistration.STATUS_ACTIVE),UserRegistration.class);
|
|
String hql_re = "select max(accuracy) as accuracy from ExerciseRecord "
|
+ "where deleteFlag is false and accuracy <= 100 and exerciseGroupId = ?";
|
|
if (exeGroup.getType() == ExerciseGroup.TYPE_HOMEWORK || exeGroup.getType() == ExerciseGroup.TYPE_MOCK_EXAM) {
|
hql_re = hql_re.concat( " and status=" + ExerciseRecord.STATUS_SUBMIT);
|
}
|
|
hql_re = hql_re.concat(" GROUP BY userId order by status desc,accuracy desc,updateTime");
|
|
List<BigDecimal> reLst = find(hql_re, CollectionUtils.newList(groupId), BigDecimal.class);
|
|
Map<String, Object> map = new HashMap<String, Object>(3);
|
map.put("groupName", exeGroup.getName());
|
|
if (reLst.isEmpty()) {
|
map.put("avg", 0.00);
|
map.put("max", 0.00);
|
return map;
|
}
|
|
BigDecimal score = BigDecimal.ZERO;
|
|
// 计算已做学员总分数
|
for (BigDecimal obj : reLst) {
|
score = score.add(obj);
|
}
|
|
// 计算班级平均成绩
|
Double scoreNew = Double.valueOf(String.valueOf(score)) / userRegLst.size();
|
|
DecimalFormat df = new DecimalFormat("0.00");
|
map.put("avg", df.format(scoreNew));
|
map.put("max", df.format(reLst.get(0)));
|
|
return map;
|
}
|
|
/**
|
* 题目得分详情
|
*
|
* @param groupId
|
* @return
|
*/
|
@Override
|
public List<ExerciseItemStatistics> itemDetailList(String groupId) {
|
|
String hql_itemStatis = "from ExerciseItemStatistics where deleteFlag is false and groupId = ?";
|
List<ExerciseItemStatistics> itemStatisLst = this.find(hql_itemStatis, CollectionUtils.newList(groupId), ExerciseItemStatistics.class);
|
|
if (itemStatisLst.isEmpty()) {
|
return new ArrayList<ExerciseItemStatistics>();
|
}
|
|
// 获取组
|
ExerciseGroup group = read(ExerciseGroup.class, groupId);
|
if (null == group) {
|
return new ArrayList<ExerciseItemStatistics>();
|
}
|
|
// 默认章节练习
|
String hql = "select item from ExerciseItem item,ExerciseGroupItemRe re " + "where re.exerciseGroupId=? " + "and re.exerciseItemId=item.exerciseId " + "and item.deleteFlag is false " + "and re.deleteFlag is false " + "order by re.itemOrder ";
|
|
// 随机练习,顺序练习
|
if (ExerciseGroup.TYPE_EXERCISE_RANDOM == group.getType() || ExerciseGroup.TYPE_EXERCISE_SEQUENCE == group.getType()) {
|
hql = "select item from ExerciseItem item,ExerciseGroupItemRe re " + "where re.exerciseGroupId=? and " + "re.exerciseItemId=item.exerciseId " + "and item.deleteFlag is false " + "and re.deleteFlag is false " + "order by item.chapterId, re.itemOrder ";
|
}
|
|
// 查询当前组的所有题目
|
List<ExerciseItem> itemAllLst = this.exerDAO.find(hql, CollectionUtils.newList(groupId), ExerciseItem.class);
|
|
if (itemAllLst.isEmpty()) {
|
return new ArrayList<ExerciseItemStatistics>();
|
}
|
|
// 同步编号
|
List<ExerciseItemStatistics> exeItemStatisLst = new ArrayList<ExerciseItemStatistics>(itemStatisLst.size());
|
ExerciseItemStatistics obj = null;
|
for (int j = 0; j < itemAllLst.size(); j++) {
|
for (int i = 0; i < itemStatisLst.size(); i++) {
|
|
obj = itemStatisLst.get(i);
|
if (obj.getExerciseItemId().equals(itemAllLst.get(j).getExerciseId())) {
|
|
obj.setItemNo(j + 1);
|
obj.setClassAccuracyShow(obj.getClassAccuracy() + "%");
|
obj.setOrgAccuracyShow(obj.getOrgAccuracy() + "%");
|
|
// 给类型赋值
|
setExerItemTypeNewName(obj);
|
|
exeItemStatisLst.add(obj);
|
break;
|
}
|
}
|
}
|
|
return exeItemStatisLst;
|
}
|
|
private void setExerItemTypeNewName(ExerciseItemStatistics obj) {
|
// 判断类型文字显示
|
if (obj.getExerciseItemType() == ExerciseItem.TYPE_SINGLE_SELECT) {
|
obj.setItemTypeName("单选题");
|
} else if (obj.getExerciseItemType() == ExerciseItem.TYPE_MULTI_SELECT) {
|
obj.setItemTypeName("多选题");
|
} else if (obj.getExerciseItemType() == ExerciseItem.TYPE_TRUE_OR_FALSE) {
|
obj.setItemTypeName("判断题");
|
} else if (obj.getExerciseItemType() == ExerciseItem.TYPE_ESSAY_QUESTION) {
|
obj.setItemTypeName("问答题");
|
}
|
}
|
|
/**
|
* 加载题目选项详情 - 班级、机构
|
*
|
* @param groupId
|
* @return
|
*/
|
@Override
|
public List<Map<String, Object>> loadOptionsList(String exerciseItemId) {
|
|
String hql_option = "from ExerciseOptionStatistics where deleteFlag is false and exerciseItemId = ? and classId = ? and orgId = ? group by optionId";
|
List<ExerciseOptionStatistics> optionLst = this.find(hql_option, CollectionUtils.newList(exerciseItemId, ClientUtils.getClassId(), ClientUtils.getOrgId()), ExerciseOptionStatistics.class);
|
|
ExerciseItem item = this.read(ExerciseItem.class, exerciseItemId);
|
|
List<Map<String, Object>> lstResult = new ArrayList<Map<String, Object>>(optionLst.size());
|
Map<String, Object> map = null;
|
|
for (ExerciseOptionStatistics optionStatis : optionLst) {
|
|
map = new HashMap<String, Object>(12);
|
map.put("content", optionStatis.getContent());
|
map.put("checked", optionStatis.getChecked());
|
map.put("classCorrectNum", optionStatis.getClassCorrectNum());
|
map.put("classTotalNum", optionStatis.getClassTotalNum());
|
map.put("classAccuracy", optionStatis.getClassAccuracy());
|
map.put("orgCorrectNum", optionStatis.getOrgCorrectNum());
|
map.put("orgTotalNum", optionStatis.getOrgTotalNum());
|
map.put("orgAccuracy", optionStatis.getOrgAccuracy());
|
map.put("exerciseItemTitel", item.getTitle());
|
map.put("correctAnswer", item.getAnswer());
|
|
if (optionStatis.getOptionOrder().equals("True")) {// 为True - 正确
|
map.put("optionOrder", "正确");
|
} else if (optionStatis.getOptionOrder().equals("False")) {// 为False - 错误
|
map.put("optionOrder", "错误");
|
} else {
|
map.put("optionOrder", optionStatis.getOptionOrder());
|
}
|
|
// 判断题目的类型
|
if ((short) item.getType() == ExerciseItem.TYPE_SINGLE_SELECT) {
|
map.put("exerciseItemType", "单选题");
|
} else if ((short) item.getType() == ExerciseItem.TYPE_MULTI_SELECT) {
|
map.put("exerciseItemType", "多选题");
|
} else if ((short) item.getType() == ExerciseItem.TYPE_TRUE_OR_FALSE) {
|
map.put("exerciseItemType", "判断题");
|
} else if ((short) item.getType() == ExerciseItem.TYPE_ESSAY_QUESTION) {
|
map.put("exerciseItemType", "问答题");
|
}
|
|
lstResult.add(map);
|
}
|
return lstResult;
|
}
|
|
/**
|
* 编辑练习保存
|
*/
|
@Override
|
public Result doSaveEditGroup(String groupId,String groupName) {
|
ExerciseGroup group = read(ExerciseGroup.class, groupId);
|
group.setName(groupName);
|
TraceUtils.setUpdateTrace(group);
|
|
this.bulkUpdate("update ExerciseGroup set name = ? where originExerciseId = ?", new Object[]{groupName, group.getGroupId()});
|
this.bulkUpdate("update SchCourseware set name = ? where id in(select groupId from ExerciseGroup where originExerciseId = ?)", new Object[]{groupName, group.getGroupId()});
|
|
return this.saveExerciseGroup(group);
|
}
|
|
/**
|
* 排序
|
*
|
* @param ids 排序id
|
* @param index 序号
|
* @return
|
*/
|
public Result doOrder(List<String> ids, List<Integer> index){
|
// 循环修改order
|
CommonDAO commonDAO = this.getCommonDAO();
|
for( int i=0;i< ids.size();i++){
|
String id = ids.get(i);
|
commonDAO.bulkUpdate("update ExerciseGroup set orderNum = " + index.get(i) + " where groupId = ?", new Object[] { id });
|
commonDAO.bulkUpdate("update SchCourseware set orderNum = " + index.get(i) + " where id = ?", new Object[] { id });
|
}
|
return new Result(true);
|
}
|
|
/**
|
* 排序
|
*
|
* @param ids 排序id
|
* @param index 序号
|
* @return
|
*/
|
public Result doitemOrder(List<String> ids, List<Integer> index,String groupId){
|
// 循环修改order
|
CommonDAO commonDAO = this.getCommonDAO();
|
for( int i=0;i< ids.size();i++){
|
String id = ids.get(i);
|
commonDAO.bulkUpdate("update ExerciseGroupItemRe set itemOrder = " + index.get(i) + " where exerciseItemId = ? and exerciseGroupId = ?", new Object[] { id, groupId });
|
}
|
return new Result(true);
|
}
|
|
/**
|
* 保存练习接口
|
*
|
* @param group
|
* @return
|
*/
|
public Result saveExerciseGroup(ExerciseGroup group){
|
// boolean isClass = StringUtils.isNotEmpty(ClientUtils.getClassId()) || StringUtils.isNotEmpty(group.getClassId());
|
boolean isClass = false;
|
Result result = new Result(false);
|
TraceUtils.setUpdateTrace(group);
|
|
Map<String, Integer> order = courseWareService.getOrder(!isClass, group.getSubjectId(), group.getChapterId());
|
|
//同步排序
|
int subjectOrder = order.get("subjectOrder");
|
int chapterOrder = order.get("chapterOrder");
|
int partOrder = order.get("partOrder");
|
|
group.setSubjectOrder(subjectOrder);
|
group.setChapterOrder(chapterOrder);
|
group.setPartOrder(partOrder);
|
|
result = this.save(group);
|
|
short type = group.getType();
|
if(type != ExerciseGroup.TYPE_EXERCISE_RANDOM && type != ExerciseGroup.TYPE_INTERACT
|
&& type != ExerciseGroup.TYPE_EXERCISE_TEACH_EVALUATE && type != ExerciseGroup.TYPE_EXERCISE_SEQUENCE
|
&& type != ExerciseGroup.TYPE_EXERCISE_FREE){
|
SchCourseware courseware = null;
|
if(isClass){
|
courseware = this.findUnique("from SchCourseware where id = ? and classId = ? and deleteFlag is false",
|
CollectionUtils.newList(group.getGroupId(), group.getClassId()), SchCourseware.class);
|
}else{
|
courseware = this.findUnique("from SchCourseware where id = ? and orgId = ? and classId is null and deleteFlag is false",
|
CollectionUtils.newList(group.getGroupId(), ClientUtils.getOrgId()), SchCourseware.class);
|
|
this.bulkUpdate("update SchCourseware set name = ?,remark = ? where id = ?", new Object[]{group.getName(),String.valueOf(group.getAllCount()), group.getGroupId()});
|
}
|
String parentChapterId = null;
|
if(StringUtils.isNotEmpty(group.getChapterId())){
|
SubjectChapter chapter = this.read(SubjectChapter.class, group.getChapterId());
|
parentChapterId = chapter == null?null : chapter.getParentChapterId();
|
}
|
if(courseware == null){
|
courseware = new SchCourseware();
|
courseware.setChapterId(group.getChapterId());
|
courseware.setId(group.getGroupId());
|
courseware.setCollegeCourseId(group.getCollegeCourseId());
|
courseware.setcType(group.getType());
|
courseware.setType(SchCourseware.COURSEWARE_TYPE_EXERCISE);
|
courseware.setName(group.getName());
|
courseware.setRemark(String.valueOf(group.getAllCount()));
|
courseware.setDeleteFlag(group.getDeleteFlag());
|
courseware.setOrderNum(group.getOrderNum() == null?SchCourseware.COURSEWARE_MAX_ORDER:group.getOrderNum().intValue());
|
courseware.setSubjectId(group.getSubjectId());
|
courseware.setStatus(group.getStatus());
|
courseware.setOrgId(StringUtils.isEmpty(group.getOrgId())?ClientUtils.getOrgId():group.getOrgId());
|
courseware.setClassId(group.getClassId());
|
courseware.setParentChapterId(parentChapterId);
|
courseware.setSubjectOrder(group.getSubjectOrder());
|
courseware.setChapterOrder(group.getChapterOrder());
|
courseware.setPartOrder(group.getPartOrder());
|
TraceUtils.setCreateTrace(courseware);
|
|
}else{
|
courseware.setChapterId(group.getChapterId());
|
//courseware.setCollegeCourseId(group.getCollegeCourseId());
|
courseware.setcType(group.getType());
|
courseware.setName(group.getName());
|
courseware.setRemark(String.valueOf(group.getAllCount()));
|
courseware.setDeleteFlag(group.getDeleteFlag());
|
courseware.setOrderNum(group.getOrderNum() == null?SchCourseware.COURSEWARE_MAX_ORDER:group.getOrderNum().intValue());
|
courseware.setSubjectId(group.getSubjectId());
|
courseware.setStatus(group.getStatus());
|
courseware.setParentChapterId(parentChapterId);
|
courseware.setSubjectOrder(group.getSubjectOrder());
|
courseware.setChapterOrder(group.getChapterOrder());
|
courseware.setPartOrder(group.getPartOrder());
|
|
TraceUtils.setUpdateTrace(courseware);
|
}
|
this.save(courseware);
|
}
|
return result;
|
}
|
|
/**
|
* （后台管理系统）
|
* 管理员同步习题到班级
|
*
|
* @param exerciseItemId
|
* @return
|
* @throws InvocationTargetException
|
* @throws IllegalAccessException
|
*/
|
public Result doSynExercise(String[] exerciseItemIds) throws IllegalAccessException, InvocationTargetException{
|
if(exerciseItemIds == null || exerciseItemIds.length == 0){
|
return new Result(false, "参数错误");
|
}
|
List<Object> lstSaveObject = new ArrayList<>();
|
for(String exerciseItemId : exerciseItemIds){
|
//待同步的练习
|
ExerciseItem sourceItem = this.read(ExerciseItem.class, exerciseItemId);
|
if(sourceItem == null){
|
continue;
|
}
|
|
List<ExerciseItemOption> lstSourceOption = sourceItem.getOptions();
|
List<ExerciseItemAnalisi> lstSourceAnalisi = sourceItem.getAnalysises();
|
List<ExerciseObjectImg> lstSourceImg = this.find("from ExerciseObjectImg where exerciseObjectId = ? and deleteFlag is false and objectType = ?",
|
CollectionUtils.newList(exerciseItemId, ExerciseObjectImg.OBJECT_TYPE_ITEM), ExerciseObjectImg.class);
|
|
//下发的练习
|
List<ExerciseItem> lstExerciseItem = this.find("from ExerciseItem where deleteFlag is false and orgiExerciseId = ?",
|
CollectionUtils.newList(exerciseItemId), ExerciseItem.class);
|
if(lstExerciseItem == null || lstExerciseItem.size() == 0){
|
continue;
|
}
|
//同步题目
|
for(ExerciseItem exerciseItem :lstExerciseItem){
|
exerciseItem.setTitle(sourceItem.getTitle());
|
exerciseItem.setAnswer(sourceItem.getAnswer());
|
TraceUtils.setUpdateTrace(exerciseItem);
|
|
//同步更新练习组的时间
|
this.bulkUpdate("update ExerciseGroup p set p.updateTime = sysdate() where EXISTS "+
|
" (select 1 from ExerciseGroupItemRe i where i.exerciseItemId = ? and i.deleteFlag is false and i.exerciseGroupId = p.groupId)", new Object[]{exerciseItem.getExerciseId()});
|
|
List<ExerciseItemAnalisi> lstExerciseItemAnalisi = exerciseItem.getAnalysises();
|
List<ExerciseObjectImg> lstExerciseObjectImg = this.find("from ExerciseObjectImg where exerciseObjectId = ? and deleteFlag is false and objectType = ?",
|
CollectionUtils.newList(exerciseItem.getExerciseId(), ExerciseObjectImg.OBJECT_TYPE_ITEM), ExerciseObjectImg.class);
|
//同步选项
|
if(lstSourceOption != null && lstSourceOption.size() > 0){
|
ExerciseItemOption option;
|
//删除选项的题目
|
this.bulkUpdate("update ExerciseItemOption p set p.deleteFlag = true where exerciseItemId = ?", new Object[]{exerciseItem.getExerciseId()});
|
for(ExerciseItemOption sourceOption : lstSourceOption){
|
ExerciseObjectImg objExerciseObjectImg;
|
option = this.findUnique("from ExerciseItemOption where exerciseItemId = ? and optionOrder = ?",
|
CollectionUtils.newList(exerciseItem.getExerciseId(), sourceOption.getOptionOrder()), ExerciseItemOption.class);
|
|
ExerciseObjectImg objSourceImg = this.findUnique("from ExerciseObjectImg where exerciseObjectId = ? and deleteFlag is false and objectType = ?",
|
CollectionUtils.newList(sourceOption.getOptionId(), ExerciseObjectImg.OBJECT_TYPE_ITEM_OPTION), ExerciseObjectImg.class);
|
if(option == null){
|
option = new ExerciseItemOption();
|
BeanUtils.copyProperties(option, sourceOption);
|
option.setExerciseItemId(exerciseItem.getExerciseId());
|
option.setOptionId(null);
|
|
TraceUtils.setCreateTrace(option);
|
|
if(objSourceImg != null){//选项图片
|
objExerciseObjectImg = new ExerciseObjectImg();
|
BeanUtils.copyProperties(objExerciseObjectImg, objSourceImg);
|
objExerciseObjectImg.setExerciseObjectId(option.getOptionId());
|
objExerciseObjectImg.setImgId(null);
|
|
TraceUtils.setCreateTrace(objExerciseObjectImg);
|
|
lstSaveObject.add(objExerciseObjectImg);
|
}
|
}else{
|
option.setContent(sourceOption.getContent());
|
option.setChecked(sourceOption.getChecked());
|
option.setDeleteFlag(false);
|
|
TraceUtils.setUpdateTrace(option);
|
|
objExerciseObjectImg = this.findUnique("from ExerciseObjectImg where exerciseObjectId = ? and deleteFlag is false and objectType = ?",
|
CollectionUtils.newList(option.getOptionId(), ExerciseObjectImg.OBJECT_TYPE_ITEM_OPTION), ExerciseObjectImg.class);
|
if(objSourceImg != null){
|
if(objExerciseObjectImg != null){
|
objExerciseObjectImg.setImgPath(objSourceImg.getImgPath());
|
|
TraceUtils.setUpdateTrace(objExerciseObjectImg);
|
}else{
|
objExerciseObjectImg = new ExerciseObjectImg();
|
BeanUtils.copyProperties(objExerciseObjectImg, objSourceImg);
|
objExerciseObjectImg.setExerciseObjectId(option.getOptionId());
|
objExerciseObjectImg.setImgId(null);
|
|
TraceUtils.setCreateTrace(objExerciseObjectImg);
|
}
|
|
lstSaveObject.add(objExerciseObjectImg);
|
}
|
}
|
lstSaveObject.add(option);
|
}
|
}
|
//同步解析
|
if(lstSourceAnalisi != null && lstSourceAnalisi.size() > 0){
|
ExerciseItemAnalisi objExerciseItemAnalisi;
|
if(lstExerciseItemAnalisi == null || lstExerciseItemAnalisi.size() == 0){
|
objExerciseItemAnalisi = new ExerciseItemAnalisi();
|
BeanUtils.copyProperties(objExerciseItemAnalisi, lstSourceAnalisi.get(0));
|
objExerciseItemAnalisi.setExerciseItemId(exerciseItem.getExerciseId());
|
objExerciseItemAnalisi.setExerciseAnalisisId(null);
|
|
TraceUtils.setCreateTrace(objExerciseItemAnalisi);
|
}else{
|
objExerciseItemAnalisi = lstExerciseItemAnalisi.get(0);
|
TraceUtils.setUpdateTrace(objExerciseItemAnalisi);
|
objExerciseItemAnalisi.setAnalysis(lstSourceAnalisi.get(0).getAnalysis());
|
}
|
lstSaveObject.add(objExerciseItemAnalisi);
|
}
|
//同步题目图片
|
if(lstSourceImg != null && lstSourceImg.size() > 0){
|
ExerciseObjectImg objExerciseObjectImg;
|
if(lstExerciseObjectImg == null || lstExerciseObjectImg.size() == 0){
|
objExerciseObjectImg = new ExerciseObjectImg();
|
BeanUtils.copyProperties(objExerciseObjectImg, lstSourceImg.get(0));
|
objExerciseObjectImg.setExerciseObjectId(exerciseItem.getExerciseId());
|
objExerciseObjectImg.setImgId(null);
|
|
TraceUtils.setCreateTrace(objExerciseObjectImg);
|
}else{
|
objExerciseObjectImg = lstExerciseObjectImg.get(0);
|
objExerciseObjectImg.setImgPath(lstSourceImg.get(0).getImgPath());
|
TraceUtils.setUpdateTrace(objExerciseObjectImg);
|
}
|
|
lstSaveObject.add(objExerciseObjectImg);
|
}
|
lstSaveObject.add(exerciseItem);
|
}
|
}
|
this.saveOrUpdateAll(lstSaveObject);
|
return new Result(true);
|
}
|
|
/**
|
* 数据同步接口，同步下发到班级的数据
|
*
|
* @param orgId
|
* @param groupId
|
* @return
|
*/
|
public Result doSynExerciseItem(String orgId, String groupId){
|
List<ExerciseGroup> lstGroup = null;
|
if(StringUtils.isNoneBlank(orgId)){
|
String hql = "select e from ExerciseGroup e ,OrgCollegeCourse o ,ExerciseReCourse c "
|
+ " where e.groupId = c.groupId"
|
+ " and o.collegeCourseId = c.collegeCourseId "
|
+ " and c.orgId=? "
|
+ " and o.deleteFlag is false "
|
+ " and c.deleteFlag is false "
|
+ " and e.deleteFlag is false ";
|
lstGroup = this.find(hql, CollectionUtils.newList(orgId), ExerciseGroup.class);
|
}else if(StringUtils.isNotBlank(groupId)){
|
lstGroup = this.find("from ExerciseGroup g where g.groupId = ?", CollectionUtils.newList(groupId), ExerciseGroup.class);
|
}else{
|
return new Result(false, "参数错误");
|
}
|
|
if(lstGroup == null || lstGroup.size() == 0){
|
return new Result(false, "数据为空");
|
}
|
|
for(ExerciseGroup group : lstGroup){
|
String id = group.getGroupId();
|
List<ExerciseGroup> subListGroup = this.find("from ExerciseGroup e where e.originExerciseId = ? and deleteFlag is false and e.groupId <> ?",
|
CollectionUtils.newList(id, id), ExerciseGroup.class);
|
|
if(subListGroup == null || subListGroup.size() == 0){
|
continue;
|
}
|
List<ExerciseItem> orgiExerciseItem = group.getItems();
|
|
for(ExerciseGroup subGroup : subListGroup){
|
List<ExerciseItem> subExerciseItem = subGroup.getItems();
|
for(ExerciseItem item : subExerciseItem){
|
int index = orgiExerciseItem.indexOf(item);
|
if(index > -1){
|
item.setOrgiExerciseId(orgiExerciseItem.get(index).getExerciseId());
|
|
TraceUtils.setUpdateTrace(item);
|
this.save(item);
|
}
|
}
|
|
}
|
}
|
return new Result(true, "成功");
|
}
|
|
@SuppressWarnings("unchecked")
|
@Override
|
public Result saveExerciseItemBatch(String groupId,List<ExerciseItem> items) {
|
if (items == null || items.size() == 0) {
|
return new Result(false, "没有要保存或更新的题目数据!");
|
}
|
|
ExerciseGroup group = this.read(ExerciseGroup.class, groupId);
|
int allCount= group.getAllCount()==null?0:group.getAllCount().intValue();
|
|
List<String> lstExerciseItemIds = new ArrayList<String>();
|
for (ExerciseItem item : items) {
|
if (StringUtils.isEmpty(item.getExerciseId())) {
|
this.insertExerciseItem(groupId, item, item.getOptions(),
|
item.getAnalisis().getAnalysis());
|
group.setAllCount(BigInteger.valueOf(++allCount));
|
lstExerciseItemIds.add(item.getExerciseId());
|
} else {
|
this.updateExerciseItem(item, item.getOptions(), item.getAnalisis()==null?null:item.getAnalisis().getAnalysis());
|
lstExerciseItemIds.add(item.getExerciseId());
|
}
|
}
|
|
this.save(group);
|
redisTemplate.delete(groupId);
|
return new Result(true, "成功",lstExerciseItemIds.toArray());
|
}
|
|
|
/**
|
* 问卷评估 复制练习
|
* @param groupId
|
* @return
|
*/
|
@Override
|
public String doCopyExerciseByEvaluate(String groupId) {
|
|
// 1、复制练习组
|
ExerciseGroup group = this.read(ExerciseGroup.class, groupId);
|
ExerciseGroup newGroup = new ExerciseGroup();
|
try {
|
BeanUtils.copyProperties(newGroup, group);
|
newGroup.setGroupId(null);
|
newGroup.setRecords(null);
|
} catch (Exception e) {
|
log.error("问卷复制：复制练习BeanUtils.copyProperties()方法copy失败", e);
|
}
|
TraceUtils.setCreateTrace(newGroup);
|
this.save(newGroup);
|
|
// 2、复制题目
|
this.doCopyEvaExerciseItem(newGroup.getGroupId(), groupId);
|
|
return newGroup.getGroupId();
|
}
|
|
/**
|
* 拷贝练习题
|
*
|
* @param newGroupId
|
* @param oldGroupId
|
*/
|
public void doCopyEvaExerciseItem(String newGroupId, String oldGroupId) {
|
//改用存储过程
|
//执行
|
this.executeProduce("{call copy_exercise_item(?,?)}", new Object[]{newGroupId, oldGroupId});
|
}
|
|
/**
|
* 查询问卷用户练习详情
|
* @param recordId
|
* @param evaluateId
|
* @return
|
*/
|
@Override
|
public ResultJson queryUserEvaExerciseDetail(String recordId, String evaluateId) {
|
ExerciseRecord objExerciseRecord = this.read(ExerciseRecord.class, recordId);
|
|
QExerciseItem item = QExerciseItem.exerciseItem;
|
QExerciseGroupItemRe re = QExerciseGroupItemRe.exerciseGroupItemRe;
|
// 查询题目list
|
List<ExerciseItem> itemLst = this.getQueryFactory().select(item).from(item,re)
|
.where(item.exerciseId.eq(re.exerciseItemId)
|
.and(item.deleteFlag.eq(false))
|
.and(re.deleteFlag.eq(false))
|
.and(re.exerciseGroupId.eq(objExerciseRecord.getExerciseGroupId()))).fetch();
|
|
QExerciseItemAnswerU answerU = QExerciseItemAnswerU.exerciseItemAnswerU;
|
QExerciseObjectImg objImg = QExerciseObjectImg.exerciseObjectImg;
|
QExerciseItemOption option = QExerciseItemOption.exerciseItemOption;
|
SchEvaluate objSchEvaluate = this.read(SchEvaluate.class, evaluateId);
|
List<ExerciseObjectImg> lstExerciseObjectImg = null;
|
for (ExerciseItem objExerciseItem : itemLst) {
|
if(objExerciseItem.getType() == ExerciseItem.TYPE_ATTACHMENT){//附件题读取题目的图片信息
|
|
lstExerciseObjectImg = this.getQueryFactory().selectFrom(objImg)
|
.where(objImg.exerciseObjectId.in(
|
this.getQueryFactory().select(option.optionId).from(option)
|
.where(option.exerciseItemId.eq(objExerciseItem.getExerciseId()).and(option.deleteFlag.eq(false))))
|
.and(objImg.deleteFlag.eq(false))
|
.and(objImg.createId.eq(objExerciseRecord.getUserId()))
|
)
|
.fetch();
|
|
}
|
|
//查询用户答题
|
List<ExerciseItemAnswerU> lstExerciseItemAnswerU = this.getQueryFactory().selectFrom(answerU)
|
.where(answerU.deleteFlag.eq(false)
|
.and(answerU.exerciseRecordId.eq(objExerciseRecord.getRecordId()))
|
.and(answerU.exerciseItemId.eq(objExerciseItem.getExerciseId())))
|
.fetch();
|
|
objExerciseItem.setExerciseItemAnswerU(lstExerciseItemAnswerU);
|
}
|
|
//拼装前端所需要的数据
|
Map<String, Object> resultMap = ExerciseUtils.packageUserExerciseDetail(itemLst, objSchEvaluate, lstExerciseObjectImg);
|
|
return new ResultJson(true,"success",resultMap);
|
}
|
|
/**
|
* 删除问卷图片
|
*/
|
@Override
|
public ResultJson dodelEvaExerciseObjImg(String imgObjId) {
|
ExerciseObjectImg img = this.read(ExerciseObjectImg.class, imgObjId);
|
img.setDeleteFlag(true);
|
TraceUtils.setUpdateTrace(img);
|
|
this.save(img);
|
|
return new ResultJson(true,"操作成功");
|
}
|
|
/**
|
* 新增问卷图片
|
*/
|
@Override
|
public List<Map<String, Object>> doAddEvaExerciseObjImg(String[] imgPath, String imgObjId, int imgObjType) {
|
// 查询此练习是否已经存在记录
|
QExerciseObjectImg objImg = QExerciseObjectImg.exerciseObjectImg;
|
List<ExerciseObjectImg> lstObjImg = this.getQueryFactory()
|
.selectFrom(objImg)
|
.where(objImg.exerciseObjectId.eq(imgObjId)
|
.and(objImg.objectType.eq(imgObjType)
|
.and(objImg.deleteFlag.eq(false))))
|
.orderBy(objImg.imgOrder.desc())
|
.fetch();
|
|
int imgOrder = 1;
|
if (!lstObjImg.isEmpty()) {
|
imgOrder = lstObjImg.get(0).getImgOrder() + 1;
|
}
|
|
List<ExerciseObjectImg> lstImg = new ArrayList<ExerciseObjectImg>(imgPath.length);
|
ExerciseObjectImg img = new ExerciseObjectImg();
|
img.setObjectType(imgObjType);
|
img.setImgPath(imgPath[0]);
|
img.setExerciseObjectId(imgObjId);
|
img.setImgOrder(imgOrder);
|
img.setDeleteFlag(false);
|
TraceUtils.setCreateTrace(img);
|
lstImg.add(img);
|
|
for (int i = 1; i < imgPath.length; i++) {
|
img.setImgPath(imgPath[i]);
|
img.setImgOrder(imgOrder++);
|
lstImg.add(img);
|
}
|
|
this.saveOrUpdateAll(lstImg);
|
|
List<Map<String, Object>> lstResult = new ArrayList<Map<String, Object>>(lstImg.size());
|
Map<String, Object> resultMap = null;
|
for (ExerciseObjectImg obj : lstImg) {
|
resultMap = new HashMap<String, Object>(2);
|
resultMap.put("imgId", obj.getImgId());
|
resultMap.put("imgPath", obj.getImgPath());
|
lstResult.add(resultMap);
|
}
|
return lstResult;
|
}
|
|
/**
|
* 查询问卷图片
|
*/
|
@Override
|
public List<Map<String, Object>> queryEvaExerciseObjImg(String imgObjId, int imgObjType) {
|
// 查询此练习是否已经存在记录
|
QExerciseObjectImg objImg = QExerciseObjectImg.exerciseObjectImg;
|
List<ExerciseObjectImg> lstObjImg = this.getQueryFactory()
|
.selectFrom(objImg)
|
.where(objImg.exerciseObjectId.eq(imgObjId)
|
.and(objImg.objectType.eq(imgObjType)
|
.eq(objImg.deleteFlag.eq(false))))
|
.orderBy(objImg.imgOrder.asc())
|
.fetch();
|
|
if(lstObjImg.isEmpty()){
|
return null;
|
}
|
List<Map<String,Object>> lstResult = new ArrayList<Map<String,Object>>(lstObjImg.size());
|
Map<String,Object> resultMap = null;
|
for(ExerciseObjectImg obj:lstObjImg){
|
resultMap = new HashMap<String,Object>(2);
|
resultMap.put("imgId", obj.getImgId());
|
resultMap.put("imgPath", obj.getImgPath());
|
lstResult.add(resultMap);
|
}
|
return lstResult;
|
}
|
|
/**
|
* 更新习题选项图片对象结果
|
*
|
* @param optionId
|
* @param imgIds
|
* @return
|
*/
|
private Result updateEvaExerciseObjImgId(JSONArray titleImgs,String exerciseId) {
|
|
if (titleImgs == null || titleImgs.isEmpty()) {
|
return new Result(false);
|
}
|
|
List<String> imgIds = new ArrayList<String>(titleImgs.size());
|
for(int i=0;i<titleImgs.size();i++){
|
imgIds.add(String.valueOf(titleImgs.getJSONObject(i).get("imgId")));
|
}
|
|
QExerciseObjectImg objImg = QExerciseObjectImg.exerciseObjectImg;
|
this.getQueryFactory().update(objImg).set(objImg.exerciseObjectId, exerciseId)
|
.where(objImg.imgId.in(imgIds)
|
.and(objImg.deleteFlag.eq(false))).execute();
|
|
return new Result(true);
|
}
|
|
/**
|
* 更新习题选项图片对象结果
|
*
|
* @param optionId
|
* @param imgIds
|
* @return
|
*/
|
private Result updateEvaExerOptionObjImgId(ExerciseItemOption option) {
|
|
List<ExerciseObjectImg> imgs = option.getImgs();
|
if (imgs == null || imgs.isEmpty()) {
|
return new Result(false);
|
}
|
List<String> imgIds = new ArrayList<String>(imgs.size());
|
for (int i = 0; i < imgs.size(); i++) {
|
imgIds.add(imgs.get(i).getImgId());
|
}
|
|
QExerciseObjectImg objImg = QExerciseObjectImg.exerciseObjectImg;
|
this.getQueryFactory().update(objImg).set(objImg.exerciseObjectId, option.getOptionId())
|
.where(objImg.imgId.in(imgIds)
|
.and(objImg.deleteFlag.eq(false))).execute();
|
|
return new Result(true);
|
}
|
}
|
