package com.qxueyou.scc.exercise.action;

import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.InvocationTargetException;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Timestamp;
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 javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.qxueyou.scc.admin.classes.model.ClsClass;
import com.qxueyou.scc.base.dao.CommonDAO;
import com.qxueyou.scc.base.model.Constants;
import com.qxueyou.scc.base.model.ExcelExportParam;
import com.qxueyou.scc.base.model.Pager;
import com.qxueyou.scc.base.model.Result;
import com.qxueyou.scc.base.model.ResultJson;
import com.qxueyou.scc.base.util.ClientUtils;
import com.qxueyou.scc.base.util.CollectionUtils;
import com.qxueyou.scc.base.util.ExcelExportUtils;
import com.qxueyou.scc.exercise.model.ExerGroupResponseData;
import com.qxueyou.scc.exercise.model.ExerItemResponseData;
import com.qxueyou.scc.exercise.model.ExerciseAddItemParams;
import com.qxueyou.scc.exercise.model.ExerciseChapter;
import com.qxueyou.scc.exercise.model.ExerciseDataSubmitLog;
import com.qxueyou.scc.exercise.model.ExerciseGroup;
import com.qxueyou.scc.exercise.model.ExerciseGroupExtend;
import com.qxueyou.scc.exercise.model.ExerciseItem;
import com.qxueyou.scc.exercise.model.ExerciseItemAnswerData;
import com.qxueyou.scc.exercise.model.ExerciseItemData;
import com.qxueyou.scc.exercise.model.ExerciseItemOption;
import com.qxueyou.scc.exercise.model.ExerciseItemStatistics;
import com.qxueyou.scc.exercise.model.ExerciseObjectImg;
import com.qxueyou.scc.exercise.model.ExerciseParseResult;
import com.qxueyou.scc.exercise.model.ExerciseRecord;
import com.qxueyou.scc.exercise.model.ExerciseSubmitAnswerData;
import com.qxueyou.scc.exercise.model.ExerciseSubmitAnswerDataList;
import com.qxueyou.scc.exercise.service.IExercisePyService;
import com.qxueyou.scc.exercise.service.IExerciseService;
import com.qxueyou.scc.exercise.service.IExerciseVerService;
import com.qxueyou.scc.org.model.OrgCollegeCourse;
import com.qxueyou.scc.org.model.Organization;
import com.qxueyou.scc.school.model.SchClassSubject;
import com.qxueyou.scc.sys.service.IOssService;
import com.qxueyou.scc.user.model.ExportUserScore;

/**
 * Á·Ï°ÌâÄ¿¿ØÖÆ
 * @author zhiyong
 *
 */
@Controller
@RequestMapping(value = "/exercise/Exercise")
public class ExerciseController {
	/** ÈÕÖ¾  */
	private static final Logger log = LogManager.getLogger("ExerciseController");
	
	/** commonDAO  */
	@Autowired
	private CommonDAO commonDAO;
	
	/** Á·Ï° service */
	@Autowired
	private IExerciseService exerciseService;
	
	/** Á·Ï°µ¼Èë service */
	@Autowired
	private IExercisePyService exercisePyService;
	
	/** Á·Ï°V2.0°æ±¾½Ó¿Úservice */
	@Autowired
	private IExerciseVerService exerciseVerService;

	/** Á·Ï°V2.0°æ±¾½Ó¿Úservice */
//	@Autowired
//	IConfigService cfg;
	
	/** oss service */
	@Autowired
	IOssService ossService;
	
	/** ÏûÏ¢·¢ËÍ service */
//	@Autowired
//	IMsgVenderService  easemobService;
	
	/** ×éid */
	private static final String GROUP_ID = "groupId";
	
	/** ×öÌâ¼Ç¼id */
	private static final String EXERCISE_RECORD_ID = "exerciseRecordId";
	
	/** ---------------------------APP V2.0½Ó¿Ú start----------------------*/
	/**
	 * APP2.0: »ñÈ¡¼ÒÍ¥×÷Òµlist
	 * URL:    /exercise/Exercise/homeWorkListNew
	 * 
	 * 
	 *ÇëÇó²ÎÊý={
			subjectId:¿Î³Ìid£¬//¿ÉÑ¡£¬ÓÃÓÚ¸ßУ°æ
			page:µ±Ç°Ò³,//±Ø´«,´óÓÚ0
			limit:ÿҳÏÞÖÆÌõÊý,//±Ø´«,´óÓÚ0
		}
		 ·µ»Ø²ÎÊý=[
		    {
		        GROUP_ID:"×éid",
		        "classId":°à¼¶id,
		        "courseId":¿ÆÄ¿id,
		        "orgId":»ú¹¹id,
		        "subjectId":¿Î³Ìid,
		        "name":"×éÃû",
		        "type":×éÀàÐÍ ,
		        "updateTime":¸üÐÂʱ¼ä,
		        "answerUpdateTime":±¾Ì×Ìâ´ðÌâ¸üÐÂʱ¼ä,
		        "allCount":ÌâÄ¿×ÜÊý,
		        "exerciseTime":"¿¼ÊÔʱ¼ä",
		        EXERCISE_RECORD_ID:"¼Ç¼id",
		        "doCount": ×öÌâ¸öÊý,
		        "correctCount": ÕýÈ·¸öÊý,
		        "submitNumber":ÒÑÌá½»ÈËÊý(¼ÒÍ¥×÷Òµ),
		        "currTitleNumber":µ±Ç°×öÌâÐòºÅ,
		        "status":×öÌâ״̬(0£ºÎ´Ìá½» 1£ºÒÑÌá½»),
		        "completionRate": Íê³ÉÂÊ, 
		        "accuracy": ÕýÈ·ÂÊ, 
		        "score": ·ÖÊý,
		        "extendAllCount":´íÌâ±¾¡¢Êղر¾×ÜÊý
		    },
		    ...Ñ­»·¶à¸ö
		]
	 * 
	 * @return
	 */
	@RequestMapping(value = "homeWorkListNew", method = RequestMethod.GET)
	public @ResponseBody List<ExerGroupResponseData> getHomeWorkExerList(
			@RequestParam(value="subjectId", required = false) String subjectId,
			@RequestParam(value="page") int page,
			@RequestParam(value="limit") int limit,
			@RequestParam(value="selected", required = false) Integer selected)  {// 0:È«²¿  1£ºÎ´¿ªÊ¼ 2£º×öÌâÖÐ 3£ºÒÑÌá½»

		// »ñÈ¡group data
		List<ExerGroupResponseData> lstResult = getExericseListData(ExerciseGroup.TYPE_HOMEWORK, 
				null, page, limit, selected, null);
		
	    return lstResult;  
	}
	
	
	/**
	 * APP2.0: »ñÈ¡Õ½ÚÁ·Ï°list
	 * URL:    /exercise/Exercise/chapterListNew
	 * 
	 * @return
	 */
	@RequestMapping(value = "chapterListNew", method = RequestMethod.GET)
	public @ResponseBody List<ExerGroupResponseData> getChapterItemList(
			@RequestParam(value="subjectId", required = false) String subjectId,
			@RequestParam(value="page") int page,
			@RequestParam(value="limit") int limit,
			@RequestParam(value="selected", required = false) Integer selected, String chapterId)  {
		
		// »ñÈ¡group data
		List<ExerGroupResponseData> lstResult = getExericseListData(ExerciseGroup.TYPE_CHAPTER_ITEM, 
				subjectId, page, limit, selected, chapterId);
		
	    return lstResult;  
	}
	
	/**
	 * APP2.0: »ñÈ¡Ä£Ä⿼ÊÔlist
	 * URL:    /exercise/Exercise/examsListNew
	 * 
	 * @return
	 */ 
	@RequestMapping(value = "examsListNew", method = RequestMethod.GET)
	public @ResponseBody List<ExerGroupResponseData> getExamsExerList(
			@RequestParam(value="subjectId", required = false) String subjectId,
			@RequestParam(value="page") int page,
			@RequestParam(value="limit") int limit,
			@RequestParam(value="selected", required = false) Integer selected)  {
		
		// »ñÈ¡group data
		List<ExerGroupResponseData> lstResult = getExericseListData(ExerciseGroup.TYPE_MOCK_EXAM, 
				null, page, limit, selected, null);
		
	    return lstResult;  
	}
	
	/**
	 * APP2.0: »ñȡרÌâÁ·Ï°list
	 * URL:    /exercise/Exercise/topicListNew
	 * 
	 * @return
	 */ 
	@RequestMapping(value = "topicListNew", method = RequestMethod.GET)
	public @ResponseBody List<ExerGroupResponseData> getTopicExerList(
			@RequestParam(value="subjectId", required = false) String subjectId,
			@RequestParam(value="page") int page,
			@RequestParam(value="limit") int limit,
			@RequestParam(value="selected", required = false) Integer selected)  {
		
		// »ñÈ¡group data
		List<ExerGroupResponseData> lstResult = getExericseListData(ExerciseGroup.TYPE_EXERCISE_TOPIC, 
				null, page, limit, selected, null);
		
	    return lstResult;  
	}
	
	/**
	 * APP2.0: »ñȡרÌâÁ·Ï°list
	 * URL:    /exercise/Exercise/freeListNew
	 * 
	 * @return
	 */ 
	@RequestMapping(value = "freeListNew", method = RequestMethod.GET)
	public @ResponseBody List<ExerGroupResponseData> getFreeExerList(
			@RequestParam(value="subjectId", required = false) String subjectId,
			@RequestParam(value="page") int page,
			@RequestParam(value="limit") int limit,
			@RequestParam(value="selected", required = false) Integer selected)  {
		
		// »ñÈ¡group data
		List<ExerGroupResponseData> lstResult = getExericseListData(ExerciseGroup.TYPE_EXERCISE_FREE, 
				null, page, limit, selected, null);
		
	    return lstResult;
	}
	
	/**
	 * »ñÈ¡Á·Ï°ÁбíÊý¾Ý
	 * @param exerType
	 * @param subjectId
	 * @param page
	 * @param limit
	 * @param selected // 0:È«²¿  1£ºÎ´¿ªÊ¼ 2£º×öÌâÖÐ 3£ºÒÑÌá½»
	 * @return
	 */
	private List<ExerGroupResponseData> getExericseListData(short exerType, 
			String subjectId, int page, int limit, Integer selected, String chapterId){
		int pageNum = page;
		int pageSize = limit;
		Integer iSelected = selected;
		
		// 1.·ÖÒ³ÐÅÏ¢
		if(pageNum < 1){
			pageNum = 1;
		}
		if(pageSize < 1){
			pageSize = 1;
		}
		if(iSelected == null){//Ϊ¿ÕÉèÖÃΪ È«²¿
			iSelected = 0;
		}
		Pager pager = new Pager();
		pager.setPageNum(pageNum);
		pager.setPageSize(limit);
		
		// 2.µÃµ½ÁбíÊý¾Ý
		List<ExerGroupResponseData> lstResult = exerciseVerService.queryExericseListData(exerType,subjectId,pager,iSelected, chapterId);
		
		if(null == lstResult){// ½á¹ûת»»³É []
			lstResult = new ArrayList<ExerGroupResponseData>();
		}
		
		return lstResult;
	}

