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;
|
}
|
|
/**
|
* h³ýÁ·Ï°¹ØÁª±íÊý¾Ý
|
*
|
* @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);
|
}
|
|
/**
|
* ËùÓÐÁ·Ï°Ð޸IJÙ×÷ÐèҪͬʱÐÞ¸Ä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);
|
}
|
}
|
