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);
	}
}