	/**
	 * APP2.0: ²éѯ×öÌâ¼Ç¼
	 * URL:    /exercise/Exercise/exerRecord
	 *  ÇëÇó²ÎÊý={
			exerType:Á·Ï°ÀàÐÍ,//±Ø´«
			subjectId:¿Î³Ìid£¬//¿ÉÑ¡£¬ÓÃÓÚ¸ßУ°æ
			page:µ±Ç°Ò³,//±Ø´«,´óÓÚ0
			limit:ÿҳÏÞÖÆÌõÊý,//±Ø´«,´óÓÚ0
		}
		
		·µ»Ø²ÎÊý=[
			    {
			        GROUP_ID:"×éid",
			        "classId":°à¼¶id,
			        "courseId":¿ÆÄ¿id,
			        "orgId":»ú¹¹id,
			        "subjectId":¿Î³Ìid,
			        "name":"×éÃû",
			        "type":×éÀàÐÍ ,
			        "updateTime":¸üÐÂʱ¼ä,
			        "answerUpdateTime":±¾Ì×Ìâ´ðÌâ¸üÐÂʱ¼ä,
			        "allCount":ÌâÄ¿×ÜÊý,
			        "exerciseTime":"¿¼ÊÔʱ¼ä",
			        EXERCISE_RECORD_ID:"¼Ç¼id",
			        "doCount": ×öÌâ¸öÊý,
			        "correctCount": ÕýÈ·¸öÊý,
			        "submitNumber":ÒÑÌá½»ÈËÊý(¼ÒÍ¥×÷Òµ),
			        "currTitleNumber":µ±Ç°×öÌâÐòºÅ,
			        "status":×öÌâ״̬(0£ºÎ´Ìá½» 1£ºÒÑÌá½»),
			        "completionRate": Íê³ÉÂÊ, 
			        "accuracy": ÕýÈ·ÂÊ, 
			        "score": ·ÖÊý,
			        "extendAllCount":´íÌâ±¾¡¢Êղر¾×ÜÊý
			    },
			    ...Ñ­»·¶à¸ö
			]
	 * @param page
	 * @param start
	 * @param limit
	 * @return
	 */
	@RequestMapping(value = "exerRecord", method = RequestMethod.GET)
	public @ResponseBody List<ExerGroupResponseData> queryExerRecordListNew(
			@RequestParam(value="exerType") int exerType,
			@RequestParam(value="subjectId", required = false) String subjectId,
			@RequestParam(value="page") int page,
			@RequestParam(value="limit") int limit)  {
		
		int pageNum = page;
		int pageSize = limit;
		
		// 1.·ÖÒ³ÐÅÏ¢
		if(pageNum < 1){
			pageNum = 1;
		}
		if(pageSize < 1){
			pageSize = 1;
		}
		
		Pager pager = new Pager();
		pager.setPageNum(pageNum);
		pager.setPageSize(pageSize);
		
		
		StringBuffer hql = new StringBuffer(512);
		// 2.²éѯ½á¹û
		hql.append("select g,"
					+ "  r.recordId,r.updateTime,r.doCount,r.titleMaxNumber,r.status,"
					+ "	 r.correctCount,r.completionRate,r.score,r.accuracy,e.repeatFlag,e.classAccuracy, "
					+ "  e.exerciseTime,e.exerciseStrategy,e.exerciseSource,e.exerciseMode"
					+ " from ExerciseRecord r, ExerciseGroup g,ExerciseGroupExtend e "
					+ " where r.exerciseGroupId=g.groupId"
					+ " and g.groupId=e.groupId"
					+ " and g.deleteFlag is false "
					+ " and r.userId=?"
					+ " and g.type=?"
					+ " and g.classId=? ");
		
		List<Object> args = CollectionUtils.newList(ClientUtils.getUserId(), (short)exerType, ClientUtils.getClassId());
		
		/*if(StringUtils.isNotBlank(subjectId)){
			hql.append("  and g.subjectId=? ");
			args.add(subjectId);
		}*/
		
		hql.append("  order by r.updateTime desc ");
		
		List<Object[]> lstRecord = commonDAO.findList(hql.toString(), pager, args, Object[].class);
		
		List<ExerGroupResponseData> lstResult = new ArrayList<ExerGroupResponseData>(lstRecord.size());
		
		// 3.ÖØ×é×Ö¶Î
		for(Object[] obj:lstRecord){
			
			// ×é×°Á·Ï°×öÌâ¼Ç¼ÁбíÊý¾Ý
			lstResult.add(packagingExerciseRecordListData(exerType, obj));
			
		}
			
		return lstResult;
	}

	/**
	 * ×é×°Á·Ï°×öÌâ¼Ç¼ÁбíÊý¾Ý
	 * @param exerType
	 * @param obj
	 * @param group
	 * @param result
	 * @return
	 */
	private ExerGroupResponseData packagingExerciseRecordListData(int exerType,
			Object[] obj) {
		ExerciseGroup group = (ExerciseGroup)obj[0];
		ExerGroupResponseData result =  new ExerGroupResponseData();
		
		// ¸³Öµ×Ö¶ÎÖµ
		BeanUtils.copyProperties(group, result);
		
		result.setExerciseRecordId(String.valueOf(obj[1]));
		result.setAnswerUpdateTime((Timestamp)obj[2]);
		if(obj[3] == null){
			result.setDoCount(BigInteger.ZERO);
		}else{
			result.setDoCount((BigInteger)obj[3]);
		}
		result.setCurrTitleNumber(String.valueOf(obj[4]));
		result.setStatus(String.valueOf(obj[5]));
		
		// ×é×°Á·Ï°×öÌâ¼Ç¼²¿·Ö²ÎÊý
		packagingExerciseRecordListParam(obj, result);
		
		result.setExtendAllCount(group.getAllCount());
		
		if(obj[10] == null){
			if(exerType == ExerciseGroup.TYPE_HOMEWORK){// ¼ÒÍ¥×÷Òµ
				result.setRepeatFlag(false);
			}else{
				result.setRepeatFlag(true);
			}
		}else{
			result.setRepeatFlag(!(boolean)obj[10]);// true ¿ÉÒÔÖØ×ö false²»ÄÜÖØ×ö
		}
		
		// °à¼¶ÕýÈ·ÂÊ
		result.setClassAccuracy(obj[11] == null ? "--" :obj[11]+"%");
		
		if(exerType == ExerciseGroup.TYPE_EXERCISE_FREE 
				|| exerType == ExerciseGroup.TYPE_MOCK_EXAM ){// ×ÔÓÉÁ·Ï° Ä£Ä⿼ÊÔ
			result.setExerciseTime(String.valueOf(obj[12]));
			result.setExerciseStrategy(String.valueOf(obj[13]));
			result.setExerciseSource(String.valueOf(obj[14]));
			result.setExerciseMode(String.valueOf(obj[15]));
		}
		return result;
	}

	/**
	 * ×é×°Á·Ï°×öÌâ¼Ç¼²¿·Ö²ÎÊý ²ð·Ö·½·¨
	 * @param obj
	 * @param result
	 */
	private void packagingExerciseRecordListParam(Object[] obj,
			ExerGroupResponseData result) {
		if(obj[6] == null){
			result.setCorrectCount(BigInteger.ZERO);
		}else{
			result.setCorrectCount(new BigInteger(String.valueOf(obj[6])));
		}
		if(obj[7] == null){
			result.setCompletionRate(BigDecimal.ZERO);
		}else{
			result.setCompletionRate(new BigDecimal(String.valueOf(obj[7])));
		}
		if(obj[8] == null){
			result.setScore(BigDecimal.ZERO);
		}else{
			result.setScore(new BigDecimal(String.valueOf(obj[8])));
		}
		if(obj[9] == null){
			result.setAccuracy(BigDecimal.ZERO);
		}else{
			result.setAccuracy(new BigDecimal(String.valueOf(obj[9])));
		}
	}
	
	/**
	 * APP2.0: »ñÈ¡¼ÒÍ¥×÷ÒµÁ·Ï°ÌâÄ¿Êý¾Ý
	 * URL:    /exercise/Exercise/homeworkExercise
	 * 
	 * ÇëÇó²ÎÊý={
			groupId:×éid£¬//±Ø´«
			exerciseRecordId:µ±Ç°Ò³,//±Ø´«,ûÓд«""
			getExercise:ÊÇ·ñ¸üÐÂÌâÄ¿,//±Ø´«,
			booleanÖµ£¬Ã»Óд«false
			getAnswer:ÊÇ·ñ¸üдð°¸,//±Ø´«,
			booleanÖµ£¬Ã»Óд«false
		}
	      
		·µ»Ø²ÎÊý={
	    "items":[// ÌâÄ¿¼¯ºÏ
	        {
	            "exerciseId":Á·Ï°id,
	            "chapterId":null,
	            "lessonId":null,
	            "title":±êÌâ,
	            "type":ÌâÄ¿ÀàÐÍ,
	            "answer":ÕýÈ·´ð°¸,
	            "options":[
	                {
	                    "optionId":Ñ¡Ïîid,
	                    "checked":true,
	                    "content":ÄÚÈÝ,
	                    "optionOrder":ÌâÄ¿ÐòºÅ,
	                    "exerciseItemId":"Á·Ï°id",
	                    "imgs":[
	                        {
	                            "imgId":"ͼƬid",
	                            "exerciseObjectId":null,
	                            "imgPath":ͼƬ·¾¶,
	                            "imgOrder":ÅÅÐò,
	                            "objectType":ͼƬÀàÐÍ 1£ºÌâÄ¿ 2£ºÑ¡Ïî
	                        },
	                        ... Ñ­»·¶à¸ö
	                    ]
	                },
	                ... Ñ­»·¶à¸ö
	            ],
	            "scores":null,
	            "itemNo":null,
	            "analisisResult":{
	                "allAccuracy":ȫվͳ¼Æ ÕýÈ·ÂÊ,
	                "analysis":"½âÎö",
	                "submitAllNumber":È«Õ¾ Ìá½»×ÜÊý,
	                "usualFaultAnswers":Ò×´íÌâ,
	                "exerciseAnalisisUId":null,
	                "accuracy":¸öÈËͳ¼Æ ÕýÈ·ÂÊ,
	                "submitNumber":¸öÈËͳ¼Æ  Ìá½»×ÜÊý,
	                "submitErrorNumber":¸öÈËͳ¼Æ  Ìá½»´íÎó×ÜÊý,
	            },
	            "imgs":[
	                {
	                   "imgId":"ͼƬid",
	                    "exerciseObjectId":null,
	                    "imgPath":ͼƬ·¾¶,
	                    "imgOrder":ÅÅÐò,
	                    "objectType":ͼƬÀàÐÍ 1£ºÌâÄ¿ 2£ºÑ¡Ïî
	                },
	                ... Ñ­»·¶à¸ö
	            ],
	            "commentFlag": null,
	        }
	    ],
	    "answers":[// ¸öÈ˴𰸼¯ºÏ
	        {
	            "answerUId":"Ö÷¼üid",
	            "answer":Ñ¡Ôñ´ð°¸  È磺¶àѡΪ(A,B,C),
	            "correct":0,
	            "exerciseItemId":Á·Ï°id,
	            EXERCISE_RECORD_ID:¼Ç¼id,
	            "userId":Óû§id
	        },
	        ... Ñ­»·¶à¸ö
	    ]
	}
	 * @param groupId ×éid
	 * @param exerciseRecordId Á·Ï°¼Ç¼id
	 * @param getExercise ÊÇ·ñ»ñÈ¡Á·Ï°Ìâ
	 * @param getAnswer ÊÇ·ñ»ñÈ¡´ð°¸
	 * @return
	 */
	@RequestMapping(value = "homeworkExercise", method = RequestMethod.GET)
	public @ResponseBody ExerItemResponseData getHomeworkExerciseData(
			@RequestParam(value = GROUP_ID) String groupId,
			@RequestParam(value = EXERCISE_RECORD_ID) String exerciseRecordId,
			@RequestParam(value = "getExercise") boolean getExercise,
			@RequestParam(value = "getAnswer") boolean getAnswer)  {
		
		// »ñÈ¡½á¹û
		ExerItemResponseData result = exerciseVerService.queryExerItemResponseData(groupId,
				exerciseRecordId, getExercise, getAnswer, ExerciseGroup.TYPE_HOMEWORK);
		
		return result;
	}
	
	/**
	 * APP2.0: »ñÈ¡Ä£Ä⿼ÊÔÁ·Ï°ÌâÄ¿Êý¾Ý
	 * URL:    /exercise/Exercise/examExercise
	 * @param groupId ×éid
	 * @param exerciseRecordId Á·Ï°¼Ç¼id
	 * @param getExercise ÊÇ·ñ»ñÈ¡Á·Ï°Ìâ
	 * @param getAnswer ÊÇ·ñ»ñÈ¡´ð°¸
	 * @return
	 */
	@RequestMapping(value = "examExercise", method = RequestMethod.GET)
	public @ResponseBody ExerItemResponseData getExamExerciseData(
			@RequestParam(value = GROUP_ID) String groupId,
			@RequestParam(value = EXERCISE_RECORD_ID) String exerciseRecordId,
			@RequestParam(value = "getExercise") boolean getExercise,
			@RequestParam(value = "getAnswer") boolean getAnswer)  {
		
		// »ñÈ¡½á¹û
		ExerItemResponseData result = exerciseVerService.queryExerItemResponseData(groupId,
				exerciseRecordId, getExercise, getAnswer, ExerciseGroup.TYPE_MOCK_EXAM);
		
		return result;
	}
	
	
	/**
	 * APP2.0: »ñÈ¡Õ½ÚÁ·Ï°ÌâÄ¿Êý¾Ý
	 * URL:    /exercise/Exercise/chapterExercise
	 * @param groupId ×éid
	 * @param exerciseRecordId Á·Ï°¼Ç¼id
	 * @param getExercise ÊÇ·ñ»ñÈ¡Á·Ï°Ìâ
	 * @param getAnswer ÊÇ·ñ»ñÈ¡´ð°¸
	 * @return
	 */
	@RequestMapping(value = "chapterExercise", method = RequestMethod.GET)
	public @ResponseBody ExerItemResponseData getChapterExerciseData(
			@RequestParam(value = GROUP_ID) String groupId,
			@RequestParam(value = EXERCISE_RECORD_ID) String exerciseRecordId,
			@RequestParam(value = "getExercise") boolean getExercise,
			@RequestParam(value = "getAnswer") boolean getAnswer)  {
		
		// »ñÈ¡½á¹û
		ExerItemResponseData result = exerciseVerService.queryExerItemResponseData(groupId,
				exerciseRecordId, getExercise, getAnswer, ExerciseGroup.TYPE_CHAPTER_ITEM);
		
		return result;
	}
	
	/**
	 * APP2.0: »ñȡרÌâÁ·Ï°ÌâÄ¿Êý¾Ý
	 * URL:    /exercise/Exercise/topicExercise
	 * @param groupId ×éid
	 * @param exerciseRecordId Á·Ï°¼Ç¼id
	 * @param getExercise ÊÇ·ñ»ñÈ¡Á·Ï°Ìâ
	 * @param getAnswer ÊÇ·ñ»ñÈ¡´ð°¸
	 * @return
	 */
	@RequestMapping(value = "topicExercise", method = RequestMethod.GET)
	public @ResponseBody ExerItemResponseData getTopicExerciseData(
			@RequestParam(value = GROUP_ID) String groupId,
			@RequestParam(value = EXERCISE_RECORD_ID) String exerciseRecordId,
			@RequestParam(value = "getExercise") boolean getExercise,
			@RequestParam(value = "getAnswer") boolean getAnswer)  {
		
		// »ñÈ¡½á¹û
		ExerItemResponseData result = exerciseVerService.queryExerItemResponseData(groupId,
				exerciseRecordId, getExercise, getAnswer, ExerciseGroup.TYPE_EXERCISE_TOPIC);
		
		return result;
	}
	
	
	/**
	 * APP2.0: »ñȡרÌâÁ·Ï°ÌâÄ¿Êý¾Ý
	 * URL:    /exercise/Exercise/freeExercise
	 * @param groupId ×éid
	 * @param exerciseRecordId Á·Ï°¼Ç¼id
	 * @param getExercise ÊÇ·ñ»ñÈ¡Á·Ï°Ìâ
	 * @param getAnswer ÊÇ·ñ»ñÈ¡´ð°¸
	 * @return
	 */
	@RequestMapping(value = "freeExercise", method = RequestMethod.GET)
	public @ResponseBody ExerItemResponseData getFreeExerciseData(
			@RequestParam(value = GROUP_ID) String groupId,
			@RequestParam(value = EXERCISE_RECORD_ID) String exerciseRecordId,
			@RequestParam(value = "getExercise") boolean getExercise,
			@RequestParam(value = "getAnswer") boolean getAnswer)  {
		
		// »ñÈ¡½á¹û
		ExerItemResponseData result = exerciseVerService.queryExerItemResponseData(groupId,
				exerciseRecordId, getExercise, getAnswer, ExerciseGroup.TYPE_EXERCISE_FREE);
		
		
		return result;
	}
	
	/**
	 * APP2.0: »ñȡרÌâÁ·Ï°ÌâÄ¿Êý¾Ý
	 * URL:    /exercise/Exercise/newFreeExercise
	 * 
	 * {
	 * 	source: Á·Ï°À´Ô´(1:Á·Ï°Ìâ¿â 2£º¿¼ÊÔÌâ¿â  3£º¼ÒÍ¥×÷Òµ)   ¶à¸öÒÔ¶ººÅ·Ö¿ª
		strategy:×öÌⷽʽ£¨1£ºÎ´×öÌâÓÅÏÈ  2£º´íÌâÓÅÏÈ£©
		mode:×öÌâģʽ(1:Á·Ï°Ä£Ê½ 2£º¿¼ÊÔģʽ)
		count:ÊýÁ¿£¨30 50 100 200£©
		exerciseTime:Á·Ï°Ê±¼ä
	 * }
	 * 
	 * @return
	 */
	@RequestMapping(value = "newFreeExercise", method = RequestMethod.GET)
	public @ResponseBody ExerItemResponseData getFreeExerciseData(
			@RequestParam(value="subjectId", required = false) String subjectId,
			@RequestParam(value = "source") String source,
			@RequestParam(value = "strategy") String strategy,
			@RequestParam(value = "mode") String mode,
			@RequestParam(value = "count") int count,
			@RequestParam(value = "exerciseTime") String exerciseTime)  {
		
		if(StringUtils.isBlank(source)
				|| StringUtils.isBlank(strategy)
				|| StringUtils.isBlank(exerciseTime)
				|| count < 1){
			return null;
		}
		
		// ¸ù¾ÝÌõ¼þ»ñÈ¡×ÔÓÉÁ·Ï°
		ExerItemResponseData result = exerciseVerService.doGetFreeExercise(
				null, source, strategy, mode, count, exerciseTime);
		
		return result;
	}
	
	
	/**
	 * APP2.0: Ìá½»Á·Ï°´ð°¸
	 * URL:    /exercise/Exercise/exerAnswers
	 * 
	 * ÇëÇó²ÎÊý={
	    "exerciseGroupId": ×éid, 
	    EXERCISE_RECORD_ID: ¼Ç¼id, 
	    "exerciseExtendId": null, 
	    "currTitleNum": "µ±Ç°ÌâºÅ", 
	    "status": ״̬,
	    "type": Á·Ï°ÀàÐÍ,// ÕûÐÍ
	    "doCount": Á·Ï°ÀàÐÍ,
	    "correctCount": ÕýÈ·¸öÊý, 
	    "allCount":ÌâÄ¿×ÜÊý,
	    "items": [
	        {
	            "exerciseId": "Á·Ï°id", 
	            "type": Á·Ï°ÀàÐÍ,// ÕûÊýÐÍ
	            "answer": "Ñ¡Ôñ´ð°¸", 
	            "correct": ÊÇ·ñÕýÈ·(0:´íÎó 1£ºÕýÈ· 2:δ֪)
	        }, 
	        {
	            "exerciseId": "Á·Ï°id", 
	            "type": Á·Ï°ÀàÐÍ, 
	            "answer": "Ñ¡Ôñ´ð°¸", 
	            "correct": ÊÇ·ñÕýÈ·(0:´íÎó 1£ºÕýÈ· 2:δ֪)
	        }
	    ]
		}
		
		·µ»Ø²ÎÊý={
			"success":true,//true:³É¹¦ false:ʧ°Ü
			"attrs":{EXERCISE_RECORD_ID:Á·Ï°¼Ç¼id,
					"updateTime":ÐÞ¸Äʱ¼ä
			 },
			"msg":"Ìá½»³É¹¦",//½á¹ûÐÅÏ¢
			}

	 * 
	 * @param answers
	 * @return
	 */
	@RequestMapping(value = "exerAnswers", method = RequestMethod.POST)
	public @ResponseBody Object doSubmitExerAnswer(
			@RequestParam(value = "answers")  String answers)  {
		
		// Óû§±¾´Î×öÌâÌá½»µÄÊý¾Ý
		List<ExerciseItemAnswerData> lstAnswers = null;
		
		Result result = new Result(false);
		String exerciseRecordId = null;
		try {
			ObjectMapper mapper = new ObjectMapper();
			
			// ×°»»jsonµ½¶ÔÏó
			ExerciseSubmitAnswerData answerData = mapper.readValue(answers, ExerciseSubmitAnswerData.class);
			
			lstAnswers = answerData.getItems();
			
			// ¼Ç¼id
			String initExerciseRecordId = answerData.getExerciseRecordId();
						
			if(lstAnswers.isEmpty() 
					&&  !ExerciseRecord.STATUS_SUBMIT.equals(answerData.getStatus())
					&& answerData.getSubmitType() != 1){
				
				exerciseVerService.doSaveExerciseDataSubmitLog(answers,
						initExerciseRecordId, ExerciseDataSubmitLog.TYPE_SUBMIT_ANSWER,
						ExerciseDataSubmitLog.STATUS_FAILED, "/exercise/Exercise/exerAnswers");
				
				return new Result(false,"Ìá½»Êý¾ÝÒì³£");
			}
				
			// 1.---------¼Ç¼Ìá½»µÄÊý¾ÝÈÕÖ¾
			// ¼Ç¼Ìá½»µÄÊý¾ÝÈÕÖ¾
			String exerciseDataLogId = exerciseVerService.doSaveExerciseDataSubmitLog(answers,
					initExerciseRecordId, ExerciseDataSubmitLog.TYPE_SUBMIT_ANSWER, 
					ExerciseDataSubmitLog.STATUS_SUCCESS,"/exercise/Exercise/exerAnswers");
			
			// 2.-------- Ìá½»´ð°¸
			// ²Ù×÷Á·Ï°Êý¾Ý
			Map<String,Object> resultMap = exerciseVerService.doOperExerciseAnswerData(answerData);
			
			result = new Result(true, "´ð°¸Ìá½»³É¹¦");
			result.setData(resultMap);
			
			// 3.-------- °à¼¶Í³¼ÆÊý¾Ý
			if(resultMap.get("exerciseGroupId") != null){
				
				String exerciseGroupId = String.valueOf(resultMap.get("exerciseGroupId"));
				
				// 2.·¢ËͰ༶ÅÅÃûÇëÇó
				exerciseVerService.sendUpdateClassRankMsg(exerciseGroupId);
				
				// 3.·¢ËÍ ÌâÄ¿µÄȫվͳ¼Æ ¡¢¸öÈËͳ¼Æ¡¢°à¼¶ÕýÈ·ÂÊÇëÇóÏûÏ¢
				exerciseVerService.sendUpdateExerItemStatisticsMsg(exerciseGroupId, answerData);
				//exerciseVerService.doStatisUserExerciseItemData(ClientUtils.getUserId(), ClientUtils.getUserName(), answerData);
			}
			
			// 4.---------¸üб¾´ÎÌá½»µÄÊý¾ÝÈÕÖ¾exerciseRecordId
			if(StringUtils.isBlank(initExerciseRecordId) 
					&& resultMap.get(EXERCISE_RECORD_ID) != null){// Ϊ¿Õ ˵Ã÷µÚÒ»´ÎÌá½»  ¸üÐÂÈÕÖ¾¼Ç¼id
				
				exerciseRecordId = String.valueOf(resultMap.get(EXERCISE_RECORD_ID));
				
				exerciseVerService.doUpdateExerciseDataSubmitLog(exerciseDataLogId, exerciseRecordId);
			}
			
		} catch (Exception e) {
			
			result = new Result(false, "Ìá½»Á·Ï°´ð°¸ÇëÇóÒì³£");
			log.error("Ìá½»Á·Ï°´ð°¸ÇëÇóÒì³£===",e);
			
			exerciseVerService.doSaveExerciseDataSubmitLog(answers,
					exerciseRecordId, ExerciseDataSubmitLog.TYPE_SUBMIT_ANSWER, 
					ExerciseDataSubmitLog.STATUS_FAILED, "/exercise/Exercise/exerAnswers");
		}
		
		return result;
	}
	
	
	/**
	 * APP2.0: Ìá½»Á·Ï°´ð°¸
	 * URL:    /exercise/Exercise/exerAnswers
	 * 
	 * ÇëÇó²ÎÊý=[{
	    "exerciseGroupId": ×éid, 
	    EXERCISE_RECORD_ID: ¼Ç¼id, 
	    "exerciseExtendId": null, 
	    "currTitleNum": "µ±Ç°ÌâºÅ", 
	    "status": ״̬,
	    "type": Á·Ï°ÀàÐÍ,// ÕûÐÍ
	    "doCount": Á·Ï°ÀàÐÍ,
	    "correctCount": ÕýÈ·¸öÊý, 
	    "allCount":ÌâÄ¿×ÜÊý,
	    "items": [
	        {
	            "exerciseId": "Á·Ï°id", 
	            "type": Á·Ï°ÀàÐÍ,// ÕûÊýÐÍ
	            "answer": "Ñ¡Ôñ´ð°¸", 
	            "correct": ÊÇ·ñÕýÈ·(0:´íÎó 1£ºÕýÈ· 2:δ֪)
	        }, 
	        {
	            "exerciseId": "Á·Ï°id", 
	            "type": Á·Ï°ÀàÐÍ, 
	            "answer": "Ñ¡Ôñ´ð°¸", 
	            "correct": ÊÇ·ñÕýÈ·(0:´íÎó 1£ºÕýÈ· 2:δ֪)
	        }
	    ]
		},
		   ...
		]
		
		·µ»Ø²ÎÊý={"success":true,//true:³É¹¦ false:ʧ°Ü
			"attrs":[{EXERCISE_RECORD_ID:Á·Ï°¼Ç¼id,
			exerciseGroupId:Á·Ï°×éid£¬
			isNewRecord£ºÊÇ·ñΪÐÂÔöµÄrecord(true:ÊÇ false:·ñ)
			"updateTime":ÐÞ¸Äʱ¼ä
			},...],
			"msg":"Ìá½»³É¹¦",//½á¹ûÐÅÏ¢
			}

	 * 
	 * @param answers
	 * @return
	 */
	@RequestMapping(value = "exerMutiAnswers", method = RequestMethod.POST)
	public @ResponseBody Object doSubmitMutiExerAnswer(
			@RequestParam(value = "answers")  String answers)  {
		
		// Óû§±¾´Î×öÌâÌá½»µÄÊý¾Ý
		List<ExerciseSubmitAnswerData> lstRecord = null;
		List<ExerciseItemAnswerData> lstAnswers= null;
		String exerciseRecordId = null;
		ExerciseSubmitAnswerData answerData = null;
		
		Map<String,Object> resultMap = new HashMap<String,Object>(2);
		Map<String,Object> returnMap = null;
		resultMap.put("success", false);
		resultMap.put("attrs", null);
		List<Map<String,Object>> resultList = null;
		try {
			ObjectMapper mapper = new ObjectMapper();
			
			// ×°»»jsonµ½¶ÔÏó
			ExerciseSubmitAnswerDataList answerDataList = mapper.readValue(answers, ExerciseSubmitAnswerDataList.class);
			
			lstRecord = answerDataList.getDatas();
			
			resultList = new ArrayList<Map<String,Object>>(lstRecord.size());
			for(int i=0; i<lstRecord.size(); i++){
				
				answerData = lstRecord.get(i);
				if(null == answerData){
					continue;
				}
				
				// ¼Ç¼id
				String initExerciseRecordId = answerData.getExerciseRecordId();
							
				// ¼Ç¼Ìá½»µÄÊý¾ÝÈÕÖ¾
				String recordData = JSONObject.toJSONString(answerData);
				
				lstAnswers = answerData.getItems();
						
				if(lstAnswers.isEmpty() 
						&& !ExerciseRecord.STATUS_SUBMIT.equals(answerData.getStatus())
						&& answerData.getSubmitType() != 1){// ½öÌá½» »ò½ö½ö±¾µØÎÞÍøÖØ×ö
					
					exerciseVerService.doSaveExerciseDataSubmitLog(recordData,
							initExerciseRecordId, ExerciseDataSubmitLog.TYPE_SUBMIT_ANSWER,
							ExerciseDataSubmitLog.STATUS_FAILED,"/exercise/Exercise/exerMutiAnswers");
					
					continue;
				}
				
				// 1.---------¼Ç¼Ìá½»µÄÊý¾ÝÈÕÖ¾
				String exerciseDataLogId = exerciseVerService.doSaveExerciseDataSubmitLog(recordData,
						initExerciseRecordId, ExerciseDataSubmitLog.TYPE_SUBMIT_ANSWER,
						ExerciseDataSubmitLog.STATUS_SUCCESS,"/exercise/Exercise/exerMutiAnswers");
				
				// 2.-------- Ìá½»´ð°¸
				// ²Ù×÷Á·Ï°Êý¾Ý
				returnMap = exerciseVerService.doOperExerciseAnswerData(answerData);
				if(StringUtils.isBlank(initExerciseRecordId)){// ±íʾrecordIdΪÐÂÔö
					returnMap.put("isNewRecord", true);
				}else{
					returnMap.put("isNewRecord", false);
				}
				
				resultList.add(returnMap);
				// 3.-------- °à¼¶Í³¼ÆÊý¾Ý;
				if(returnMap.get("exerciseGroupId") != null){
					
					String exerciseGroupId = String.valueOf(returnMap.get("exerciseGroupId"));
					
					// 2.·¢ËͰ༶ÅÅÃûÇëÇó
					exerciseVerService.sendUpdateClassRankMsg(exerciseGroupId);
					
					// 3.·¢ËÍ ÌâÄ¿µÄȫվͳ¼Æ  ¸öÈËͳ¼ÆÇëÇóÏûÏ¢
					exerciseVerService.sendUpdateExerItemStatisticsMsg(exerciseGroupId, answerData);
				}
				
				// 4.---------¸üб¾´ÎÌá½»µÄÊý¾ÝÈÕÖ¾exerciseRecordId
				if(StringUtils.isBlank(initExerciseRecordId) 
						&& returnMap.get(EXERCISE_RECORD_ID) != null){// Ϊ¿Õ ˵Ã÷µÚÒ»´ÎÌá½»  ¸üÐÂÈÕÖ¾¼Ç¼id
					
					exerciseRecordId = String.valueOf(returnMap.get(EXERCISE_RECORD_ID));
					
					exerciseVerService.doUpdateExerciseDataSubmitLog(exerciseDataLogId, exerciseRecordId);
				}
				
			}
			
			resultMap.put("success", true);
			resultMap.put("attrs", resultList);
			resultMap.put("msg", "Ìá½»³É¹¦");
			
		} catch (Exception e) {
			
			log.error("Ìá½»Á·Ï°´ð°¸ÇëÇóÒì³£===",e);
			resultMap.put("msg", "Ìá½»Á·Ï°´ð°¸ÇëÇóÒì³£");
			
			exerciseVerService.doSaveExerciseDataSubmitLog(answers,
					"exerMutiAnswers", ExerciseDataSubmitLog.TYPE_SUBMIT_ANSWER,
					ExerciseDataSubmitLog.STATUS_FAILED,"/exercise/Exercise/exerMutiAnswers");
		}
		
		return resultMap;
	}
	
	/**
	 * APP2.0: ¸üÐÂÁ·Ï°¼ÒÍ¥×÷Òµ¡¢Ä£Ä⿼ÊÔÊÇ·ñÌá½»
	 * URL:    /exercise/Exercise/updateHomeExerSubmitNew
	 * 
	 * @param exerciseRecordId     Á·Ï°¼Ç¼ID
	 * @return
	 */
	@RequestMapping(value = "updateHomeExerSubmitNew", method = RequestMethod.GET)
	public @ResponseBody Result doUpdateHomeExerSubmit(
			@RequestParam(value = EXERCISE_RECORD_ID) String exerciseRecordId)  {
		Result result = new Result(false);
		
		ExerciseRecord record = commonDAO.read(ExerciseRecord.class, exerciseRecordId);
		if(record == null 
				|| !ClientUtils.getUserId().equals(record.getUserId())){
			return new Result(false, "·Ç·¨²Ù×÷£¬²»Êǵ±Ç°Óû§²Ù×÷");
		}
		
		record.setStatus(ExerciseRecord.STATUS_SUBMIT);
		result = exerciseVerService.updateExerciseRecordObj(record);
		
		return result;
	} 
	
	/**
	 * APP2.0: ¸üÐÂÁ·Ï°¼ÒÍ¥×÷Òµ¡¢Ä£Ä⿼ÊÔÊÇ·ñÌá½»
	 * URL:    /exercise/Exercise/updateExerciseRecord
	 * 
	 * @param exerciseRecordId     Á·Ï°¼Ç¼ID
	 * @return
	 */
	@RequestMapping(value = "updateExerciseRecord", method = RequestMethod.GET)
	public @ResponseBody Result doUpdateExerciseRecord(
			@RequestParam(value = EXERCISE_RECORD_ID) String exerciseRecordId,
			@RequestParam(value = GROUP_ID)  String groupId,
			@RequestParam(value = "currTitleNum", required = false) String currTitleNum)  {
		
		Result result = exerciseVerService.doUpdateExerciseRecord(exerciseRecordId, groupId, currTitleNum);
		
		return result;
	} 
	
	/**
	 * APP2.0: ¸üÐÂÁ·Ï°×÷ÒµÌâºÅ app¶ËÖØпªÊ¼×öÌâ
	 * URL:    /exercise/Exercise/updateNewExerRecordNew
	 * 
	 * @param groupId         Ï°Ìâ×éID
	 * @return
	 */
	@RequestMapping(value = "updateNewExerRecordNew", method = RequestMethod.GET)
	public @ResponseBody Result doUpdateExerItemNumber(
			@RequestParam(value = GROUP_ID)  String groupId)  {
		
		Map<String,Object> map = exerciseVerService.doInsertExerRecord(groupId);

		Result result = new Result(true, "״̬¸üгɹ¦");
		result.setData(map);
		
		return result;
	} 
	
	/**
	 * APP2.0: ÌâÄ¿´ð°¸·ÖÎö
	 * URL:    /exercise/Exercise/itemstatisics
	 * 
	 * 
	 * 
	 * @param groupId         Ï°Ìâ×éID
	 * @return
	 */
	@RequestMapping(value = "itemStatisics", method = RequestMethod.GET)
	public @ResponseBody List<Map<String, Object>> doQueryExerciseItemStatisics(
			@RequestParam(value = GROUP_ID)  String groupId)  {
		
		// ²éѯ½á¹û
		List<Map<String, Object>> resultLst = exerciseVerService.queryExerciseItemStatisics(groupId);
		
		return resultLst;
	} 
	
	
	
	/** -----------------------------------------------APP V2.0½Ó¿Ú end--------------------------------------------------------*/
	
	
	/**------------------------------  web ºó¶Ë------------------------------------------------------------------------*/
	
	/**
	 * Á·Ï°¹ÜÀíÖ÷Ò³
	 * 
	 * @return
	 */
	@RequestMapping(method = RequestMethod.GET)
	public String listPage() {
		return "/exercise/Exercise";
	}
	
	/**
	 * »ú¹¹Á·Ï°¹ÜÀíÖ÷Ò³
	 * 
	 * @return
	 */
	@RequestMapping(value = "/org",method = RequestMethod.GET)
	public String listOrgPage() {
		return "/exercise/OrgExercise";
	}
	
	/**
	 * £¨ºǫ́¹ÜÀíϵͳ£©
	 * 
	 * Á·Ï°¹ÜÀíÁÐ±í£¬»ñÈ¡ÁбíÊý¾Ý
	 * 
	 * @return
	 */
	@RequestMapping(value = "list", method = RequestMethod.GET)
	public @ResponseBody List<ExerciseGroup> data(String tid, String classId) {
		classId = StringUtils.isEmpty(classId)?ClientUtils.getClassId():classId;
		
		String sql = " select g.ORIGIN_EXERCISE_ID as originExerciseId,g.NAME AS name ,g.GROUP_ID AS groupId,g.TYPE AS type,g.ORDER_NUM as orderNum,g.all_count as allCount,e.exercise_time as attribute1 "
				+ " from  exercise_group g left join exercise_group_extend e "
				+ " on g.group_id = e.group_id and e.delete_flag = 0  "
				+ " where g.delete_flag = 0 "
				+ " and g.type != ? "
				+ " and g.type != ? "
				+ " and g.type != ? "
				+ " and g.type != ? "
				+ " and g.type != ? "
				+ " and g.type != ? "
				+ " and g.class_id = ? ";
		if(StringUtils.isNotBlank(tid)){
			sql = sql.concat(" and g.subject_id = ? ");
		}
		sql = sql.concat(" order by g.order_num asc");
		
		//ÌÞ³ý»¥¶¯¼°½ÌѧÆÀ¹À
		List<ExerciseGroup> result = new ArrayList<ExerciseGroup>();
		if(StringUtils.isNotBlank(tid)){
			result = exerciseService.queryExerciceGroupList(sql, CollectionUtils.newList(ExerciseGroup.TYPE_EXERCISE_FREE,
					ExerciseGroup.TYPE_INTERACT,ExerciseGroup.TYPE_EXERCISE_TEACH_EVALUATE,ExerciseGroup.TYPE_EXERCISE_SEQUENCE,
					ExerciseGroup.TYPE_EXERCISE_RANDOM, ExerciseGroup.TYPE_CHAPTER_ITEM,classId,tid));
		}else{
			result = exerciseService.queryExerciceGroupList(sql, CollectionUtils.newList(ExerciseGroup.TYPE_EXERCISE_FREE,
					ExerciseGroup.TYPE_INTERACT,ExerciseGroup.TYPE_EXERCISE_TEACH_EVALUATE,ExerciseGroup.TYPE_EXERCISE_SEQUENCE,
					ExerciseGroup.TYPE_EXERCISE_RANDOM, ExerciseGroup.TYPE_CHAPTER_ITEM ,classId));
		}
		  
		for (ExerciseGroup exerciseGroup : result) {
			if(StringUtils.isNotBlank(exerciseGroup.getOriginExerciseId())){
				exerciseGroup.setEditFlag(false);
			}else{
				exerciseGroup.setEditFlag(true);
			}
			
		}
		return result;
	}
	
	/**
	 * £¨ºǫ́¹ÜÀíϵͳ£©
	 * 
	 * »ú¹¹Á·Ï°¹ÜÀíÁÐ±í£¬»ñÈ¡ÁбíÊý¾Ý
	 * 
	 * @return
	 */
	@RequestMapping(value = "orgList", method = RequestMethod.GET)
	public @ResponseBody List<Map<String,Object>> orgData(String collegeCourseId) {
		List<Map<String,Object>> list = new ArrayList<Map<String,Object>>();
		List<Object[]> result = new ArrayList<Object[]>();
		String hql = "select e,o.name,c.exerciseCourseId,c.orderNum 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 ";
		
		if(StringUtils.isNotBlank(collegeCourseId)){
			hql = hql.concat( " and c.collegeCourseId = ? order by c.orderNum asc ");
			result = commonDAO.findwithRawResult(hql, CollectionUtils.newList(ClientUtils.getOrgId(),collegeCourseId));
		}else{
			hql = hql.concat( " order by c.orderNum asc ");
			result = commonDAO.findwithRawResult(hql, CollectionUtils.newList(ClientUtils.getOrgId()));
		}
		
		for (Object[] objects : result) {
			ExerciseGroup group = (ExerciseGroup) objects[0];
			Map<String,Object> map = new HashMap<String, Object>();
			map.put("name", group.getName());
			map.put("typeName", group.getTypeName());
			map.put("allCount", group.getAllCount());
			map.put("attribute1", group.getAttribute1());
			map.put("type", group.getType());
			map.put(GROUP_ID, group.getGroupId());
			map.put("courseName", objects[1]);
			map.put("exerciseCourseId", objects[2]);
			map.put("orderNum", objects[3]);
			//findAlreadyOrg(group,map);
			map.put("meFlag", ClientUtils.getOrgId().equals(group.getOrgId()));
			list.add(map);
			
		}
		
		return list;
	}
	
	/**
	 * ²é¿´Á·Ï°ÒѾ­Ö¸¶¨µÄ»ú¹¹ºÍ°à¼¶
	 * @param groupId
	 * @return
	 */
	@RequestMapping(value = "/exerOrgIds", method = RequestMethod.GET)
	public @ResponseBody Result findAlreadyOrg(String groupId){
		Map<String,Object> map = new HashMap<String, Object>();
		String hql = " select r from ExerciseReCourse c,Organization r"
				+ " where c.orgId = r.organizationId"
				+ " and c.deleteFlag is false"
				+ " and r.deleteFlag is false"
				+ " and c.groupId = ?";
		List<Organization> lstOrg = commonDAO.find(hql, CollectionUtils.newList(groupId), Organization.class);
		//StringBuffer sbName = new StringBuffer();
		StringBuffer sbId = new StringBuffer();
		List<String> classIds = new ArrayList<String>();
		//String orgNames = "";
		String orgIds = "";
		for (Organization org : lstOrg) {
			//sbName.append(org.getName()+",");
			sbId.append(org.getOrganizationId()).append(',');
		}
		
		if(classIds.isEmpty()){
			map.put("classIds", "");
		}else{
			hql = "select distinct classId from ExerciseGroup where classId in (:classIds) and deleteFlag is false and originExerciseId = :groupId";
			Map<String,Object> args = new HashMap<String,Object>();
			
			args.put("classIds", classIds.toArray());
			
			
			args.put(GROUP_ID, groupId);
			List<String> objs = commonDAO.findByComplexHql(hql, args, String.class);
			map.put("classIds", StringUtils.join(objs.toArray(), ","));
		}
		
		/*if(sbName.length()>0){
			orgNames = sbName.deleteCharAt(sbName.length()-1).toString();
		}*/
		if(sbId.length()>0){
			orgIds = sbId.deleteCharAt(sbId.length()-1).toString();
		}
		//map.put("orgNames", orgNames);
		map.put("orgIds", orgIds);
		Result result = new Result(true);
		result.setData(map);
		return result;
	}
	/**
	 * »ñÈ¡Á·Ï°×éÊý¾Ý
	 * 
	 * @return
	 */
	@RequestMapping(value = "group/{groupId}", method = RequestMethod.GET)
	public @ResponseBody ExerciseGroup readGroup(@PathVariable String groupId) {
		
		String hql = "from ExerciseGroup where groupId=? and deleteFlag is false";
		
		ExerciseGroup group = commonDAO.findUnique(hql, CollectionUtils.newList(groupId), ExerciseGroup.class);
		
		group.setItems(null);
		
		return group;
	}
	
	/**
	 * »ñÈ¡Á·Ï°Êý¾Ý
	 * 
	 * @return
	 */
	@RequestMapping(value = "item/{exerciseId}", method = RequestMethod.GET)
	public @ResponseBody ExerciseItem readExerciseItem(@PathVariable String exerciseId) {
		
		String hql = "from ExerciseItem where exerciseId=? and deleteFlag is false";
		
		ExerciseItem item = commonDAO.findUnique(hql, CollectionUtils.newList(exerciseId), ExerciseItem.class);
		
		return item;
	}
	
	/**
	 * »ñÈ¡Á·Ï°Êý¾Ý
	 * 
	 * @return
	 */
	@RequestMapping(value = "itemNew/{exerciseId}", method = RequestMethod.GET)
	public @ResponseBody ExerciseItem readExerciseItem(@PathVariable String exerciseId,String groupId) {
		
		String hql = "from ExerciseItem where exerciseId=? and deleteFlag is false";
		
		ExerciseItem item = commonDAO.findUnique(hql, CollectionUtils.newList(exerciseId), ExerciseItem.class);
		
		String hqlForNo = "select itemOrder from ExerciseGroupItemRe where exerciseItemId=? and exerciseGroupId=?";
		
		Integer itemOrder = commonDAO.findUnique(hqlForNo, CollectionUtils.newList(exerciseId,groupId), Integer.class);
		
		if(null != itemOrder){
			item.setItemNo(itemOrder);
		}
		
		return item;
	}
	
	@RequestMapping(value = "checkDeleteNew", method = RequestMethod.POST)
	@ResponseBody
	public boolean checkDeleteNew(String groupId){
		
		String[] arrId = groupId.split(",");
		StringBuffer replaceCode = new StringBuffer(1024);
		replaceCode.append(" ( ");
		List<Object> lstArgs = new ArrayList<Object>(arrId.length);
		for(int i = 0; i < arrId.length ; i++ ){
			lstArgs.add(arrId[i]);
			if( i == arrId.length - 1 ){
				replaceCode.append( " ? ) ") ;
			}else{
				replaceCode.append(" ? ,  ") ;
			}
		}
		
		String hql = "select count(1) from ExerciseItemAnswerU u where deleteFlag is false and  exerciseItemId in " +
				"( select i.exerciseId from ExerciseGroup g,ExerciseItem i,ExerciseGroupItemRe r where g.groupId=r.exerciseGroupId " +
				" and i.exerciseId = r.exerciseItemId and g.groupId in " + replaceCode.toString() + " and  g.deleteFlag is false and  i.deleteFlag is false ) ";
		
		int iCount = commonDAO.findCount(hql, lstArgs);
		
		return iCount > 0 ? true : false;
		
	}
	
	
	/**
	 * £¨ºǫ́¹ÜÀíϵͳ£©
	 * ɾ³ýÁ·Ï°×é(ÓÅ»¯)
	 * 
	 * ¸üÐÂ20150907£º¸üÐÂÏ°Ìâ×é×îºóÐÞ¸Äʱ¼ä
	 * @return
	 */
	@RequestMapping(value = "deleteNew", method = RequestMethod.POST)
	@ResponseBody
	public Result deleteNew(String groupId,String type) {
		
		return exerciseService.deleteExerciseGroup(groupId,type,"class",null,null,null);
	}
	
	/**
	 * £¨ºǫ́¹ÜÀíϵͳ£©
	 * ɾ³ýÁ·Ï°×é(ÓÅ»¯)
	 * 
	 * ¸üÐÂ20150907£º¸üÐÂÏ°Ìâ×é×îºóÐÞ¸Äʱ¼ä
	 * @return
	 */
	@RequestMapping(value = "deleteOrg", method = RequestMethod.POST)
	@ResponseBody
	public Result deleteOrg(String groupId,String type,Integer delAll, String orgIds[], String classIds[]) {
		
		return exerciseService.deleteExerciseGroup(groupId,type,"org",delAll,orgIds,classIds);
	}
	
	
	
	/**
	 * »ñÈ¡Ï°ÌâÁбí
	 * 
	 * @return
	 */
	@RequestMapping(value = "item/data/{groupId}", method = RequestMethod.GET)
	@ResponseBody
	public List<ExerciseItem> listItems(@PathVariable String groupId) {


		List<ExerciseItem> items =  exerciseService.readExerciseItemsWithNo(groupId);
		
		return items;
	}
	
	/**
	 * £¨ºǫ́¹ÜÀíϵͳ£©
	 *  ¹ÜÀíԱͬ²½Ï°Ìâµ½°à¼¶
	 * 
	 * @param exerciseItemId
	 * @return
	 * @throws InvocationTargetException 
	 * @throws IllegalAccessException 
	 */
	@RequestMapping(value = "/item/synExercise", method = RequestMethod.POST)
	@ResponseBody
	public Result synExercise(String[] exerciseIds) throws IllegalAccessException, InvocationTargetException {
		return exerciseService.doSynExercise(exerciseIds);
	}
	
	/**
	 * £¨ºǫ́¹ÜÀíϵͳ£©
	 * Ôö¼ÓÏ°Ìâ
	 * 
	 * ¸üÐÂ20150617£º¸üÐÂÏ°Ìâ×é×îºóÐÞ¸Äʱ¼ä
	 * @return
	 */
	@RequestMapping(value = "item/addOrUpdate", method = RequestMethod.POST)
	@ResponseBody
	public Result addOrUpdateItem(ExerciseAddItemParams params) {
		
			String groupId = params.getGroupId();
			
			short type = params.getType();
			boolean checkA = params.getCheckA();
			boolean checkB = params.getCheckB();
			boolean checkC = params.getCheckC();
			boolean checkD = params.getCheckD();
			boolean checkE = params.getCheckE();
			boolean checkF = params.getCheckF();
			boolean checkG = params.getCheckG();
			boolean checkH = params.getCheckH();
			boolean checkI = params.getCheckI();
			boolean checkJ = params.getCheckJ();
			boolean checkK = params.getCheckK();
			boolean checkL = params.getCheckL();
			boolean checkM = params.getCheckM();
			boolean checkN = params.getCheckN();
			boolean checkO = params.getCheckO();
			
			List<ExerciseItemOption> lstOptions = new ArrayList<ExerciseItemOption>(8);
			createItemOption(getOptionOrder(type,'A'),params.getOptionA(), checkA, params.getOptionA_Id(), params.getOptionA_imgIds(), lstOptions);
			createItemOption(getOptionOrder(type,'B'),params.getOptionB(), checkB, params.getOptionB_Id(), params.getOptionB_imgIds(), lstOptions);
			createItemOption(getOptionOrder(type,'C'),params.getOptionC(), checkC, params.getOptionC_Id(), params.getOptionC_imgIds(), lstOptions);
			createItemOption(getOptionOrder(type,'D'),params.getOptionD(), checkD, params.getOptionD_Id(), params.getOptionD_imgIds(), lstOptions);
			createItemOption(getOptionOrder(type,'E'),params.getOptionE(), checkE, params.getOptionE_Id(), params.getOptionE_imgIds(), lstOptions);
			createItemOption(getOptionOrder(type,'F'),params.getOptionF(), checkF, params.getOptionF_Id(), params.getOptionF_imgIds(), lstOptions);
			createItemOption(getOptionOrder(type,'G'),params.getOptionG(), checkG, params.getOptionG_Id(), params.getOptionG_imgIds(), lstOptions);
			createItemOption(getOptionOrder(type,'H'),params.getOptionH(), checkH, params.getOptionH_Id(), params.getOptionH_imgIds(), lstOptions);
			createItemOption(getOptionOrder(type,'I'),params.getOptionI(), checkI, params.getOptionI_Id(), params.getOptionI_imgIds(), lstOptions);
			createItemOption(getOptionOrder(type,'J'),params.getOptionJ(), checkJ, params.getOptionJ_Id(), params.getOptionJ_imgIds(), lstOptions);
			createItemOption(getOptionOrder(type,'K'),params.getOptionK(), checkK, params.getOptionK_Id(), params.getOptionK_imgIds(), lstOptions);
			createItemOption(getOptionOrder(type,'L'),params.getOptionL(), checkL, params.getOptionL_Id(), params.getOptionL_imgIds(), lstOptions);
			createItemOption(getOptionOrder(type,'M'),params.getOptionM(), checkM, params.getOptionM_Id(), params.getOptionM_imgIds(), lstOptions);
			createItemOption(getOptionOrder(type,'N'),params.getOptionN(), checkN, params.getOptionN_Id(), params.getOptionN_imgIds(), lstOptions);
			createItemOption(getOptionOrder(type,'O'),params.getOptionO(), checkO, params.getOptionO_Id(), params.getOptionO_imgIds(), lstOptions);
			
			// µÃµ½ÕýÈ·´ð°¸
			if(StringUtils.isBlank(params.getOptionE())){
				checkE=false;
			}
			if(StringUtils.isBlank(params.getOptionF())){
				checkF=false;
			}
			
			String answer = getCorrectAnswer(params, type);
			
			if(StringUtils.isEmpty(params.getExerciseId())){
				ExerciseItem item = new ExerciseItem();
				item.setAnswer(answer);
				item.setTitle(params.getTitle());
				item.setType(type);
				item.setImgs(getExerciseTitleImgs(params.getTitle_imgsIds()));
				if(groupId.contains("#")){// groupid½áβ¶à#
					groupId = groupId.substring(0, groupId.indexOf('#'));
				}
				// Á·Ï°²»·¢ÏµÍ³Í¨Öª
				//sendSysNotice(0, groupId);
				return exerciseService.insertExerciseItem(groupId, item, lstOptions,params.getAnalysis());	
			}else{
				ExerciseItem item = this.commonDAO.read(ExerciseItem.class, params.getExerciseId());
				item.setAnswer(answer);
				item.setTitle(params.getTitle());
				item.setType(type);
				// Á·Ï°²»·¢ÏµÍ³Í¨Öª
				//sendSysNotice(1, groupId);
				return exerciseService.updateExerciseItem(item, lstOptions,params.getAnalysis());	
			}
			
	}
	
	
	/**
	 * µÃµ½ÕýÈ·´ð°¸
	 * @param checkA
	 * @param checkB
	 * @param checkC
	 * @param checkD
	 * @param checkE
	 * @param checkF
	 * @return
	 */
	private String getCorrectAnswer(ExerciseAddItemParams params,short type){
		StringBuffer answer = new StringBuffer(64);
		
		if(ExerciseItem.TYPE_TRUE_OR_FALSE==type){//ÅжÏ
			return params.getCheckA()?"True":params.getCheckB()?"False":null;
		}
		
		if(params.getCheckA()){
			answer.append('A');
		}
		if(params.getCheckB()){
			answer.append(',').append('B');
		}
		
		// ×é×°ÓàÏÂÕýÈ·´ð°¸
		packagingCorrectAnswer(params, answer);
		
		String answers = answer.toString();
		
		if(answers.indexOf(',') == 0){
			answers = answers.substring(1, answers.length());
		}
		
		return answers;
	}

	/**
	 * ×é×°ÕýÈ·´ð°¸
	 * @param checkC
	 * @param checkD
	 * @param checkE
	 * @param checkF
	 * @param answer
	 */
	private void packagingCorrectAnswer(ExerciseAddItemParams params, StringBuffer answer) {
		if(params.getCheckC()){
			answer.append(',').append('C');
		}
		if(params.getCheckD()){
			answer.append(',').append('D');
		}
		if(params.getCheckE()){
			answer.append(',').append('E');
		}
		if(params.getCheckF()){
			answer.append(',').append('F');
		}
		if(params.getCheckG()){
			answer.append(',').append('G');
		}
		if(params.getCheckH()){
			answer.append(',').append('H');
		}
		packagingCorrectAnswerFirst(params, answer);
	}
	
	/**
	 * ×é×°ÕýÈ·´ð°¸
	 * @param checkC
	 * @param checkD
	 * @param checkE
	 * @param checkF
	 * @param answer
	 */
	private void packagingCorrectAnswerFirst(ExerciseAddItemParams params, StringBuffer answer) {
		if(params.getCheckI()){
			answer.append(',').append('I');
		}
		if(params.getCheckJ()){
			answer.append(',').append('J');
		}
		if(params.getCheckK()){
			answer.append(',').append('K');
		}
		if(params.getCheckL()){
			answer.append(',').append('L');
		}
		if(params.getCheckM()){
			answer.append(',').append('M');
		}
		if(params.getCheckN()){
			answer.append(',').append('N');
		}
		if(params.getCheckO()){
			answer.append(',').append('O');
		}
	}
	
	/**
	 * µÃµ½Á·Ï°ÌâĿͼƬlist
	 * @param title_imgsIds
	 * @return
	 */
	private List<ExerciseObjectImg> getExerciseTitleImgs(String title_imgsIds){
		if(StringUtils.isBlank(title_imgsIds)){//ÐÂÔöͼƬ
			return null;
		}
		String[] strImgsId = title_imgsIds.split(",");
		List<ExerciseObjectImg> imgs = new ArrayList<ExerciseObjectImg>(strImgsId.length);
		ExerciseObjectImg objImg = null;
		for(String imgId:strImgsId){
			objImg = new ExerciseObjectImg();
			objImg.setImgId(imgId);
			imgs.add(objImg);
		}
		return imgs;
	}
	
	/**
	 * ´´½¨Ï°ÌâÑ¡Ïî
	 * @param option
	 * @param check
	 * @param lstOptions
	 */
	private void createItemOption(String optionOrder,String option_t, boolean check, String optionId,
			String imgsId, List<ExerciseItemOption> lstOptions) {
		String option = option_t;
		
		if("True".equals(optionOrder) || "False".equals(optionOrder)){
			option = optionOrder;
		}
		
		ExerciseItemOption a = new ExerciseItemOption();
		if(StringUtils.isNotBlank(optionId)){// ¸üÐÂ
			a.setOptionId(optionId);
		}else{
			if(StringUtils.isEmpty(option)){
				return;
			}
		}
		
		if(StringUtils.isNotBlank(imgsId)){//ÐÂÔöͼƬ
			String[] strImgsId = imgsId.split(",");
			List<ExerciseObjectImg> imgs = new ArrayList<ExerciseObjectImg>(strImgsId.length);
			ExerciseObjectImg objImg = null;
			for(String imgId:strImgsId){
				objImg = new ExerciseObjectImg();
				objImg.setImgId(imgId);
				imgs.add(objImg);
			}
			a.setImgs(imgs);
		}
		a.setChecked(check);
		a.setContent(option);
		a.setOptionOrder(optionOrder);
		lstOptions.add(a);
	}
	
	
	private String getOptionOrder(short type,char order){
		
		if(ExerciseItem.TYPE_TRUE_OR_FALSE==type){
			return order=='A'?"True":order=='B'?"False":null;
		}else{
			return String.valueOf(order);
		}
		
	}
	
	/**
	 * ¸üÐÂÏ°Ìâ
	 * 
	 * @return
	 */
	@RequestMapping(value = "item/update", method = RequestMethod.POST)
	@ResponseBody
	public Result updateItem(ExerciseItem item) {
		return null;
	}
	
	/**
	 * £¨ºǫ́¹ÜÀí£©
	 * ɾ³ýÏ°Ìâ
	 * ¸üÐÂ20150617£º¸üÐÂÏ°Ìâ×é×îºóÐÞ¸Äʱ¼ä
	 * 
	 * @return
	 */
	@RequestMapping(value = "item/delete", method = RequestMethod.POST)
	@ResponseBody
	public Result delItem(String exerciseIds,String reIds,String groupId) {
		return exerciseService.deleteExerciseItems(exerciseIds.split(","),reIds.split(","),groupId);
	}
	
	/**
	 * ¸ù¾ÝclassID»ñÈ¡ËùÓпγÌ
	 * 
	 * @return
	 */ 
	@RequestMapping(value = "listLesson", method = RequestMethod.POST)
	public @ResponseBody List<SchClassSubject> getLessionList() {
		
		String hql = "from SchClassSubject where classId = ? and deleteFlag is false ";
		
		List<SchClassSubject> result = commonDAO.find(hql, CollectionUtils.newList(ClientUtils.getClassId()), SchClassSubject.class);
		
		return result;
	}
	
	/**
	 * »ñÈ¡×éÃû³Æ
	 * 
	 * @return
	 */ 
	@RequestMapping(value = "getGroupName", method = RequestMethod.POST)
	public @ResponseBody List<Map<String,Object>> getGroupName(String groupId) {

		ExerciseGroup group = commonDAO.read(ExerciseGroup.class, groupId);
		List<Map<String,Object>> lstMap = new ArrayList<Map<String,Object>>(1);
		Map<String,Object> map = null;
		
		if(group.getType() == ExerciseGroup.TYPE_CHAPTER_ITEM || group.getType() == ExerciseGroup.TYPE_EXERCISE_TOPIC || group.getType() == ExerciseGroup.TYPE_EXERCISE_EXAM){ // Õ½ÚÁ·Ï° ¡¢ רÏîÁ·Ï°
			map = new HashMap<String, Object>(7);
			map.put("groupId", group.getGroupId());
			map.put("name", group.getName());
			map.put("type", group.getType());
			map.put("subjectId", group.getSubjectId());
			map.put("chapterId", group.getAttribute2());
			lstMap.add(map);
			return lstMap;
		}
		String hql = "select e,eg from ExerciseGroup e,ExerciseGroupExtend eg "
				+ "where e.deleteFlag is false and eg.deleteFlag is false "
				+ "and e.groupId = eg.groupId and e.groupId = ? ";
		List<Object[]> result = this.commonDAO.findwithRawResult(hql, CollectionUtils.newList(groupId));
		
		for (Object[] obj : result) {
			group = (ExerciseGroup) obj[0];
			ExerciseGroupExtend groupExtend = (ExerciseGroupExtend) obj[1];
			map = new HashMap<String, Object>(7);
			map.put("groupId", group.getGroupId());
			map.put("name", group.getName());
			map.put("type", group.getType());
			map.put("subjectId", group.getSubjectId());
			
			map.put("exerciseTime", groupExtend.getExerciseTime());
			map.put("repeatFlag", groupExtend.getRepeatFlag());
			lstMap.add(map);
			
		}
		return lstMap;
	}
	
	/**
	 * ±à¼­Á·Ï°±£´æ
	 * 
	 * @return
	 */ 
	@RequestMapping(value = "editGroup", method = RequestMethod.POST)
	public @ResponseBody Result saveEditGroup(String groupId,String groupName) {
		
		return exerciseService.doSaveEditGroup(groupId, groupName);
	}
	
	/**
	 * ¸ù¾ÝlessionId»ñÈ¡ËùÓÐÕ½Ú,Åųýµôµ±Ç°°à¼¶
	 * 
	 * @return
	 */ 
	@RequestMapping(value = "listChapter", method = RequestMethod.POST)
	public @ResponseBody List<ExerciseChapter> getChapterList(
			@RequestParam(value = "classSubjectId") String classSubjectId, short type) {
		
		String hql = "from ExerciseChapter where classSubjectId = ? and deleteFlag is false ";
		List<Object> lstArgs = CollectionUtils.newList(classSubjectId);
		if(ExerciseGroup.TYPE_EXERCISE_SEQUENCE == type){
			hql = " from ExerciseChapter where classSubjectId = ? and deleteFlag is false and chapterId not in  " 
				+ " ( select attribute2  from ExerciseGroup where deleteFlag is false and classId = ? and attribute1 = ? ) ";
			lstArgs = CollectionUtils.newList(classSubjectId,ClientUtils.getClassId(),classSubjectId);
		}
		
		List<ExerciseChapter> result = commonDAO.find(hql, lstArgs , ExerciseChapter.class);
		
		return result;
	}
	
	/**
	 * ¸ù¾ÝclassID»ñȡ˳ÐòÁ·Ï°
	 * 
	 * @return
	 */ 
	@RequestMapping(value = "listOrderExercise", method = RequestMethod.POST)
	public @ResponseBody List<ClsClass> getOrderExerciseCount() {
		
		String hql = "from ExerciseGroup where classId = ? and type = ? and deleteFlag is false";
		
		int result = commonDAO.findCount(hql, CollectionUtils.newList(ClientUtils.getClassId(),ExerciseGroup.TYPE_EXERCISE_SEQUENCE));
		List<ClsClass> lstResult = new ArrayList<ClsClass>();
		//´æÔÚ˳ÐòÁ·Ï°£¬½«°à¼¶ÐÅÏ¢´«»Ø
		if( result > 0){
			hql = "from ClsClass where classId = ? ";
			lstResult = commonDAO.find(hql, CollectionUtils.newList(ClientUtils.getClassId()), ClsClass.class);
		}
		
		return lstResult;
	}
	
	/**
	 * ¸ù¾ÝclassID»ñȡ˳ÐòÁ·Ï°
	 * 
	 * @return
	 */ 
	@RequestMapping(value = "checkChapterRepetition", method = RequestMethod.POST)
	public @ResponseBody String checkChapterRepetition(
		    @RequestParam(value = "classSubjectId") String classSubjectId,
		    @RequestParam(value = "chapterId") String chapterId) {
		
		String hql = "from ExerciseGroup where classId = ? and type = ? and attribute1 = ? and attribute2 = ? and deleteFlag is false ";
		int result = commonDAO.findCount(hql, CollectionUtils.newList(ClientUtils.getClassId(),ExerciseGroup.TYPE_CHAPTER_ITEM,classSubjectId,chapterId));
		
		return result > 0 ?  "1" : "0";
	}
	
	/**
	 * ÐÂÔöÁ·Ï°
	 * 
	 * @return
	 */
	@RequestMapping(value = "addExercise", method = RequestMethod.POST)
	public @ResponseBody
	Result addExercise(String groupId,String name,short type,String subjectId,String chapterId,String attribute1,boolean repeatFlag) {
		return exerciseService.insertExerciseGroup(groupId,name,type,subjectId,chapterId,attribute1,repeatFlag);
	}
	
	/**
	 * »ú¹¹ÐÂÔöÁ·Ï°
	 * 
	 * @return
	 */
	@RequestMapping(value = "addOrgExercise", method = RequestMethod.POST)
	public @ResponseBody
	Result addOrgExercise(ExerciseGroup group, boolean repeatFlag) {
		return exerciseService.insertOrgExercise(group,repeatFlag);
	}
	
	/**
	 * »ú¹¹Ö¸¶¨Á·Ï°
	 * 
	 * @return
	 */
	@RequestMapping(value = "OrgExercise", method = RequestMethod.POST)
	public @ResponseBody
	Result addOrgExercise(String groupId [],String orgId[],String classIds[]) {
		return exerciseService.insertAppointExercise(groupId,orgId,classIds);
	}
	
	/**
	 * ORG »ñÈ¡»ú¹¹¿ÆÄ¿Áбí
	 * 
	 * @return
	 */
	@RequestMapping(value = "/orgCourse", method = RequestMethod.GET)
	public @ResponseBody
	List<OrgCollegeCourse> orgCollegeCourse() {

		String hql = " from OrgCollegeCourse where topOrgId = ? and deleteFlag is false";
		
		Organization org = commonDAO.read(Organization.class, ClientUtils.getOrgId());
		
		List<OrgCollegeCourse> result = this.commonDAO.find(hql, CollectionUtils.newList(org.getTopOrganizationId()), OrgCollegeCourse.class);
		
		return result;

	}
	
	/**
	 * ÐÂÔöͼƬ·¾¶µ½Êý¾Ý¿â
	 * @param fullPaths
	 * @param imgObjId
	 * @param imgObjType
	 * @return
	 */
	@RequestMapping(value = "addExerObjImg",method = RequestMethod.POST)
	public @ResponseBody List<Map<String,Object>> doAddExerciseObjImg(
			@RequestParam("fullPaths") String fullPaths,
			@RequestParam("imgObjId") String imgObjId,
			@RequestParam("imgObjType") int imgObjType){
		
		if(StringUtils.isBlank(fullPaths)){
			return null;
		}
		String[] imgPaths = fullPaths.split(";");
		
		// ¸üз¾¶µ½Êý¾Ý¿â
		List<Map<String,Object>> lstResult = exerciseService.doAddExerciseObjImg(imgPaths, imgObjId, imgObjType);
		
		return lstResult;
	}
	
	/** ÐÂÔöͼƬ·¾¶µ½Êý¾Ý¿â */
	@RequestMapping(value = "delExerObjImg",method = RequestMethod.POST)
	public @ResponseBody Result dodelExerciseObjImg(
			@RequestParam("imgId") String imgId){
		
		Result result = exerciseService.dodelExerciseObjImg(imgId);
		
		return result;
	}
	
	/** ²éѯͼƬ·¾¶ */
	@RequestMapping(value = "queryExerObjImg",method = RequestMethod.POST)
	public @ResponseBody List<Map<String,Object>> doQueryExerciseObjImg(
			@RequestParam("imgObjId") String imgObjId,
			@RequestParam("imgObjType") int imgObjType){
		if(StringUtils.isBlank(imgObjId)){
			return null;
		}
		String hql = "from ExerciseObjectImg where deleteFlag is false and exerciseObjectId=? and objectType=? order by imgOrder";
		// ²éѯ´ËÁ·Ï°ÊÇ·ñÒѾ­´æÔڼǼ
		List<ExerciseObjectImg> lstObjImg = commonDAO.find(hql,
				CollectionUtils.newList(imgObjId,imgObjType), ExerciseObjectImg.class);
		
		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 groupId Ï°Ìâ×éID
	 * @param uuid uuid
	 * @param fileName ÎļþÃû³Æ
	 * @return
	 */
	@RequestMapping(value = "/item/deepAnalysisDoc", method = RequestMethod.POST)
	@ResponseBody
	public Result deepAnalysisDoc(String groupId,String fullPath) {
		
		return exerciseService.doDeepAnalysisDoc(groupId,fullPath);
		
	}
	
	
	/**
	 * £¨ºǫ́¹ÜÀíϵͳ:µ¼ÈëÏ°ÌâÄ£¿é£©
	 *  µ¼ÈëÏ°Ìâ-µÚÒ»´Î½«word½âÎö½á¹û·µ»Ø¸øǰ̨£¬²¢²»±£´æµ½Êý¾Ý¿â
	 *  
	 * @param groupId Ï°Ìâ×éID
	 * @param uuid uuid
	 * @param fileName ÎļþÃû³Æ
	 * @return
	 */
	@RequestMapping(value = "/item/import/parser/{groupId}", method = RequestMethod.POST)
	@ResponseBody
	public ExerciseParseResult importItemsNew(@PathVariable String groupId,String fullPath,String module) {
		
		return exerciseService.doParseItems(groupId, fullPath , module);
		
	}
	
	/**
	 * £¨ºǫ́¹ÜÀíϵͳ:µ¼ÈëÏ°ÌâÄ£¿é£©
	 *  УÑéÄÚÈÝ£¬·µ»Ø½âÎö½á¹û
	 * 
	 * @param content Îı¾ÄÚÈÝ
	 * @return
	 */
	@RequestMapping(value = "/item/import/validateExercise", method = RequestMethod.POST)
	@ResponseBody
	public ExerciseParseResult validateExercise(String content) {
		
		return exerciseService.validateExercise(content);
	}
	
	/**
	 * »ñÈ¡ËùÓа༶£¬µ±Ç°°à¼¶³ýÍâ,Ôö¼Ó¹ýÂËûÓÐÏ°ÌâµÄ°à¼¶
	 * @return
	 */
	@RequestMapping(value = "loadClasses", method = RequestMethod.GET)
	public @ResponseBody List<ClsClass> loadClasses() {
		
		String hql = "select distinct cls from ClsClass cls,OrgCharger charge, ExerciseGroup g " +
				" where cls.classChargerId = charge.orgChargerId " +
				" and cls.classId = g.classId " +
				" and g.deleteFlag is false " +
				" and g.type != ? " +
				" and g.type != ? " +
				" and g.type != ? " +
				" and g.type != ? " +
				" and charge.userId = ? " +
				" and cls.classId <> ? " +
				" and charge.orgId = ? " +
				" and cls.deleteFlag is false";
		
		return commonDAO.find(hql, CollectionUtils.newList(
				ExerciseGroup.TYPE_EXERCISE_RANDOM,ExerciseGroup.TYPE_EXERCISE_SEQUENCE,
				ExerciseGroup.TYPE_INTERACT,ExerciseGroup.TYPE_EXERCISE_TEACH_EVALUATE,
				ClientUtils.getUserId(),ClientUtils.getClassId(),ClientUtils.getOrgId()), ClsClass.class);
	}
	
	/**
	 * ¸´ÖÆÏ°Ìâ
	 * @param fromClassId
	 * @return
	 */
	@RequestMapping(value = "copyExercise", method = RequestMethod.POST)
	public @ResponseBody Result copyExercise(String groupId, String subjectId, String subjectName, String chapterId) {
		
		return exerciseService.executeCopyExercise(groupId, subjectId, subjectName, chapterId);

	}
	
	/**
	 * ѧԱµÃ·ÖÏêÇéÁбí
	 * @param groupId
	 * @return
	 */
	@RequestMapping(value = "resultList/{groupId}", method = RequestMethod.GET)
	public @ResponseBody List<Map<String, Object>> resultList(@PathVariable String groupId) {
		
		List<Map<String, Object>> lstMap = exerciseService.resultList(groupId);
		
		return lstMap;

	}
	
	/**
	 * ³õʼ»¯Æ½¾ù³É¼¨ºÍ×î¸ß³É¼¨
	 * @param groupId
	 * @return
	 */
	@RequestMapping(value = "initScore/{groupId}", method = RequestMethod.GET)
	public @ResponseBody Map<String, Object> initScore(@PathVariable String groupId) {
		
		Map<String, Object> map = exerciseService.initScore(groupId);
		
		return map;
	}
	
	/**
	 * ÿµÀÌâµÃ·ÖÏêÇé
	 * @param groupId
	 * @return
	 */
	@RequestMapping(value = "itemDetailList/{groupId}", method = RequestMethod.GET)
	public @ResponseBody List<ExerciseItemStatistics> scoreDetail(@PathVariable String groupId) {
		
		List<ExerciseItemStatistics> itemStatisLst = exerciseService.itemDetailList(groupId);
		
		return itemStatisLst;
	}
	
	/**
	 * ¼ÓÔØÌâÄ¿Ñ¡ÏîÏêÇé - °à¼¶¡¢»ú¹¹
	 * @param groupId
	 * @return
	 */
	@RequestMapping(value = "loadOptionsList", method = RequestMethod.GET)
	public @ResponseBody List<Map<String,Object>> loadOptionsList( String exerciseItemId) {
		
		List<Map<String,Object>> map = exerciseService.loadOptionsList(exerciseItemId);
		
		return map;
	}
	
	/**
	 * ˢиüÐÂͳ¼Æ
	 * @param groupId
	 * @return
	 */
	@RequestMapping(value = "refreshStatistical/{groupId}", method = RequestMethod.GET)
	public @ResponseBody Result refreshStatistical(@PathVariable String groupId) {
		
		Result result = exerciseVerService.updateRefreshStatistical(groupId,ClientUtils.getOrgId() ,ClientUtils.getClassId(),Constants.BOOLEAN_FLAG_FALSE);
		
		return result;
	}
	
	/**
	 * µ¼³öÁ·Ï°Ã¿µÀÌâµÃ·ÖÏêÇé
	 * 
	 * @return
	 * @throws IOException 
	 */
	@RequestMapping(value = "itemStatis/data/{groupId}", method = RequestMethod.GET)
	public String exportItemStatis(@PathVariable String groupId,HttpServletResponse response) throws IOException {
		ExerciseGroup exeGroup= this.commonDAO.read(ExerciseGroup.class, groupId);
		
		//»ñȡÿµÀÌâµÃ·ÖÏêÇéÁбí
		List<ExerciseItemStatistics> itemStatisLst = exerciseService.itemDetailList(groupId);
		
		ExcelExportUtils<ExerciseItemStatistics> ex = new ExcelExportUtils<ExerciseItemStatistics>();
		ExcelExportParam<ExerciseItemStatistics> obj = new ExcelExportParam<ExerciseItemStatistics>();
		obj.setColData(itemStatisLst);
		String[] headers = { "ÐòºÅ","ÌâºÅ","ÌâÄ¿", "ÀàÐÍ", "ÕýÈ·´ð°¸","°à¼¶ÕýÈ·ÂÊ","È«Õ¾ÕýÈ·ÂÊ"};
		
		obj.setHeaders(headers);
		obj.setLstColumn(new ArrayList<String>(Arrays.asList("itemNo","exerciseItemTitel","itemTypeName","correctAnswer","classAccuracyShow","orgAccuracyShow")));
		obj.setPattern("yyyy-MM-dd HH:mm");
		
		response.reset();
		response.setContentType("application/vnd.ms-excel;charset=utf-8");
		response.setHeader("Content-Disposition", "attachment;filename="+ new String((ClientUtils.getClassName()+ "_" + exeGroup.getName() + "_ÏêÇé.xls").getBytes(), "iso-8859-1"));
		response.setCharacterEncoding("utf-8");
		OutputStream ouputStream = response.getOutputStream();
		obj.setOut(ouputStream);
		ex.exportExcelByColomn(obj);
		ouputStream.flush();
		ouputStream.close();
		
	    return null;
	}
	
	/**
	 * µ¼³öÁ·Ï°Ñ§Ô±µÃ·ÖÏêÇé
	 * 
	 * @return
	 * @throws IOException 
	 */
	@RequestMapping(value = "userScoreStatis/data/{groupId}", method = RequestMethod.GET)
	public String exportUserScore(@PathVariable String groupId,HttpServletResponse response) throws IOException {
		// »ñÈ¡×éÃû³Æ
		ExerciseGroup exeGroup= this.commonDAO.read(ExerciseGroup.class, groupId);
		
		// »ñȡ֮ǰ×é×°µÄÅÅÃûList<Map<String, Object>>Áбí
		List<Map<String, Object>> userScoreMap = exerciseService.resultList(groupId);
		List<ExportUserScore> userLst = new ArrayList<ExportUserScore>(userScoreMap.size());
		ExportUserScore user = null;
		
		if(userScoreMap != null){
			// ½«»ñÈ¡µÄMapÁбíת»»ÎªListÁбí
			for(Map<String, Object> userScore:userScoreMap){
				user = new ExportUserScore();
				user.setName(String.valueOf(userScore.get("name")));
				user.setMobilePhone(String.valueOf(userScore.get("mobilePhone")));
				user.setScore(new BigDecimal(String.valueOf( userScore.get("accuracy"))));
				user.setSubmitTime((Date)userScore.get("time"));
				user.setSalesCode(String.valueOf(userScore.get("salesCode")));
				user.setCreateTime((Date)userScore.get("createTime"));
				userLst.add(user);
			}
			
			ExcelExportUtils<ExportUserScore> ex = new ExcelExportUtils<ExportUserScore>();
			ExcelExportParam<ExportUserScore> obj = new ExcelExportParam<ExportUserScore>();
			obj.setColData(userLst);
			String[] headers = { "ÅÅÃû","ѧԱÐÕÃû","±¨ÃûÂë","±¨Ãûʱ¼ä","ÊÖ»úºÅÂë", "Ìύʱ¼ä", "³É¼¨"};
			
			obj.setHeaders(headers);
			obj.setLstColumn(new ArrayList<String>(Arrays.asList("name","salesCode","createTime","mobilePhone","submitTime","score")));
			obj.setPattern("yyyy-MM-dd HH:mm");
			
			response.reset();
			response.setContentType("application/vnd.ms-excel;charset=utf-8");
			response.setHeader("Content-Disposition", "attachment;filename="+ new String((ClientUtils.getClassName() + "_" + exeGroup.getName() + "_³É¼¨.xls").getBytes(), "iso-8859-1"));
			response.setCharacterEncoding("utf-8");
			OutputStream ouputStream = response.getOutputStream();
			obj.setOut(ouputStream);
			ex.exportExcelByColomn(obj);
			ouputStream.flush();
			ouputStream.close();
		}
		
	    return null;
	}
	
	
	
	/**
	 * Ï°Ìâ×éÅÅÐò
	 * 
	 * @param key
	 * @return
	 */
	@RequestMapping(value = "/order", method=RequestMethod.POST)
    public @ResponseBody Result order(@RequestParam("ids[]") List<String> ids,  @RequestParam("index[]") List<Integer> index){
		exerciseService.doOrder(ids, index);
		return new Result(true) ;
	}
	
	/**
	 * Ï°ÌâÅÅÐò
	 * 
	 * @param key
	 * @return
	 */
	@RequestMapping(value = "/item/order", method=RequestMethod.POST)
    public @ResponseBody Result itemOrder(@RequestParam("ids[]") List<String> ids,  @RequestParam("index[]") List<Integer> index,  @RequestParam("groupId") String groupId){
		exerciseService.doitemOrder(ids, index,groupId);
		return new Result(true) ;
	}
	
	
	
	/******************************************pyµ¼Èë******************************************************************/
	/**
	 * £¨ºǫ́¹ÜÀíϵͳ:µ¼ÈëÏ°ÌâÄ£¿é£©
	 *  µ¼ÈëÏ°Ìâ-µÚÒ»´Î½«word½âÎö½á¹û·µ»Ø¸øǰ̨£¬²¢²»±£´æµ½Êý¾Ý¿â
	 *  
	 * @param groupId Ï°Ìâ×éID
	 * @param uuid uuid
	 * @param fileName ÎļþÃû³Æ
	 * @return
	 */
	@RequestMapping(value = "/item/importpy/parse/{groupId}", method = RequestMethod.POST)
	public @ResponseBody Map<String,Object> importItemsPy(@PathVariable String groupId,String fullPath,String module) {
		
		return exercisePyService.parserPyExercise(groupId, fullPath, module);
		
	}
	
	/**
	 * £¨ºǫ́¹ÜÀíϵͳ:µ¼ÈëÏ°ÌâÄ£¿é£©
	 *  УÑéÄÚÈÝ£¬·µ»Ø½âÎö½á¹û
	 * 
	 * @param content Îı¾ÄÚÈÝ
	 * @return
	 */
	@RequestMapping(value = "/item/importpy/validate", method = RequestMethod.POST)
	public @ResponseBody Map<String, Object> validatePyExercise(String content) {
		
		return exercisePyService.validatePyExercise(content);
	}
	
	/**
	 * £¨ºǫ́¹ÜÀíϵͳ:µ¼ÈëÏ°ÌâÄ£¿é£©
	 *  µ¼ÈëÄÚÈÝ£¬·µ»Ø½âÎö½á¹û
	 * 
	 * @param content Îı¾ÄÚÈÝ
	 * @return
	 */
	@SuppressWarnings("unchecked")
	@RequestMapping(value = "/item/importpy/import", method = RequestMethod.POST)
	public @ResponseBody Result importPyExercise(@RequestParam(value = "data")  String data,@RequestParam(value = "groupId")  String groupId) {
		
		ObjectMapper mapper = new ObjectMapper();
		JavaType javaType = mapper.getTypeFactory().constructParametricType(List.class, ExerciseItemData.class); 
		
		try {
			
			List<ExerciseItemData> lst =  (List<ExerciseItemData>)mapper.readValue(data, javaType);
			return exercisePyService.doImportPyExercise(lst,groupId);
			
		} catch (Exception e) {
			log.error("Ìá½»Êý¾ÝÓÐÎó" + e );
		}
		
		return new Result(false,"½âÎöjsonʧ°Ü");
	}
	
	
	
	
	/**-----------------  Îʾíµ÷²é----start-----------------------------------*/
	/**
	 * ÆÀ¹ÀÄ£¿éÌí¼ÓÎÊ´ð
	 * 
	 * @param jsonExerciseItemDTO
	 * @return
	 */
	@RequestMapping(value = "item/addOrUpdate4Evaluate", method = RequestMethod.POST, produces="application/json;charset=UTF-8")
	@ResponseBody
	public ResultJson addOrUpdate4Evaluate(@RequestBody String jsonExerciseItemDTO) {
		JSONObject jsonObject = (JSONObject) JSON.parse(jsonExerciseItemDTO);
		String groupId = jsonObject.getString(GROUP_ID);
		String exerciseId = jsonObject.getString("exerciseId");
		String title = jsonObject.getString("title");
		boolean mustAnswer = jsonObject.getBooleanValue("mustAnswer");
		short type = jsonObject.getShort("type");
		String analysis = jsonObject.getString("analysis");
		JSONArray titleImgs = jsonObject.getJSONArray("imags");// ÌâÄ¿µÄͼƬ·¾¶
		
		//»ñÈ¡Ñ¡Ïî
		List<ExerciseItemOption> lstOptions = JSONArray.parseArray(jsonObject.getString("lstOptions"), ExerciseItemOption.class);
		ExerciseItem item = null;
		
		if(StringUtils.isEmpty(exerciseId)){// ÐÂÔö
			item = new ExerciseItem();
			item.setTitle(title);
			item.setType(type);
			item.setMustAnswer(mustAnswer);
			exerciseService.insertExerciseItem4Evaluate(groupId, item, lstOptions,analysis,titleImgs);
		}else{// ±à¼­
			item = this.commonDAO.read(ExerciseItem.class, exerciseId);
			item.setTitle(title);
			item.setType(type);
			item.setMustAnswer(mustAnswer);
			return exerciseService.updateExerciseItem4Evaluate(item, lstOptions,analysis);	
		}
		
		return 	new ResultJson(true,"success",
				CollectionUtils.newObjectMap("exerciseId",item.getExerciseId(),
						"lstOptions",lstOptions));
	}
	
	
	/**
	 * »ñÈ¡ÎʾíÏ°ÌâÁбí
	 * 
	 * @return
	 */
	@RequestMapping(value = "item/data4Evaluate/{groupId}", method = RequestMethod.GET)
	@ResponseBody
	public ResultJson listItems4Evaluate(@PathVariable String groupId) {

		return 	new ResultJson(true,"success",
				exerciseService.readExerciseItems4Evaluate(groupId));
	}
	
	/**
	 * ²é¿´Ñ§Ô±´ð¾íÇé¿ö
	 * 
	 * @param recordId ´ðÌâ¼Ç¼id
	 * @param schEvaluateId
	 * @return
	 */
	@RequestMapping(value = "evaluate/userExerciseDetail", method = RequestMethod.GET)
	public @ResponseBody ResultJson queryUserEvaExerciseDetail(String recordId,String evaluateId) {
		
		return exerciseService.queryUserEvaExerciseDetail(recordId, evaluateId);
	}
	
	/** ²éѯͼƬ·¾¶ */
	@RequestMapping(value = "evaluate/queryExerObjImg",method = RequestMethod.GET)
	public @ResponseBody ResultJson queryEvaExerciseObjImg(
			@RequestParam("imgObjId") String imgObjId,
			@RequestParam("imgObjType") int imgObjType){
		
		if(StringUtils.isBlank(imgObjId)){
			return new ResultJson(false,"²ÎÊýΪ¿Õ");
		}
		
		List<Map<String,Object>> lstResult =  exerciseService.queryEvaExerciseObjImg(imgObjId, imgObjType);
		
		return new ResultJson(true,"success",lstResult);
	}
	
	/**
	 * ÐÂÔöͼƬ·¾¶µ½Êý¾Ý¿â
	 * @param fullPaths
	 * @param imgObjId
	 * @param imgObjType
	 * @return
	 */
	@RequestMapping(value = "evaluate/addExerObjImg",method = RequestMethod.POST)
	public @ResponseBody ResultJson doAddEvaExerciseObjImg(
			@RequestParam("fullPaths") String fullPaths,
			@RequestParam("imgObjId") String imgObjId,
			@RequestParam("imgObjType") int imgObjType){
		
		if(StringUtils.isBlank(fullPaths)){
			return null;
		}
		String[] imgPaths = fullPaths.split(";");
		
		// ¸üз¾¶µ½Êý¾Ý¿â
		List<Map<String,Object>> lstResult = exerciseService.doAddEvaExerciseObjImg(imgPaths, imgObjId, imgObjType);
		
		return new ResultJson(true,"success",lstResult);
	}
	
	/** ɾ³ýͼƬ·¾¶µ½Êý¾Ý¿â */
	@RequestMapping(value = "evaluate/delExerObjImg",method = RequestMethod.POST)
	public @ResponseBody ResultJson dodelEvaExerciseObjImg(
			@RequestParam("imgId") String imgId){
		
		ResultJson result = exerciseService.dodelEvaExerciseObjImg(imgId);
		
		return result;
	}
	/**------------------  Îʾíµ÷²é----end------------------------------------*/
	
	
	/**------------------------------  web ºó¶Ë----end--------------------------------------------------------------------*/
	
}