package com.qxueyou.scc.exercise.service.impl;


import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Timestamp;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

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.Service;

import com.alibaba.fastjson.JSONObject;
import com.qxueyou.scc.base.model.Constants;
import com.qxueyou.scc.base.model.Pager;
import com.qxueyou.scc.base.model.Result;
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.DateTimeUtils;
import com.qxueyou.scc.base.util.DateUtils;
import com.qxueyou.scc.base.util.TraceUtils;
import com.qxueyou.scc.exercise.model.ExciseExtendReqData;
import com.qxueyou.scc.exercise.model.ExerGroupResponseData;
import com.qxueyou.scc.exercise.model.ExerItemResponseData;
import com.qxueyou.scc.exercise.model.ExerciseDataSubmitLog;
import com.qxueyou.scc.exercise.model.ExerciseExtendRecordData;
import com.qxueyou.scc.exercise.model.ExerciseFault;
import com.qxueyou.scc.exercise.model.ExerciseFaultBook;
import com.qxueyou.scc.exercise.model.ExerciseFaultHis;
import com.qxueyou.scc.exercise.model.ExerciseFaultRecord;
import com.qxueyou.scc.exercise.model.ExerciseFaultStatistics;
import com.qxueyou.scc.exercise.model.ExerciseFavorite;
import com.qxueyou.scc.exercise.model.ExerciseFavoriteBook;
import com.qxueyou.scc.exercise.model.ExerciseFavoriteHis;
import com.qxueyou.scc.exercise.model.ExerciseFavoriteRecord;
import com.qxueyou.scc.exercise.model.ExerciseGroup;
import com.qxueyou.scc.exercise.model.ExerciseItem;
import com.qxueyou.scc.exercise.model.ExerciseItemAnalisi;
import com.qxueyou.scc.exercise.model.ExerciseItemAnalisiU;
import com.qxueyou.scc.exercise.model.ExerciseItemAnswerData;
import com.qxueyou.scc.exercise.model.ExerciseItemAnswerU;
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.IExerciseExtendService;
import com.qxueyou.scc.exercise.service.IExerciseVerService;
import com.qxueyou.scc.exercise.util.ExerciseUtils;


/**
 * 练习  实现service
 * @author zhiyong
 *
 */
@Service(value = "exerciseExtendService")
public class ExerciseExtendService extends CommonAppService implements IExerciseExtendService {
	/** 日志 */
	private static final Logger log = LogManager.getLogger(ExerciseExtendService.class);
	
	/** 练习接口service  */
	@Autowired
	private IExerciseVerService exerciseVerService;
	
	/** 做题记录id */
	private static final String EXERCISE_RECORD_ID = "exerciseRecordId";
	
	/** 更新时间 */
	private static final String UPDATE_TIME = "updateTime";
	
	/**
	 * 新增收藏book记录
	 * @param groupId
	 * @return 
	 */
	public String insertExerciseFavorBook(String currTitleNum) {
		
		ExerciseFavoriteBook record = new ExerciseFavoriteBook();
		record.setUserId(ClientUtils.getUserId());
		record.setClassId(ClientUtils.getClassId());
		record.setDeleteFlag(false);
		//record.setTitleMaxNumber(currTitleNum);
		TraceUtils.setCreateTrace(record);
		
		this.save(record);
		
		return record.getFavoriteBookId();
	}
	
	/**
	 * 新增错题book记录
	 * @param groupId
	 * @return 
	 */
	public String insertExerciseFaultBook() {
		
		ExerciseFaultBook record = new ExerciseFaultBook();
		record.setUserId(ClientUtils.getUserId());
		record.setClassId(ClientUtils.getClassId());
		record.setDeleteFlag(false);
		TraceUtils.setCreateTrace(record);
		
		this.save(record);
		
		return record.getResumeBookId();
	}
	
	/**
	 * 新增收藏记录
	 * @param groupId
	 * @return 
	 */
	public Result insertExerciseFavor(String favoriteBookId, String exerciseItemId) {
		ExerciseFavorite record = new ExerciseFavorite();
		record.setFavoriteBookId(favoriteBookId);
		record.setExerciseItemId(exerciseItemId);
		record.setDeleteFlag(false);
		TraceUtils.setCreateTrace(record);
		
		this.save(record);
		
		return new Result(true);
	}
	
	/**
	 * 新增错题记录
	 * @param groupId
	 * @return 
	 */
	public Result insertExerciseFault(String resumeBookId, String exerciseItemId, String repeatFlag) {
		ExerciseFault record = new ExerciseFault();
		record.setExerciseItemId(exerciseItemId);
		record.setResumeBookId(resumeBookId);
		record.setDeleteFlag(false);
		TraceUtils.setCreateTrace(record);
		
		this.save(record);
		
		return new Result(true);
	}
	
	/** -------------------------APP--V2.0- start------------------------------------------- */
	/**
	 * 操作错题记录
	 */
	public Map<String,Object> doOperExerciseFaultRecordData(String subjectId, ExciseExtendReqData recordResult) {
		// 练习组id
		String exerciseGroupId = recordResult.getExerciseGroupId();
		String exerciseGroupType = recordResult.getExerciseGroupType();
		
		// 1.操作练习总记录
		ExerciseFaultBook resumeBook = doOperExerciseFaultBook(subjectId,recordResult);
		String resumeBookId = resumeBook.getResumeBookId();
		
		// 2.操作练习记录
		ExerciseFaultRecord record = doOperExerciseFaultRecord(resumeBookId,
				exerciseGroupId, exerciseGroupType, recordResult);
		
		String faultRecordId = record.getFaultRecordId();
		
		// 3.组装错题结果入库
		doOperFaultExerciseToDB(resumeBookId, faultRecordId, recordResult);
		
		// 4.重新计算做题记录正确个数 做题个数  正确率  错题本
		record = this.doCalcFaultExericseStatisBySubmitData(record,resumeBook,subjectId);
		
		// 5.返回结果
		Map<String,Object> map = new HashMap<String, Object>(3);
		map.put(EXERCISE_RECORD_ID, faultRecordId);
		map.put("exerciseGroupId", exerciseGroupId);
		map.put(UPDATE_TIME, DateTimeUtils.getCurrDateTime(record.getUpdateTime()));
		
		return map;
	}
	
	/**
	 * 重新计算错题record数据结果
	 * @param record
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public Result updateExerciseFaultRecordData(ExerciseFaultRecord record){
		String sql = "SELECT"+
				" count(1) allCount,"+
				" sum(CORRECT = 1) corrCount,"+
				" sum(ANSWER IS NOT NULL) doCount,"+
				" round(sum(CORRECT = 1) / count(1) * 100,2) accuracy,"+
				" round(sum(ANSWER IS NOT NULL) / count(1) * 100,2) rate"+
				" FROM exercise_fault"+
				" WHERE DELETE_FLAG = 0"+
				" AND FAULT_RECORD_ID = ?";

		List<Object[]> lstFault = this.findBySql(sql,  CollectionUtils.newList(record.getFaultRecordId()));
		
		Object[] objs = lstFault.get(0);
		
		// 拆分子数据
		packagingExerciseFaultRecordData(record, objs);
		
		if(record.getAllCount().compareTo(BigInteger.ZERO) == 0){// 全部删除后 数据清0
			record.setTitleMaxNumber("0");
			record.setStatus("0");
		}else if(StringUtils.isNotBlank(record.getTitleMaxNumber()) && 
				record.getAllCount().compareTo(new BigInteger(record.getTitleMaxNumber())) < 0){// 总个数小于最大题号数
			record.setTitleMaxNumber(String.valueOf(record.getAllCount()));
		}
		TraceUtils.setUpdateTrace(record);
		this.save(record);
		
		return new Result(true);
	}
	
	/**
	 * 重新计算错题record数据结果   拆分子数据
	 * @param record
	 * @param objs
	 */
	private void packagingExerciseFaultRecordData(ExerciseFaultRecord record,
			Object[] objs) {
		record.setAllCount((BigInteger)objs[0]);
		record.setCorrectCount(new BigInteger(String.valueOf(objs[1]==null ? "0" : objs[1])));
		record.setDoCount(new BigInteger(String.valueOf(objs[2]==null ? "0" : objs[2])));
		record.setAccuracy(new BigDecimal(String.valueOf(objs[3]==null ? "0" : objs[3])));
		record.setCompletionRate(new BigDecimal(String.valueOf(objs[4]==null ? "0" : objs[4])));
		record.setScore(record.getAccuracy());
	}
	
	/**
	 * 重新计算做题记录总个数    错题本 正确个数 做题个数  正确率  错题本
	 * @return
	 */
	public ExerciseFaultRecord doCalcFaultExericseStatisBySubmitData(ExerciseFaultRecord record,
			ExerciseFaultBook resumeBook, String subjectId){
		// 1.计算做题总个数 record
		this.updateExerciseFaultRecordData(record);
		
		// 2.计算该班级的总个数
		this.updateExerciseFaultBookInfo(resumeBook);
		if(resumeBook.getAllCount().compareTo(BigInteger.ZERO) == 0){// 全部删除后 数据清0
			resumeBook.setTitleMaxNumber("0");
			resumeBook.setStatus("0");
		}else if(StringUtils.isNotBlank(resumeBook.getTitleMaxNumber()) && 
				resumeBook.getAllCount().compareTo(new BigInteger(resumeBook.getTitleMaxNumber())) < 0){// 总个数小于最大题号数
			resumeBook.setTitleMaxNumber(String.valueOf(resumeBook.getAllCount()));
		}
		TraceUtils.setUpdateTrace(resumeBook);
		this.save(resumeBook);
		
		return record;
	}
	
	/**
	 * 组装错题结果入库
	 * @param resumeBookId
	 * @param faultRecordId
	 * @param recordResult
	 * @return
	 */
	private Result doOperFaultExerciseToDB(String resumeBookId, String faultRecordId, ExciseExtendReqData recordResult){
		List<ExerciseExtendRecordData> lstItems = recordResult.getItems();
		
		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);
		argsMap.put("resumeBookId", resumeBookId);
		
		//  查询此用户是否有错题记录
		String hql = "from ExerciseFault where exerciseItemId in (:exerciseIds) and resumeBookId=:resumeBookId and deleteFlag is false ";
		List<ExerciseFault> lstExistfavor = this.findByComplexHql(hql, argsMap, ExerciseFault.class);
		
		Map<String, ExerciseFault> faultMap = new HashMap<String, ExerciseFault>();
		for(ExerciseFault fault:lstExistfavor){
			faultMap.put(fault.getExerciseItemId(), fault);
		}
		
		List<ExerciseFault> lstFault = new ArrayList<ExerciseFault>(recordResult.getItems().size());
		ExerciseFault fault=null;
		
		// 循环每一条记录
		// 判断客户端提交的数据是否重复map
		Map<String,Object> repeatMap = new HashMap<String,Object>(lstItems.size());
		
		for(ExerciseExtendRecordData record:lstItems){
				if(repeatMap.get(record.getExerciseId()) != null && 
						(boolean)repeatMap.get(record.getExerciseId()) == record.getFlag()){//重复数据
					continue;
				}
			
				fault=faultMap.get(record.getExerciseId());
				if(record.getFlag()){//添加错题
					if(fault == null){
						fault = new ExerciseFault();
						fault.setFaultRecordId(faultRecordId);
						fault.setResumeBookId(resumeBookId);
						fault.setExerciseItemId(record.getExerciseId());
						fault.setDeleteFlag(false);
						TraceUtils.setCreateTrace(fault);
					}else{// 原来已经删除  恢复
						if(fault.getDeleteFlag()){
							fault.setDeleteFlag(false);
							fault.setAnswer(null);
							fault.setCorrect(Byte.valueOf("0"));
							TraceUtils.setUpdateTrace(fault);
						}else{
							continue;
						}
					}
					
				}else{// 删除错题
					if(fault == null){
						continue;
					}
					fault.setDeleteFlag(true);
					fault.setAnswer(null);
					fault.setCorrect(Byte.valueOf("0"));
					TraceUtils.setUpdateTrace(fault);
				}
				lstFault.add(fault);
				
				repeatMap.put(record.getExerciseId(), record.getFlag());
		}
		
		// 2.记录错题itemList
		// 批量增加
		this.saveOrUpdateAll(lstFault);
		this.flush();
		
		return new Result(true);
	}
	
	/**
	 * 操作练习记录
	 * @param subjectId
	 * @return
	 */
	public ExerciseFaultRecord doOperExerciseFaultRecord(String resumeBookId,String exerciseGroupId,
			String exerciseGroupType, ExciseExtendReqData recordResult){
		// 错题记录 当前组
		String hql = "from ExerciseFaultRecord where resumeBookId=? and exerciseGroupId=? and deleteFlag is false ";
		
		ExerciseFaultRecord record = this.findUnique(hql, 
				CollectionUtils.newList(resumeBookId, exerciseGroupId), ExerciseFaultRecord.class);
		
		if(null == record){// 记录不存在
			
			record = new ExerciseFaultRecord();
			record.setResumeBookId(resumeBookId);
			record.setExerciseGroupId(exerciseGroupId);
			record.setExerciseGroupType(Short.valueOf(exerciseGroupType));
			record.setDeleteFlag(false);
			TraceUtils.setCreateTrace(record);
			
			this.save(record);
		}
		
		
		return record;
	}
	
	
	/**
	 * 操作练习记录
	 * @param subjectId
	 * @return
	 */
	public ExerciseFaultBook doOperExerciseFaultBook(String subjectId,ExciseExtendReqData recordResult){
		StringBuffer hql = new StringBuffer(512);
		hql.append("from ExerciseFaultBook where classId=? and userId=? and deleteFlag is false ");
		
		List<Object> args = CollectionUtils.newList(ClientUtils.getClassId(), 
					ClientUtils.getUserId());
		if(StringUtils.isNotBlank(subjectId)){// 高校
			hql.append(" and subjectId=? ");
			 args.add(subjectId);
		}
		
		//  查询此用户是否有错题记录
		List<ExerciseFaultBook> lstFault = this.find(hql.toString(), args, ExerciseFaultBook.class);
		
		ExerciseFaultBook book = null;
		String hql_book;
		if(lstFault.isEmpty()){// 记录为空
			
			if(StringUtils.isNotBlank(subjectId)){// 高校
				
				// 先查询上级记录是否存在
				hql_book = "from ExerciseFaultBook where classId=? and userId=? and deleteFlag is false ";
				
				lstFault = this.find(hql_book, CollectionUtils.newList(ClientUtils.getClassId(), 
						ClientUtils.getUserId()), ExerciseFaultBook.class);
				
				if(lstFault.isEmpty()){//班级记录不存在
					book = this.insertExerciseFaultBookNew(ExerciseFaultBook.TYPE_ORGANIZATION, null);
				}
				
				book = this.insertExerciseFaultBookNew(ExerciseFaultBook.TYPE_COLLEGE, lstFault.get(0).getResumeBookId());
				
				
			}else{
				book = this.insertExerciseFaultBookNew(ExerciseFaultBook.TYPE_ORGANIZATION, null);
			}
		}else{
			book = lstFault.get(0);
		}
		
		
		return book;
	}
	
	
	/**
	 * 新增错题book记录
	 * @param groupId
	 * @return 
	 */
	public ExerciseFaultBook insertExerciseFaultBookNew(short type, String parentId) {
		
		ExerciseFaultBook record = new ExerciseFaultBook();
		record.setUserId(ClientUtils.getUserId());
		record.setClassId(ClientUtils.getClassId());
		record.setCollegeCourseId(ClientUtils.getCourseId());
		record.setOrgId(ClientUtils.getOrgId());
		//record.setSubjectId();
		record.setParentId(parentId);
		record.setType(type);
		record.setDeleteFlag(false);
		TraceUtils.setCreateTrace(record);
		
		this.save(record);
		
		return record;
	}
	
	/**
	 * 更新错题book记录
	 * @param groupId
	 * @return 
	 */
	public Result updateExerciseFaultBookNew(ExerciseFaultBook record) {
		
		TraceUtils.setUpdateTrace(record);
		
		this.save(record);
		
		return new Result(true);
	}
	
	
	/**
	 * 操作错题记录
	 */
	public Map<String,Object> doOperExerciseFavorRecordData(String subjectId, ExciseExtendReqData recordResult) {
		// 练习组id
		String exerciseGroupId = recordResult.getExerciseGroupId();
		String exerciseGroupType = recordResult.getExerciseGroupType();
		
		// 1.操作练习总记录
		ExerciseFavoriteBook  favorBook = doOperExerciseFavoriteBook(subjectId, recordResult);
		String favoriteBookId = favorBook.getFavoriteBookId();
		
		// 2.操作练习记录
		ExerciseFavoriteRecord record = doOperExerciseFavorRecord(favoriteBookId,
				exerciseGroupId, exerciseGroupType,recordResult);
		String favoriteRecordId = record.getFavoriteRecordId();
		
		// 3.组装错题结果入库
		doOperFavorExerciseToDB(favoriteBookId, favoriteRecordId, recordResult);
		
		
		// 4. 重新计算做题记录总个数  收藏
		record = this.doCalcFavorExericseStatisBySubmitData(record, favorBook, subjectId);
		
		// 5.返回结果
		Map<String,Object> map = new HashMap<String, Object>(3);
		map.put(EXERCISE_RECORD_ID, favoriteRecordId);
		map.put("exerciseGroupId", exerciseGroupId);
		map.put(UPDATE_TIME, DateTimeUtils.getCurrDateTime(record.getUpdateTime()));
		
		return map;
	}
	
	/**
	 * 更新ExerciseFavoriteRecord数据
	 * @param record
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public Result updateExerciseFavoriteRecordData(ExerciseFavoriteRecord record){
		String sql = "SELECT"+
				" count(1) allCount,"+
				" sum(CORRECT = 1) corrCount,"+
				" sum(ANSWER IS NOT NULL) doCount,"+
				" round(sum(CORRECT = 1) / count(1) * 100,2) accuracy,"+
				" round(sum(ANSWER IS NOT NULL) / count(1) * 100,2) rate"+
				" FROM exercise_favorite"+
				" WHERE DELETE_FLAG = 0"+
				" AND FAVORITE_RECORD_ID = ?";

		List<Object[]> lstFault = this.findBySql(sql,  CollectionUtils.newList(record.getFavoriteRecordId()));
		
		Object[] objs = lstFault.get(0);
		
		//  拆分子数据
		packagingExerciseFavoriteRecordData(record, objs);
		
		if(record.getAllCount().compareTo(BigInteger.ZERO) == 0){// 全部删除后 数据清0
			record.setTitleMaxNumber("0");
			record.setStatus("0");
		}else if(StringUtils.isNotBlank(record.getTitleMaxNumber()) && 
				record.getAllCount().compareTo(new BigInteger(record.getTitleMaxNumber())) < 0){// 总个数小于最大题号数
			record.setTitleMaxNumber(String.valueOf(record.getAllCount()));
		}
		TraceUtils.setUpdateTrace(record);
		this.save(record);
		
		return new Result(true);
	}
	
	/**
	 * 拆分子数据
	 * @param record
	 * @param objs
	 */
	private void packagingExerciseFavoriteRecordData(
			ExerciseFavoriteRecord record, Object[] objs) {
		record.setAllCount((BigInteger)objs[0]);
		record.setCorrectCount(new BigInteger(String.valueOf(objs[1]==null ? "0" : objs[1])));
		record.setDoCount(new BigInteger(String.valueOf(objs[2]==null ? "0" : objs[2])));
		record.setAccuracy(new BigDecimal(String.valueOf(objs[3]==null ? "0" : objs[3])));
		record.setCompletionRate(new BigDecimal(String.valueOf(objs[4]==null ? "0" : objs[4])));
		record.setScore(record.getAccuracy());
	}
	
	/**
	 * 重新计算做题记录总个数  收藏
	 * @param exerciseGroupId
	 * @param exerciseRecordId
	 * @return
	 */
	public ExerciseFavoriteRecord doCalcFavorExericseStatisBySubmitData(ExerciseFavoriteRecord record,
			ExerciseFavoriteBook favorBook,String subjectId){
		// 1.计算做题总个数 record
		this.updateExerciseFavoriteRecordData(record);
				
		// 2.计算该班级的总个数
		this.updateExerciseFavorBookInfo(favorBook);
		if(favorBook.getAllCount().compareTo(BigInteger.ZERO) == 0){// 全部删除后 数据清0
			favorBook.setTitleMaxNumber("0");
			favorBook.setStatus("0");
		}else if(StringUtils.isNotBlank(favorBook.getTitleMaxNumber()) 
				&& favorBook.getAllCount().compareTo(new BigInteger(favorBook.getTitleMaxNumber())) < 0){// 总个数小于最大题号数
			favorBook.setTitleMaxNumber(String.valueOf(favorBook.getAllCount()));
		}
		TraceUtils.setUpdateTrace(favorBook);
		this.save(favorBook);
		
		return record;
	}
	
	/**
	 * 组装错题结果入库
	 * @param resumeBookId
	 * @param faultRecordId
	 * @param recordResult
	 * @return
	 */
	private Result doOperFavorExerciseToDB(String favoriteBookId, String favoriteRecordId, ExciseExtendReqData recordResult){
		List<ExerciseExtendRecordData> lstItems = recordResult.getItems();
		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);
		argsMap.put("favoriteRecordId", favoriteRecordId);
		
		//  查询此用户是否有收藏记录
		String hql = "from ExerciseFavorite where exerciseItemId in (:exerciseIds) and favoriteRecordId=:favoriteRecordId and deleteFlag is false";
		List<ExerciseFavorite>  lstExistfavor =  this.findByComplexHql(hql, argsMap, ExerciseFavorite.class);
		Map<String, ExerciseFavorite> favorMap = new HashMap<String, ExerciseFavorite>();
		for(ExerciseFavorite favor:lstExistfavor){
			favorMap.put(favor.getExerciseItemId(), favor);
		}
		
		List<ExerciseFavorite> lstFavor= new ArrayList<ExerciseFavorite>();
		ExerciseFavorite favor=null;
		// 循环每一条记录
		// 判断客户端提交的数据是否重复map
		Map<String,Object> repeatMap = new HashMap<String,Object>(lstItems.size());
		
		for(ExerciseExtendRecordData record:lstItems){
			if(repeatMap.get(record.getExerciseId()) != null && 
					(boolean)repeatMap.get(record.getExerciseId()) == record.getFlag()){//重复数据
				continue;
			}
				
			favor = favorMap.get(record.getExerciseId());
			if(record.getFlag()){//添加收藏记录
				if(favor == null){
					favor = new ExerciseFavorite();
					favor.setFavoriteBookId(favoriteBookId);
					favor.setFavoriteRecordId(favoriteRecordId);
					favor.setExerciseItemId(record.getExerciseId());
					TraceUtils.setCreateTrace(favor);
					favor.setDeleteFlag(false);
				}else{//原来已经删除 现在恢复
					if(favor.getDeleteFlag()){
						favor.setAnswer(null);
						favor.setCorrect(Byte.valueOf("0"));
						favor.setDeleteFlag(false);
						TraceUtils.setUpdateTrace(favor);
					}else{
						continue;
					}
				}
				
			}else{// 删除收藏
				if(favor == null){
					continue;
				}
				favor.setDeleteFlag(true);
				favor.setAnswer(null);
				favor.setCorrect(Byte.valueOf("0"));
				favor.setCreateTime(new Date(System.currentTimeMillis()));
				TraceUtils.setUpdateTrace(favor);
			}
			lstFavor.add(favor);
			
			repeatMap.put(record.getExerciseId(), record.getFlag());
		}
		
		// 2.记录收藏itemList
		// 批量增加或者更新
		this.saveOrUpdateAll(lstFavor);
		this.flush();
		
		return new Result(true);
	}
	/**
	 * 操作练习记录
	 * @param subjectId
	 * @return
	 */
	public ExerciseFavoriteRecord doOperExerciseFavorRecord(String favoriteBookId,String exerciseGroupId,
			String exerciseGroupType,ExciseExtendReqData recordResult){
		// 错题记录 当前组
		String hql = "from ExerciseFavoriteRecord where favoriteBookId=? and exerciseGroupId=? and deleteFlag is false ";
		
		ExerciseFavoriteRecord record = this.findUnique(hql, 
				CollectionUtils.newList(favoriteBookId, exerciseGroupId), ExerciseFavoriteRecord.class);
		
		if(null == record){// 记录不存在
			
			record = new ExerciseFavoriteRecord();
			record.setFavoriteBookId(favoriteBookId);
			record.setExerciseGroupId(exerciseGroupId);
			record.setExerciseGroupType(Short.valueOf(exerciseGroupType));
			record.setDeleteFlag(false);
			TraceUtils.setCreateTrace(record);
			
			this.save(record);
		}
		
		return record;
	}
	
	
	/**
	 * 操作练习记录
	 * @param subjectId
	 * @return
	 */
	public ExerciseFavoriteBook doOperExerciseFavoriteBook(String subjectId,ExciseExtendReqData recordResult){
		StringBuffer hql = new StringBuffer(512);
		hql.append("from ExerciseFavoriteBook where classId=? and userId=? and deleteFlag is false ");
		
		List<Object> args = CollectionUtils.newList(ClientUtils.getClassId(), 
					ClientUtils.getUserId());
		if(StringUtils.isNotBlank(subjectId)){// 高校
			hql.append(" and subjectId=? ");
			args.add(subjectId);
		}
		
		//  查询此用户是否有错题记录
		List<ExerciseFavoriteBook> lstFavor = this.find(hql.toString(), args, ExerciseFavoriteBook.class);
		
		ExerciseFavoriteBook book = null;
		String hql_book;
		if(lstFavor.isEmpty()){// 记录为空
			
			if(StringUtils.isNotBlank(subjectId)){// 高校
				
				// 先查询上级记录是否存在
				hql_book = "from ExerciseFavoriteBook where classId=? and userId=? and deleteFlag is false ";
				
				lstFavor = this.find(hql_book, CollectionUtils.newList(ClientUtils.getClassId(), 
						ClientUtils.getUserId()), ExerciseFavoriteBook.class);
				
				if(lstFavor.isEmpty()){//班级记录不存在
					book = this.insertExerciseFavorBookNew(ExerciseFavoriteBook.TYPE_ORGANIZATION, null);
				}else{
					book = lstFavor.get(0);
				}
				
				book = this.insertExerciseFavorBookNew(ExerciseFavoriteBook.TYPE_COLLEGE, book.getFavoriteBookId());
				
				
			}else{
				book = this.insertExerciseFavorBookNew(ExerciseFavoriteBook.TYPE_ORGANIZATION, null);
			}
		}else{
			book = lstFavor.get(0);
		}
		
		return book;
	}
	
	/**
	 * 新增错题book记录
	 * @param groupId
	 * @return 
	 */
	public Result updateExerciseFavorBookNew(ExerciseFavoriteBook record) {
		
		TraceUtils.setUpdateTrace(record);
		
		this.save(record);
		
		return new Result(true);
	}
	
	/**
	 * 新增错题book记录
	 * @param groupId
	 * @return 
	 */
	public ExerciseFavoriteBook insertExerciseFavorBookNew(short type, String parentId) {
		
		ExerciseFavoriteBook record = new ExerciseFavoriteBook();
		record.setUserId(ClientUtils.getUserId());
		record.setClassId(ClientUtils.getClassId());
		record.setCollegeCourseId(ClientUtils.getCourseId());
		record.setOrgId(ClientUtils.getOrgId());
		record.setParentId(parentId);
		record.setType(type);
		record.setDeleteFlag(false);
		TraceUtils.setCreateTrace(record);
		
		this.save(record);
		
		return record;
	}
	
	/**
	 * 错题本提交答案
	 */
	@Override
	public Map<String,Object> doSubmitExerFaultAnswerDataNew(ExerciseSubmitAnswerData clientAnswerResult) {
		
		// 0.重新整理答题数据
		ExerciseSubmitAnswerData answerResult = exerciseVerService.getExerciseSubmitAnswerDataNew(clientAnswerResult);
		
		// 1.更新错题记录
		ExerciseFaultRecord record = this.doOperExerFaultRecord(answerResult);
		
		if(null == record){
			return null;
		}
		
		String faultRecordId = record.getFaultRecordId();
		
		// 返回结果
		Map<String,Object> map = new HashMap<String, Object>(3);
		map.put(EXERCISE_RECORD_ID, faultRecordId);
		map.put("exerciseGroupId", record.getExerciseGroupId());
		map.put(UPDATE_TIME, DateTimeUtils.getCurrDateTime(record.getAnswerUpdateTime()));
		map.put("exerciseBookId", record.getResumeBookId());
		map.put("correctCount", answerResult.getCorrectCount());
		map.put("doCount", answerResult.getDoCount());
				
		if(answerResult.getItems().isEmpty() 
				&& answerResult.getSubmitType() != 1){//  submitType:1表示本地无网情况下重新做题过
			return map;
		}
		
		// 2.判断是否本地重新做过 submitType:1表示本地无网情况下重新做题过
		if(1 == answerResult.getSubmitType()){
			doOperExerciseFaultRecordByRedo(faultRecordId);
		}
		
		// 2.更新答案
		answerResult.setExerciseRecordId(faultRecordId);
		Result result = this.doUpdateExerFaultAnswerData(answerResult);
		
		if(!result.isSuccess()){
			return null;
		}
		
		// 3.重新计算做题记录正确个数 做题个数  正确率
		this.updateExerciseFaultRecordData(record);
		
		return map;
	}
	
	/**
	 * 更新错题记录
	 * @param answerResult
	 * @return 
	 */
	public ExerciseFaultRecord doOperExerFaultRecord(ExerciseSubmitAnswerData answerResult) {
		
		ExerciseFaultRecord record = null;
		String exerciseRecordId = answerResult.getExerciseRecordId();
		if(StringUtils.isNotBlank(exerciseRecordId)){// 正常做题
			
			record = this.read(ExerciseFaultRecord.class, answerResult.getExerciseRecordId());
			
		}else{// 无网情况下
			String hql = "from ExerciseFaultRecord r where r.deleteFlag is false and "
					+ "r.faultBook.userId=? and r.faultBook.classId=? and r.exerciseGroupId=?";
			
			record = this.findUnique(hql, CollectionUtils.newList(ClientUtils.getUserId(), ClientUtils.getClassId(),
					answerResult.getExerciseGroupId()), ExerciseFaultRecord.class);
		}
		
		if(null == record){
			return null;
		}
		
		if(answerResult.getItems().isEmpty() 
				&& ExerciseRecord.STATUS_SUBMIT.equals(answerResult.getStatus())){//仅仅交卷
			record.setStatus(answerResult.getStatus());
			// 更新答案时间
			record.setAnswerUpdateTime(new Date(System.currentTimeMillis()));
			
			this.save(record);
			
			return record;
		}
		
		
		// 计算
//		if(!"1".equals(record.getStatus())){// 非提交的就更新  
//		}
		record.setStatus(StringUtils.isBlank(answerResult.getStatus()) ? "0" : answerResult.getStatus());
		if(!"0".equals(answerResult.getCurrTitleNum())){
			record.setTitleMaxNumber(StringUtils.isBlank(answerResult.getCurrTitleNum()) ? "0" : answerResult.getCurrTitleNum());
		}
		// 更新答案时间
		record.setAnswerUpdateTime(new Date(System.currentTimeMillis()));
		
		this.save(record);
		
		return record;
	}
	
	/**
	 *提交 错题结果到db
	 * @return
	 */
	public Result doUpdateExerFaultAnswerData(ExerciseSubmitAnswerData answerResult) {
		List<ExerciseItemAnswerData> lstAnswers = answerResult.getItems();
		if(lstAnswers.isEmpty()){
			return new Result(true);
		}
		
		// 批量更新答案
		List<ExerciseFault> lstResultFault =new ArrayList<ExerciseFault>(lstAnswers.size());
		
		// 2.1.组装参数 用于查询练习选项图片
		Map<String, Object> argsMap = new HashMap<String, Object>(2);
		Object[] args = new Object[lstAnswers.size()];
		for(int i=0; i<lstAnswers.size(); i++){
			args[i] = lstAnswers.get(i).getExerciseId();
		}
		argsMap.put("exerciseIds", args);
		argsMap.put(EXERCISE_RECORD_ID, answerResult.getExerciseRecordId());
		
		String hql = "from ExerciseFault where deleteFlag is false and exerciseItemId in (:exerciseIds) and faultRecordId =:exerciseRecordId ";
		List<ExerciseFault> lstFault = this.findByComplexHql(hql, argsMap, ExerciseFault.class);
		
		// 按练习id 对应放到map中
		Map<String, ExerciseFault> faultMap = new HashMap<String, ExerciseFault>(lstFault.size());
		for(ExerciseFault fault:lstFault){
			faultMap.put(fault.getExerciseItemId(), fault);
		}
		
		ExerciseFault fault=null;
		for(ExerciseItemAnswerData answer:lstAnswers){
			fault = faultMap.get(answer.getExerciseId());
			if(null == fault){
				continue;
			}
			if(StringUtils.isBlank(answer.getAnswer())){// 答案为空
				continue;
			}
			
			fault.setAnswer(answer.getAnswer());
			fault.setCorrect(Byte.valueOf(answer.getCorrect()));
			TraceUtils.setUpdateTrace(fault);
			lstResultFault.add(fault);
		}
		
		// 1.保存 错题 收集lst
		this.saveOrUpdateAll(lstResultFault);
		this.flush();
		
		return new Result(true);
	}
	
	/**
	 *  收藏本提交答案
	 */
	@Override
	public Map<String,Object> doSubmitExerFavorAnswerDataNew(ExerciseSubmitAnswerData clientAnswerResult) {
		
		// 0.重新整理答题数据
		ExerciseSubmitAnswerData answerResult = exerciseVerService.getExerciseSubmitAnswerDataNew(clientAnswerResult);
		
		// 1.更新错题记录
		ExerciseFavoriteRecord record = doOperExerFavorRecord(answerResult);
		if(null == record){
			return null;
		}
		String favoriteRecordId = record.getFavoriteRecordId();
		
		// 返回结果
		Map<String,Object> map = new HashMap<String, Object>(3);
		map.put(EXERCISE_RECORD_ID, favoriteRecordId);
		map.put("exerciseGroupId", record.getExerciseGroupId());
		map.put(UPDATE_TIME,   DateTimeUtils.getCurrDateTime(record.getAnswerUpdateTime()));
		map.put("exerciseBookId", record.getFavoriteBookId());
		
		if(answerResult.getItems().isEmpty() && answerResult.getSubmitType() != 1){//仅仅交卷
			return map;
		}
		
		// 2.判断是否本地重新做过 submitType:1表示本地无网情况下重新做题过
		if(1 == answerResult.getSubmitType()){
			doOperExerciseFavorRecordByRedo(favoriteRecordId);
		}
				
		// 2.更新答案
		answerResult.setExerciseRecordId(favoriteRecordId);
		Result result = doUpdateExerFavorAnswerData(answerResult);
		
		if(!result.isSuccess()){
			return null;
		}
		
		//  3.重新计算做题记录正确个数 做题个数  正确率  收藏
		this.updateExerciseFavoriteRecordData(record);
		
		return map;
	}
	
	/**
	 * 更新错题记录
	 * @param answerResult
	 * @return 
	 */
	public ExerciseFavoriteRecord doOperExerFavorRecord(ExerciseSubmitAnswerData answerResult) {
		
		ExerciseFavoriteRecord record = null;
		String exerciseRecordId = answerResult.getExerciseRecordId();
		if(StringUtils.isNotBlank(exerciseRecordId)){// 正常做题
			
			record = this.read(ExerciseFavoriteRecord.class, exerciseRecordId);
			
		}else{// 无网情况下
			String hql = "from ExerciseFavoriteRecord r where r.deleteFlag is false "
					+ " and r.favorBook.userId=? and r.favorBook.classId=? and r.exerciseGroupId=?";
			
			record = this.findUnique(hql, CollectionUtils.newList(ClientUtils.getUserId(),ClientUtils.getClassId(),
					answerResult.getExerciseGroupId()), ExerciseFavoriteRecord.class);
		}
		
		if(null == record){
			return null;
		}
		
		if(answerResult.getItems().isEmpty() 
				&& ExerciseRecord.STATUS_SUBMIT.equals(answerResult.getStatus())){//仅仅交卷
			record.setStatus(answerResult.getStatus());
			// 更新答案时间
			record.setAnswerUpdateTime(new Date(System.currentTimeMillis()));
			
			this.save(record);
			
			return record;
		}
		
//		// 计算
//		if(!"1".equals(record.getStatus())){// 非提交的就更新
//		}
		record.setStatus(answerResult.getStatus());
		if(!"0".equals(answerResult.getCurrTitleNum())){
			record.setTitleMaxNumber(answerResult.getCurrTitleNum());
		}
		
		// 更新答案时间
		record.setAnswerUpdateTime(new Date(System.currentTimeMillis()));
		
		this.save(record);
		
		return record;
	}
	
	
	/**
	 *提交 错题结果到db
	 * @return
	 */
	public Result doUpdateExerFavorAnswerData(ExerciseSubmitAnswerData answerResult) {
		List<ExerciseItemAnswerData> lstAnswers = answerResult.getItems();
		
		if(lstAnswers.isEmpty()){
			return new Result(true);
		}
		// 批量更新答案
		List<ExerciseFavorite> lstResultFavor =new ArrayList<ExerciseFavorite>(lstAnswers.size());
		
		// 2.1.组装参数 用于查询练习选项图片
		Map<String, Object> argsMap = new HashMap<String, Object>(2);
		Map<String, Object> exerItemIdMap = new HashMap<String, Object>(1);
		Object[] args = new Object[lstAnswers.size()];
		for(int i=0; i<lstAnswers.size(); i++){
			args[i] = lstAnswers.get(i).getExerciseId();
		}
		exerItemIdMap.put("exerciseIds", args);
		argsMap.put("exerciseIds", args);
		argsMap.put(EXERCISE_RECORD_ID, answerResult.getExerciseRecordId());
		
		String hql = "from ExerciseFavorite where deleteFlag is false and exerciseItemId in (:exerciseIds) and favoriteRecordId =:exerciseRecordId ";
		List<ExerciseFavorite> lstFavor = this.findByComplexHql(hql, argsMap, ExerciseFavorite.class);
		
		// 按练习id 对应放到map中
		Map<String, ExerciseFavorite> favorMap = new HashMap<String, ExerciseFavorite>(lstFavor.size());
		for(ExerciseFavorite favor:lstFavor){
			favorMap.put(favor.getExerciseItemId(), favor);
		}
		
		ExerciseFavorite favor;
		for(ExerciseItemAnswerData answer:lstAnswers){
			favor = favorMap.get(answer.getExerciseId());
			if(null == favor){
				continue;
			}
			if(StringUtils.isBlank(answer.getAnswer())){// 答案为空
				continue;
			}
			favor.setAnswer(answer.getAnswer());
			favor.setCorrect(Byte.valueOf(answer.getCorrect()));
			TraceUtils.setUpdateTrace(favor);
			lstResultFavor.add(favor);
		}
		
		this.saveOrUpdateAll(lstResultFavor);
		this.flush();
		
		return new Result(true);
	}
	
	/**
	 * 查询错题本列表数据
	 * @param exerType
	 * @param subjectId
	 * @param pager
	 * @return
	 */
	@Override
	public List<ExerGroupResponseData> queryExerciseFaultListData(
			int exerType, String subjectId, Pager pager) {
		StringBuffer hql = new StringBuffer(512);
		//  1.查询分组列表
		hql.append("select r,g from ExerciseFaultRecord r, ExerciseFaultBook b, ExerciseGroup g "
				+ " where r.resumeBookId=b.resumeBookId "
				+ " and r.exerciseGroupId=g.groupId "
				+ "	and r.deleteFlag is false "
				+ "	and b.deleteFlag is false "
				+ "	and b.userId=?  and r.allCount>0 ");
		
		List<Object> args = CollectionUtils.newList(ClientUtils.getUserId());
		if(exerType != 0){ //表示查询全部错题
			hql.append(" and r.exerciseGroupType=?");
			args.add((short)exerType);
		}
				
		if(StringUtils.isNotBlank(subjectId)){// 高校  通过课程过滤
			
			hql.append(" and b.type=? and b.subjectId=? and g.subjectId=? ");
			args.add(ExerciseFaultBook.TYPE_COLLEGE);
			args.add(subjectId);
			args.add(subjectId);
		}else{// 非高校
			
			hql.append(" and b.type=? and b.classId=? and g.classId=?");
			args.add(ExerciseFaultBook.TYPE_ORGANIZATION);
			args.add(ClientUtils.getClassId());
			args.add(ClientUtils.getClassId());
		}
		hql.append(" order by r.updateTime desc ");
		
		// 根据结构查询得到所需记录
		List<Object[]> lstRecord = this.findList(hql.toString(), pager, args, Object[].class);
		
		if(lstRecord.isEmpty()){// 查询结果记录为空
			return null;
		}
		
		// 3.组装参数
		Object[] argss = new Object[lstRecord.size()];
		ExerciseGroup groupp=null;
		for(int i=0; i<lstRecord.size(); i++){
			groupp = (ExerciseGroup)lstRecord.get(i)[1];
			argss[i] = groupp.getGroupId();
		}
		
		// 获取个人用户组对应的收藏记录 题目更新时间
		Map<String, Map<String, Object>> favorMap = this.queryFavorRecordByGroup(subjectId, argss);
				
		// 结果返回参数
		List<ExerGroupResponseData> lstResult = new ArrayList<ExerGroupResponseData>(lstRecord.size());
		
		for(Object[] objs:lstRecord){
			
			// 组装练习错题本列表数据
			lstResult.add(packagingExerciseFaultListData(
					favorMap, objs));
		}
		
		return lstResult; 
	}

	/**
	 * 组装练习错题本列表数据
	 * @param favorMap
	 * @param objs
	 * @return
	 */
	private ExerGroupResponseData packagingExerciseFaultListData(
			Map<String, Map<String, Object>> favorMap, Object[] objs) {
		ExerciseFaultRecord record = (ExerciseFaultRecord)objs[0];
		ExerciseGroup group = (ExerciseGroup)objs[1];
		
		ExerGroupResponseData resultObj = new ExerGroupResponseData();
		
		// 拆分方法
		packagingExerciseFaultListChildData(record, resultObj);
		
		resultObj.setExtendAllCount(record.getAllCount()==null ? BigInteger.ZERO  : record.getAllCount());
		if(new BigInteger(resultObj.getCurrTitleNumber()).compareTo(resultObj.getExtendAllCount())>0){
			resultObj.setCurrTitleNumber(String.valueOf(resultObj.getExtendAllCount()));
		}
		BeanUtils.copyProperties(group, resultObj);
		resultObj.setExerciseTime(group.getAttribute1());
		resultObj.setUpdateTime(record.getUpdateTime());
		resultObj.setAnswerUpdateTime(record.getAnswerUpdateTime());
		resultObj.setFaultUpdateTime(record.getUpdateTime());
		resultObj.setFaultCount(resultObj.getAllCount());
		if(favorMap != null && favorMap.get(group.getGroupId()) != null){
			resultObj.setFavorUpdateTime((Timestamp)favorMap.get(group.getGroupId()).get(UPDATE_TIME));//设置收藏本题目更新时间
			resultObj.setFavorCount((BigInteger)favorMap.get(group.getGroupId()).get("allCount"));
		}
		
		if(resultObj.getDoCount().compareTo(resultObj.getExtendAllCount())>0){
			resultObj.setDoCount(resultObj.getExtendAllCount());
		}
		return resultObj;
	}
	
	/**
	 * 组装练习错题本列表数据 拆分方法
	 * @param record
	 * @param resultObj
	 */
	private void packagingExerciseFaultListChildData(
			ExerciseFaultRecord record, ExerGroupResponseData resultObj) {
		resultObj.setStatus(record.getStatus());
		resultObj.setGroupId(record.getExerciseGroupId());
		resultObj.setExerciseRecordId(record.getFaultRecordId());
		resultObj.setAccuracy(record.getAccuracy()==null ? BigDecimal.ZERO : record.getAccuracy());
		resultObj.setCorrectCount(record.getCorrectCount()==null ? BigInteger.ZERO : record.getCorrectCount());
		resultObj.setDoCount(record.getDoCount()==null ? BigInteger.ZERO : record.getDoCount());
		resultObj.setCurrTitleNumber(record.getTitleMaxNumber()==null ? "0" : record.getTitleMaxNumber());
	}
	
	/**
	 * 获取个人用户组对应的错题题目更新时间
	 * @param subjectId
	 * @param args
	 * @return
	 */
	@Override
	public Map<String, Map<String, Object>> queryFaultRecordByGroup(String subjectId, Object[] args) {
		StringBuffer hql = new StringBuffer(512);
		//  1.查询分组列表
		hql.append("select r.exerciseGroupId,r.updateTime,r.allCount from ExerciseFaultRecord r, ExerciseFaultBook b "
				+ " where r.resumeBookId=b.resumeBookId "
				+ "	and b.userId = :userId and r.exerciseGroupId in (:groupIds)  ");
		
		Map<String, Object> argsMap = new HashMap<String, Object>(4);
		
		argsMap.put("userId", ClientUtils.getUserId());
		argsMap.put("groupIds", args);
		
		if(StringUtils.isNotBlank(subjectId)){// 高校  通过课程过滤
			
			hql.append(" and b.type=:type and b.subjectId=:subjectId ");
			argsMap.put("type", ExerciseFaultBook.TYPE_COLLEGE);
			argsMap.put("subjectId", subjectId);
		}else{// 非高校
			
			hql.append(" and b.type=:type and b.classId=:classId ");
			argsMap.put("type", ExerciseFaultBook.TYPE_ORGANIZATION);
			argsMap.put("classId", ClientUtils.getClassId());
		}
		
		// 根据结构查询得到所需记录
		List<Object[]> lstRecord = this.findByComplexHql(hql.toString(), argsMap, Object[].class);
		
		Map<String, Map<String, Object>> resultMap = new HashMap<String, Map<String, Object>>(lstRecord.size());
		Map<String, Object> paramMap = null;
		for(Object[] obj:lstRecord){
			paramMap = new HashMap<String, Object>(2);
			paramMap.put(UPDATE_TIME, obj[1]);
			paramMap.put("allCount", obj[2]);
			resultMap.put(String.valueOf(obj[0]), paramMap);
		}
		
		return resultMap;
	}
	
	/**
	 *获取个人用户组对应的收藏题目更新时间
	 * @param subjectId
	 * @param args
	 * @return
	 */
	@Override
	public Map<String, Map<String, Object>> queryFavorRecordByGroup(String subjectId, Object[] args) {
		StringBuffer hql = new StringBuffer(512);
		//  1.查询分组列表
		hql.append("select r.exerciseGroupId,r.updateTime,r.allCount from ExerciseFavoriteRecord r, ExerciseFavoriteBook b"
				+ " where r.favoriteBookId=b.favoriteBookId "
				+ "	and b.userId = :userId and r.exerciseGroupId in (:groupIds)  ");
		
		Map<String, Object> argsMap = new HashMap<String, Object>(4);
		
		argsMap.put("userId", ClientUtils.getUserId());
		argsMap.put("groupIds", args);
		
		if(StringUtils.isNotBlank(subjectId)){// 高校  通过课程过滤
			
			hql.append(" and b.type=:type and b.subjectId=:subjectId ");
			argsMap.put("type", ExerciseFaultBook.TYPE_COLLEGE);
			argsMap.put("subjectId", subjectId);
		}else{// 非高校
			
			hql.append(" and b.type=:type and b.classId=:classId ");
			argsMap.put("type", ExerciseFaultBook.TYPE_ORGANIZATION);
			argsMap.put("classId", ClientUtils.getClassId());
		}
		
		// 根据结构查询得到所需记录
		List<Object[]> lstRecord = this.findByComplexHql(hql.toString(), argsMap, Object[].class);
		Map<String, Map<String, Object>> resultMap = new HashMap<String, Map<String, Object>>(lstRecord.size());
		Map<String, Object> paramMap = null;
		for(Object[] obj:lstRecord){
			paramMap = new HashMap<String, Object>(2);
			paramMap.put(UPDATE_TIME, obj[1]);
			paramMap.put("allCount", obj[2]);
			resultMap.put(String.valueOf(obj[0]), paramMap);
		}
		
		return resultMap;
	}
	
	/**
	 * 查询收藏本列表数据
	 * @param exerType 0:表示全部错题
	 * @param subjectId
	 * @param pager
	 * @return
	 */
	@Override
	public List<ExerGroupResponseData> queryExerciseFavorListData(int exerType,
			String subjectId, Pager pager) {
		StringBuffer hql = new StringBuffer(512);
		//  1.查询分组列表
		hql.append("select r, g from ExerciseFavoriteRecord r, ExerciseFavoriteBook b, ExerciseGroup g"
				+ " where r.favoriteBookId=b.favoriteBookId "
				+ " and r.exerciseGroupId=g.groupId "
				+ "	and r.deleteFlag is false "
				+ "	and b.deleteFlag is false "
				+ " and b.userId=? and r.allCount>0 ");
		
		List<Object> args = CollectionUtils.newList(ClientUtils.getUserId());
		if(exerType != 0){ //表示查询非全部收藏  exerType=0为查询全部收藏
			hql.append(" and r.exerciseGroupType=?");
			args.add((short)exerType);
		}
		
		if(StringUtils.isNotBlank(subjectId)){// 高校  通过课程过滤
			
			hql.append(" and b.type=? and b.subjectId=? and g.subjectId=? ");
			args.add(ExerciseFaultBook.TYPE_COLLEGE);
			args.add(subjectId);
			args.add(subjectId);
		}else{// 非高校
			
			hql.append(" and b.type=? and b.classId=? and g.classId=?");
			args.add(ExerciseFaultBook.TYPE_ORGANIZATION);
			args.add(ClientUtils.getClassId());
			args.add(ClientUtils.getClassId());
		}
		hql.append(" order by r.updateTime desc ");
		
		// 根据结构查询得到所需记录
		List<Object[]> lstRecord = this.findList(hql.toString(), pager, args,Object[].class);
		
		if(lstRecord.isEmpty()){// 查询结果记录为空
			return null;
		}
		
		Object[] argss = new Object[lstRecord.size()];
		ExerciseGroup groupp=null;
		for(int i=0; i<lstRecord.size(); i++){
			groupp = (ExerciseGroup)lstRecord.get(i)[1];
			argss[i] = groupp.getGroupId();
		}
		
		// 获取个人用户组对应的错题记录 题目更新时间
		Map<String, Map<String, Object>> faultMap = this.queryFaultRecordByGroup(subjectId, argss);
		
		// 结果返回参数
		List<ExerGroupResponseData> lstResult = new ArrayList<ExerGroupResponseData>(lstRecord.size());
		
		for(Object[] objs:lstRecord){
			
			// 组装练习收藏列表数据
			lstResult.add(packagingExerciseFavorListData(
					faultMap, objs));
			
		}
		
		return lstResult;
	}
	
	/**
	 * 组装练习收藏列表数据
	 * @param faultMap
	 * @param objs
	 * @return
	 */
	private ExerGroupResponseData packagingExerciseFavorListData(
			Map<String, Map<String, Object>> faultMap, Object[] objs) {
		ExerciseFavoriteRecord record = (ExerciseFavoriteRecord)objs[0];
		ExerciseGroup group = (ExerciseGroup)objs[1];
		
		ExerGroupResponseData resultObj = new ExerGroupResponseData();
		
		// 拆分组装数据
		packagingExerciseFavorListChildData(record, resultObj);
		
		resultObj.setExtendAllCount(record.getAllCount()==null ? BigInteger.ZERO  : record.getAllCount());
		if(new BigInteger(resultObj.getCurrTitleNumber()).compareTo(resultObj.getExtendAllCount())>0){
			resultObj.setCurrTitleNumber(String.valueOf(resultObj.getExtendAllCount()));
		}
		
		BeanUtils.copyProperties(group, resultObj);
		resultObj.setExerciseTime(group.getAttribute1());
		resultObj.setUpdateTime(record.getUpdateTime());
		resultObj.setAnswerUpdateTime(record.getAnswerUpdateTime());
		resultObj.setFavorUpdateTime(record.getUpdateTime());
		resultObj.setFavorCount(resultObj.getAllCount());
		if(faultMap !=null && faultMap.get(group.getGroupId()) !=null){
			resultObj.setFaultUpdateTime((Timestamp)faultMap.get(group.getGroupId()).get(UPDATE_TIME));//设置错题本题目更新时间
			resultObj.setFaultCount((BigInteger)faultMap.get(group.getGroupId()).get("allCount"));
		}
		
		if(resultObj.getDoCount().compareTo(resultObj.getExtendAllCount())>0){
			resultObj.setDoCount(resultObj.getExtendAllCount());
		}
		return resultObj;
	}
	
	/**
	 * 组装练习收藏列表数据 拆分组装数据
	 * @param record
	 * @param resultObj
	 */
	private void packagingExerciseFavorListChildData(
			ExerciseFavoriteRecord record, ExerGroupResponseData resultObj) {
		resultObj.setStatus(record.getStatus());
		resultObj.setGroupId(record.getExerciseGroupId());
		resultObj.setExerciseRecordId(record.getFavoriteRecordId());
		resultObj.setAccuracy(record.getAccuracy()==null ? BigDecimal.ZERO : record.getAccuracy());
		resultObj.setCorrectCount(record.getCorrectCount()==null ? BigInteger.ZERO : record.getCorrectCount());
		resultObj.setDoCount(record.getDoCount()==null ? BigInteger.ZERO : record.getDoCount());
		resultObj.setCurrTitleNumber(record.getTitleMaxNumber()==null ? "0" : record.getTitleMaxNumber());
	}
	

	/**
	 * 获取全部收藏练习数据
	 * @return
	 */
	@Override
	public ExerItemResponseData queryAllExerciseFavorData(Pager pager) {
		//  1.查询此用户是否有错题记录
		String hql = "select item, favor.favorRecord.exerciseGroupId,favor.favorRecord.favorBook.status "
				+ " from ExerciseItem item, ExerciseFavorite favor "
				+ " where item.exerciseId=favor.exerciseItemId"
				+ " and favor.favorRecord.favorBook.classId=?"
				+ " and favor.favorRecord.favorBook.userId=?"
				+ " and item.deleteFlag is false"
				+ " and favor.deleteFlag is false"
				+ " order by favor.createTime";
		
		List<Object[]> lstResult = this.findList(hql, pager, 
				CollectionUtils.newList(ClientUtils.getClassId(), ClientUtils.getUserId()), Object[].class);
		
		
		if(lstResult.isEmpty()){
			return null; 
		}
		
		String status=null;
		ExerciseItem item = null;
		List<ExerciseItem> lstItems = new ArrayList<ExerciseItem>(lstResult.size());
		for(Object[] objs:lstResult){
			if(null != objs[2]) {
				status = String.valueOf(objs[2]);
			}
			item = new ExerciseItem();
			BeanUtils.copyProperties((ExerciseItem)objs[0], item);// 防止item同一个内存地址
			item.setExerciseGroupId(String.valueOf(objs[1]));//设置每个题目的组id
			lstItems.add(item);
		}
		
		// 2.重新组装练习题 加入分析结果
		lstItems =  exerciseVerService.getCommonExerItemDetail(lstItems, null);
		
		// 3.组装答案
		ExerItemResponseData result = new ExerItemResponseData();
				
		result.setItems(lstItems);
		result.setStatus(status);
		
		result.setResult(new Result(true,"查询成功"));
		
		return result; 
	}
	
	/**
	 * 获取收藏练习数据
	 * @param groupId
	 * @param exerciseRecordId 废弃
	 * @return
	 */
	@Override
	public ExerItemResponseData queryExerciseFavorData(String groupId) {
		//  1.查询此用户是否有错题记录
		String hql = "select item, favor "
				+ " from ExerciseItem item, ExerciseFavorite favor "
				+ " where item.exerciseId=favor.exerciseItemId"
				+ " and favor.favorRecord.exerciseGroupId=?"
				+ " and favor.favorRecord.favorBook.userId=?"
				+ " and item.deleteFlag is false"
				+ " and favor.deleteFlag is false"
				+ " order by favor.createTime";
		
		List<Object[]> lstResult = this.findwithRawResult(hql, CollectionUtils.newList(groupId,ClientUtils.getUserId()));
		
		
		return goQueryExerciseFavorData(lstResult, groupId); 
	}
	
	/**
	 * 获取多套收藏练习数据
	 * @param groupId
	 * @return
	 */
	@Override
	public Map<String,Object> queryExerciseMutiFavorData(String groupId) {
		//  1.查询此用户是否有错题记录
		String hql = "select item.exerciseId "
				+ " from ExerciseItem item, ExerciseFavorite favor "
				+ " where item.exerciseId=favor.exerciseItemId"
				+ " and favor.favorRecord.favorBook.userId=?"
				+ " and favor.favorRecord.favorBook.classId=?"
				+ " and favor.favorRecord.exerciseGroupId=?"
				+ " and item.deleteFlag is false"
				+ " and favor.deleteFlag is false"
				+ " order by favor.createTime";
		
		List<String> lstFavor = this.find(hql, CollectionUtils.newList(ClientUtils.getUserId(), 
				ClientUtils.getClassId(), groupId),String.class);
		
		List<Map<String,String>> lstResult = new ArrayList<Map<String,String>>(lstFavor.size());
		Map<String,String>  exerciseIdMap = null;
		for(String exerciseId:lstFavor){
			exerciseIdMap = new HashMap<String, String>(1);
			exerciseIdMap.put("exerciseId", exerciseId);
			lstResult.add(exerciseIdMap);
		}
		
		Map<String,Object> resultMap = new HashMap<String, Object>(2);
		resultMap.put("exerciseGroupId", groupId);
		resultMap.put("exerciseIds", lstResult);
		
		return resultMap; 
	}
	
	/**
	 * 查询收藏题目明细
	 * @param lstResult
	 * @param groupId
	 * @return
	 */
	public ExerItemResponseData goQueryExerciseFavorData(List<Object[]> lstResult, String groupId) {
		if(lstResult.isEmpty()){
			return null; 
		}
		
		List<ExerciseItem> lstItems = new ArrayList<ExerciseItem>(lstResult.size());
		ExerciseItem item;
		List<ExerciseItemAnswerU> lstAnswers = new ArrayList<ExerciseItemAnswerU>(lstResult.size());
		ExerciseItemAnswerU answerU;
		
		ExerciseFavorite favor;
		for(Object[] objs:lstResult){
			
			item = (ExerciseItem)objs[0];
			lstItems.add(item);
			
			favor = (ExerciseFavorite)objs[1];
			
			if(StringUtils.isNotBlank(favor.getAnswer())){
				answerU = new ExerciseItemAnswerU();
				answerU.setAnswer(favor.getAnswer());
				answerU.setCorrect(favor.getCorrect());
				answerU.setAnswerUId(favor.getExerciseFavoriteId());
				answerU.setExerciseItemId(favor.getExerciseItemId());
				answerU.setExerciseRecordId(favor.getFavoriteRecordId());
				lstAnswers.add(answerU);
			}
			
		}
		
		// 2.重新组装练习题 加入分析结果
		lstItems =  exerciseVerService.getCommonExerItemDetail(lstItems, groupId);
		
		
		// 3.组装答案
		ExerItemResponseData result = new ExerItemResponseData();
				
		result.setExerciseGroupId(groupId);
		
		result.setItems(lstItems);
		
		result.setAnswers(lstAnswers);
		
		result.setResult(new Result(true,"查询成功"));
		
		return result; 
	}
	
	/**
	 * 获取全部错题练习数据
	 * @return
	 */
	@Override
	public ExerItemResponseData queryAllExerciseFaultData(Pager pager) {
		//  1.查询此用户是否有错题记录
		String hql = "select item, fault.faultRecord.exerciseGroupId,fault.faultRecord.faultBook.status "
				+ " from ExerciseItem item, ExerciseFault fault "
				+ " where item.exerciseId=fault.exerciseItemId"
				+ " and fault.faultRecord.faultBook.userId=?" 
				+ " and fault.faultRecord.faultBook.classId=?"
				+ " and item.deleteFlag is false"
				+ " and fault.deleteFlag is false"
				+ " order by fault.createTime";
		
		List<Object[]> lstResult = this.findList(hql, pager, CollectionUtils.newList(ClientUtils.getUserId(),ClientUtils.getClassId()),Object[].class);
		
		
		if(lstResult.isEmpty()){
			return null; 
		}
		
		List<ExerciseItem> lstItems = new ArrayList<ExerciseItem>(lstResult.size());
		ExerciseItem item = null;
		String status=null;
		for(Object[] objs:lstResult){
			if(objs[2] !=null) {
				status=String.valueOf(objs[2]);//获取全部题目的提交状态
			}
			item = new ExerciseItem();
			BeanUtils.copyProperties((ExerciseItem)objs[0], item);// 防止item同一个内存地址
			item.setExerciseGroupId(String.valueOf(objs[1]));//设置每个题目的组id
			lstItems.add(item);
		}
		
		// 2.重新组装练习题 加入分析结果
		lstItems = exerciseVerService.getCommonExerItemDetail(lstItems, null);
		
		
		// 3.组装答案
		ExerItemResponseData result = new ExerItemResponseData();
		
		result.setStatus(status);
		result.setItems(lstItems);
		
		result.setResult(new Result(true,"查询成功"));
		
		return result; 
	}
	
	/**
	 * 获取单套题错题练习数据
	 * @param groupId
	 * @return
	 */
	@Override
	public ExerItemResponseData queryExerciseFaultData(String groupId) {
		//  1.查询此用户是否有错题记录
		String hql = "select item, fault "
				+ " from ExerciseItem item, ExerciseFault fault "
				+ " where item.exerciseId=fault.exerciseItemId"
				+ " and fault.faultRecord.faultBook.userId=?"
				+ " and fault.faultRecord.exerciseGroupId=?"
				+ " and item.deleteFlag is false"
				+ " and fault.deleteFlag is false"
				+ " order by fault.createTime";
		// 2.查询答案
		
		List<Object[]> lstResult = this.findwithRawResult(hql, CollectionUtils.newList(ClientUtils.getUserId(), groupId));
		
		return goQueryExerciseFaultData(lstResult, groupId); 
	}
	
	/**
	 * 获取多套题错题练习数据
	 * @param groupId
	 * @return
	 */
	@Override
	public Map<String,Object> queryExerciseMutiFaultData(String groupId) {
		
		//  1.查询题目
		String hql = "select item.exerciseId "
				+ " from ExerciseItem item, ExerciseFault fault "
				+ " where item.exerciseId=fault.exerciseItemId"
				+ " and fault.faultRecord.faultBook.userId=?"
				+ " and fault.faultRecord.faultBook.classId=?"
				+ " and fault.faultRecord.exerciseGroupId=?"
				+ " and item.deleteFlag is false"
				+ " and fault.deleteFlag is false"
				+ " order by fault.createTime";
		
		List<String> lstFault = this.find(hql, CollectionUtils.newList(ClientUtils.getUserId(), 
				ClientUtils.getClassId(), groupId),String.class);
		
		List<Map<String,String>> lstResult = new ArrayList<Map<String,String>>(lstFault.size());
		Map<String,String>  exerciseIdMap = null;
		for(String exerciseId:lstFault){
			exerciseIdMap = new HashMap<String, String>(1);
			exerciseIdMap.put("exerciseId", exerciseId);
			lstResult.add(exerciseIdMap);
		}
		
		Map<String,Object> resultMap = new HashMap<String, Object>(2);
		resultMap.put("exerciseGroupId", groupId);
		resultMap.put("exerciseIds", lstResult);
		
		return resultMap; 
	}
	
	
	/**
	 * 查询错题明细数据
	 * @param lstResult
	 * @param groupId
	 * @return
	 */
	public ExerItemResponseData goQueryExerciseFaultData(List<Object[]> lstResult, String groupId) {
		if(lstResult.isEmpty()){
			return null; 
		}
		
		List<ExerciseItem> lstItems = new ArrayList<ExerciseItem>(lstResult.size());
		ExerciseItem item;
		List<ExerciseItemAnswerU> lstAnswers = new ArrayList<ExerciseItemAnswerU>(lstResult.size());
		ExerciseItemAnswerU answerU;
		
		ExerciseFault fault;
		for(Object[] objs:lstResult){
			
			item = (ExerciseItem)objs[0];
			if(StringUtils.isBlank(groupId)){// 表示查询所有错题
				item.setExerciseGroupId(String.valueOf(objs[2]));//设置每个题目的组id
			}
			lstItems.add(item);
			
			fault = (ExerciseFault)objs[1];
			
			
			if(StringUtils.isNotBlank(fault.getAnswer())){
				answerU = new ExerciseItemAnswerU();
				answerU.setAnswer(fault.getAnswer());
				answerU.setCorrect(fault.getCorrect());
				answerU.setAnswerUId(fault.getExerciseFaultId());
				answerU.setExerciseItemId(fault.getExerciseItemId());
				answerU.setExerciseRecordId(fault.getFaultRecordId());
				lstAnswers.add(answerU);
			}
		}
		
		// 2.重新组装练习题 加入分析结果
		lstItems = exerciseVerService.getCommonExerItemDetail(lstItems, groupId);
		
		
		// 3.组装答案
		ExerItemResponseData result = new ExerItemResponseData();
		
		result.setExerciseGroupId(groupId);
				
		result.setItems(lstItems);
		
		result.setAnswers(lstAnswers);
		
		result.setResult(new Result(true,"查询成功"));
		
		return result; 
	}
	
	/**
	 * 获取收藏本答案数据 
	 */
	@Override
	public ExerItemResponseData queryExerciseFavorAnswerData(String groupId) {
		
		String hql = "select f "
				+ " from ExerciseFavorite f "
				+ " where f.favorRecord.exerciseGroupId=?"
				+ " and f.favorRecord.favorBook.userId=?"
				+ " and f.favorRecord.favorBook.classId=?"
				+ " and f.answer is not null and f.deleteFlag is false";
		
		//  1.查询错题
		List<ExerciseFavorite> lstFavors = this.find(hql, CollectionUtils.newList(groupId,
				ClientUtils.getUserId(),ClientUtils.getClassId()), ExerciseFavorite.class);
		
		List<ExerciseItemAnswerU> lstAnswers = new ArrayList<ExerciseItemAnswerU>(lstFavors.size());
		ExerciseItemAnswerU answerU;
		
		for(ExerciseFavorite favor:lstFavors){
			answerU = new ExerciseItemAnswerU();
			answerU.setAnswer(favor.getAnswer());
			answerU.setCorrect(favor.getCorrect());
			answerU.setExerciseItemId(favor.getExerciseItemId());
			lstAnswers.add(answerU);
		}
			
		// 3.组装答案
		ExerItemResponseData result = new ExerItemResponseData();
				
		result.setAnswers(lstAnswers);
		result.setExerciseGroupId(groupId);
		
		return result; 
	}
	
	/**
	 * 获取错题本答案数据 
	 */
	@Override
	public ExerItemResponseData queryExerciseFaultAnswerData(String groupId) {
		
		String hql = "select f "
				+ " from ExerciseFault f "
				+ " where f.faultRecord.exerciseGroupId=?"
				+ " and f.faultRecord.faultBook.userId=?"
				+ " and f.faultRecord.faultBook.classId=?"
				+ " and f.answer is not null and f.deleteFlag is false";
		
		//  1.查询错题
		List<ExerciseFault> lstFaults = this.find(hql, CollectionUtils.newList(groupId, 
				ClientUtils.getUserId(),ClientUtils.getClassId()), ExerciseFault.class);
		
		List<ExerciseItemAnswerU> lstAnswers = new ArrayList<ExerciseItemAnswerU>(lstFaults.size());
		ExerciseItemAnswerU answerU;
		
		for(ExerciseFault fault:lstFaults){
			answerU = new ExerciseItemAnswerU();
			answerU.setAnswer(fault.getAnswer());
			answerU.setCorrect(fault.getCorrect());
			answerU.setExerciseItemId(fault.getExerciseItemId());
			lstAnswers.add(answerU);
		}
			
		// 3.组装答案
		ExerItemResponseData result = new ExerItemResponseData();
				
		result.setAnswers(lstAnswers);
		result.setExerciseGroupId(groupId);
		
		return result; 
	}

	/**
	 * 操作本次做题记录
	 * groupId 习题组ID  如果为All时，表示全部错题、全部收藏
	 * @return
	 */
	@Override
	public Map<String, Object> doUpdateFaultExerRecordNew(String groupId) {
		
		if("All".equals(groupId)){//表示全部错题重做
			return doCleanAllFaultRecordByRedo();
		}
		
		String hql="select r from ExerciseFaultRecord r,ExerciseFaultBook b where"
				+ " r.resumeBookId=b.resumeBookId and r.exerciseGroupId=? and b.userId=? and b.classId=? and b.type=?";
		
		ExerciseFaultRecord record = this.findUnique(hql, CollectionUtils.newList(groupId,
				ClientUtils.getUserId(), ClientUtils.getClassId(),ExerciseFaultBook.TYPE_ORGANIZATION), ExerciseFaultRecord.class);
		
		if(null == record){
			return null;
		}
		
		record.setScore(BigDecimal.ZERO);
		record.setCompletionRate(BigDecimal.ZERO);
		record.setDoCount(BigInteger.ZERO);
		record.setCorrectCount(BigInteger.ZERO);
		record.setAccuracy(BigDecimal.ZERO);
		record.setTitleMaxNumber("0");
		record.setStatus("0");
		
		TraceUtils.setUpdateTrace(record);
		
		this.save(record);
		
		String faultRecordId = record.getFaultRecordId();
		
		//  重新做题 清理旧数据 
		doOperExerciseFaultRecordByRedo(faultRecordId);
		
		
		// 更新全部收藏题目的信息
		this.doOperFaultBookBySubmitAllAnswer(
				null, null, record.getResumeBookId(),null);
		
		
		Map<String,Object> resultMap = new HashMap<String, Object>(3);
		resultMap.put(EXERCISE_RECORD_ID, faultRecordId);
		resultMap.put("exerciseGroupId", groupId);
		resultMap.put(UPDATE_TIME,  DateTimeUtils.getCurrDateTime(record.getUpdateTime()));
		
		return resultMap;
	}
	
	/**
	 * 全部错题重做
	 * @return
	 */
	private Map<String,Object> doCleanAllFaultRecordByRedo(){
		
		/** 1.更新错题book记录为初始值 */
		String hql_book = "from ExerciseFaultBook b where b.userId=? and b.classId=? and b.type=? ";
		
		ExerciseFaultBook book = this.findUnique(hql_book, CollectionUtils.newList(ClientUtils.getUserId(),
				ClientUtils.getClassId(),ExerciseFaultBook.TYPE_ORGANIZATION), ExerciseFaultBook.class);
		
		if(book == null){
			return null;
		}
		
		book.setScore(BigDecimal.ZERO);
		book.setCompletionRate(BigDecimal.ZERO);
		book.setDoCount(BigInteger.ZERO);
		book.setCorrectCount(BigInteger.ZERO);
		book.setAccuracy(BigDecimal.ZERO);
		book.setTitleMaxNumber("0");
		book.setStatus("0");
		TraceUtils.setUpdateTrace(book);
		this.save(book);
		
		String resumeBookId = book.getResumeBookId();
		BigDecimal decimalZero = BigDecimal.ZERO;
		BigInteger integerZero = BigInteger.ZERO;
		
		/** 2.更新所有错题record记录为初始值 */
		String hql_record = "update ExerciseFaultRecord t set t.score="+decimalZero+", t.completionRate="+decimalZero+", t.doCount="+integerZero+","
				+ "  t.correctCount="+integerZero+", t.accuracy="+decimalZero+", t.titleMaxNumber='0', t.status='0'"
				+ "  where t.resumeBookId=? and t.deleteFlag is false";
		
		this.bulkUpdateInLoop(hql_record, new String[]{resumeBookId});
		
		
		/** 3.重新做题 清理所有旧数据    */
		// 3.1复制错题数据到历史表
		String hql_fault = "from ExerciseFault where resumeBookId=? and answer is not null and deleteFlag is false";
		doCopyExerciseFaultToHis(hql_fault,resumeBookId);
		
		// 3.2清空错题做题记录
		String hql_delFault = "update ExerciseFault t set t.answer=null,t.correct=0"
				+ " where t.resumeBookId=? and t.answer is not null and t.deleteFlag is false";
		this.bulkUpdateInLoop(hql_delFault, new String[]{resumeBookId});
		
		/** 4.返回结果    */
		Map<String,Object> resultMap = new HashMap<String, Object>(3);
		resultMap.put(EXERCISE_RECORD_ID, null);
		resultMap.put("exerciseGroupId", "All");
		resultMap.put(UPDATE_TIME, book.getUpdateTime());
		
		return resultMap;
	}
	
	/**
	 * 重新做题 清理旧数据 
	 * @param faultRecordId
	 * @return
	 */
	public Result doOperExerciseFaultRecordByRedo(String faultRecordId){
		
		// 1.拷贝做题记录到错题答案历史表
		String hql = "from ExerciseFault where faultRecordId=? and answer is not null and deleteFlag is false";
		doCopyExerciseFaultToHis(hql, faultRecordId);
		
		// 2.删除做题记录
		deleteExerciseFaultRecord(faultRecordId);
				
		return new Result(true);
	}
	
	/**
	 * 拷贝做题记录到错题答案历史表
	 * @param faultRecordId/resumeBookId
	 * @return
	 */
	public Result doCopyExerciseFaultToHis(String hql,String recordId){
		List<ExerciseFault> lstFault = this.find(hql, CollectionUtils.newList(recordId), ExerciseFault.class);
		
		// 错题历史记录表
		List<ExerciseFaultHis> lstFaultHis = new ArrayList<ExerciseFaultHis>(lstFault.size());
		ExerciseFaultHis his = null;
		for(ExerciseFault fault:lstFault){
			his = new ExerciseFaultHis();
			BeanUtils.copyProperties(fault, his);
			his.setUpdateTime(new Date(System.currentTimeMillis()));
			
			lstFaultHis.add(his);
		}
		
		this.saveOrUpdateAll(lstFaultHis);
		
		return new Result(true);
	}
	
	/**
	 * 批量刪除错题做题记录
	 * @param faultRecordId
	 * @return
	 */
	public Result deleteExerciseFaultRecord(String faultRecordId){
		
		String hql = "update ExerciseFault t set t.answer=null,t.correct=0"
				+ " where t.faultRecordId=? and t.answer is not null and t.deleteFlag is false";
		
		Result result = this.bulkUpdateInLoop(hql, new String[]{faultRecordId});
		this.flush();
		return result;
	}
	
	/**
	 * 批量刪除错题做题记录
	 * @param faultRecordId
	 * @return
	 */
	public Result deleteExerciseFavorRecord(String favorRecordId){
		
		String hql = "update ExerciseFavorite t set t.answer=null,t.correct=0"
				+ " where t.favoriteRecordId=? and t.deleteFlag is false";
		
		Result result = this.bulkUpdateInLoop(hql, new String[]{favorRecordId});
		this.flush();
		return result;
	}
	
	/**
	 * 操作本次做题记录 收藏
	 * @return
	 */
	@Override
	public Map<String, Object> doUpdateFavortExerRecordNew(String groupId) {
		
		if("All".equals(groupId)){//表示全部收藏重做
			return doCleanAllFavorRecordByRedo();
		}
		
		
		String hql="select r from ExerciseFavoriteRecord r,ExerciseFavoriteBook b where"
				+ " r.favoriteBookId=b.favoriteBookId and r.exerciseGroupId=? and b.userId=? and b.classId=? ";
		
		ExerciseFavoriteRecord record = this.findUnique(hql, CollectionUtils.newList(groupId,
				ClientUtils.getUserId(), ClientUtils.getClassId()), ExerciseFavoriteRecord.class);
		
		if(null == record){
			return null;
		}
		
		record.setScore(BigDecimal.ZERO);
		record.setCompletionRate(BigDecimal.ZERO);
		record.setDoCount(BigInteger.ZERO);
		record.setCorrectCount(BigInteger.ZERO);
		record.setAccuracy(BigDecimal.ZERO);
		record.setTitleMaxNumber("0");
		record.setStatus("0");
		
		TraceUtils.setUpdateTrace(record);
		
		this.save(record);
		
		String favoriteRecordId = record.getFavoriteRecordId();
	
		//  重新开始做题 清理旧数据
		doOperExerciseFavorRecordByRedo(favoriteRecordId);
		
		// 更新全部收藏题目的统计信息
		this.doOperFavorBookBySubmitAllAnswer(null, null, record.getFavoriteBookId(),null);
		
		Map<String,Object> resultMap = new HashMap<String, Object>(3);
		resultMap.put(EXERCISE_RECORD_ID, favoriteRecordId);
		resultMap.put(UPDATE_TIME, DateTimeUtils.getCurrDateTime(record.getUpdateTime()));
		return resultMap;
	}
	
	/**
	 * 全部收藏重做
	 * @return
	 */
	private Map<String,Object> doCleanAllFavorRecordByRedo(){
		
		/** 1.更新收藏book记录为初始值 */
		String hql_book = "from ExerciseFavoriteBook b where b.userId=? and b.classId=? and b.type=? ";
		
		ExerciseFavoriteBook book = this.findUnique(hql_book, CollectionUtils.newList(ClientUtils.getUserId(),
				ClientUtils.getClassId(),ExerciseFaultBook.TYPE_ORGANIZATION), ExerciseFavoriteBook.class);
		
		if(book == null){
			return null;
		}
		
		book.setScore(BigDecimal.ZERO);
		book.setCompletionRate(BigDecimal.ZERO);
		book.setDoCount(BigInteger.ZERO);
		book.setCorrectCount(BigInteger.ZERO);
		book.setAccuracy(BigDecimal.ZERO);
		book.setTitleMaxNumber("0");
		book.setStatus("0");
		TraceUtils.setUpdateTrace(book);
		this.save(book);
		
		String favoriteBookId = book.getFavoriteBookId();
		BigDecimal decimalZero = BigDecimal.ZERO;
		BigInteger integerZero = BigInteger.ZERO;
		
		/** 2.更新所有收藏record记录为初始值 */
		String hql_record = "update ExerciseFavoriteRecord t set t.score="+decimalZero+", t.completionRate="+decimalZero+", t.doCount="+integerZero+","
				+ "  t.correctCount="+integerZero+", t.accuracy="+decimalZero+", t.titleMaxNumber='0', t.status='0'"
				+ "  where t.favoriteBookId=? and t.deleteFlag is false";
		
		this.bulkUpdateInLoop(hql_record, new String[]{favoriteBookId});
		
		
		/** 3.重新做题 清理所有旧数据    */
		// 3.1复制收藏数据到历史表
		String hql_favor = "from ExerciseFavorite where favoriteBookId=? and answer is not null and deleteFlag is false";
		doCopyExerciseFavorToHis(hql_favor,favoriteBookId);
		
		// 3.2清空收藏做题记录
		String hql_delFavor = "update ExerciseFavorite t set t.answer=null,t.correct=0"
				+ " where t.favoriteBookId=? and t.answer is not null and t.deleteFlag is false";
		this.bulkUpdateInLoop(hql_delFavor, new String[]{favoriteBookId});
		
		/** 4.返回结果    */
		Map<String,Object> resultMap = new HashMap<String, Object>(3);
		resultMap.put(EXERCISE_RECORD_ID, null);
		resultMap.put("exerciseGroupId", "All");
		resultMap.put(UPDATE_TIME, book.getUpdateTime());
		
		return resultMap;
	}
	
	/**
	 * 重新开始做题 清理旧数据
	 * @param favoriteRecordId
	 * @return
	 */
	public Result doOperExerciseFavorRecordByRedo(String favoriteRecordId){
		
		// 1.拷贝做题记录到收藏答案历史表
		String hql = "from ExerciseFavorite where favoriteRecordId=? and answer is not null and deleteFlag is false";
		doCopyExerciseFavorToHis(hql, favoriteRecordId);
		
		// 2.删除做题记录
		deleteExerciseFavorRecord(favoriteRecordId);
		
		return new Result(true);
	}
	
	/**
	 * 拷贝做题记录到收藏答案历史表
	 * @param faultRecordId/favoriteBookId
	 * @return
	 */
	public Result doCopyExerciseFavorToHis(String hql, String recordId){
		List<ExerciseFavorite> lstFavor = this.find(hql, CollectionUtils.newList(recordId), ExerciseFavorite.class);
		
		// 错题历史记录表
		List<ExerciseFavoriteHis> lstFavorHis = new ArrayList<ExerciseFavoriteHis>(lstFavor.size());
		ExerciseFavoriteHis his = null;
		for(ExerciseFavorite favor:lstFavor){
			his = new ExerciseFavoriteHis();
			BeanUtils.copyProperties(favor, his);
			his.setUpdateTime(new Date(System.currentTimeMillis()));
			
			lstFavorHis.add(his);
		}
		
		this.saveOrUpdateAll(lstFavorHis);
		
		return new Result(true);
	}
	
	/**
	 * 查询题目统计分析结果 个人统计 全站统计
	 * @param exerciseType
	 * @return
	 */
	@Override
	public List<Map<String, Object>> queryExerciseItemStatisics(String exerciseType) {
		// 题目个人统计
		String hql_analisisU = "";
		// 题目全站统计
		String hql_analisis = "";
		// 题目
		String hql_item = "";
		
		if(Constants.EXERCISE_TYPE_FAULT.equals(exerciseType)){// 错题本
			
			hql_analisisU = "select a from ExerciseItemAnalisiU a,ExerciseFault re"
					+ " where a.exerciseItemId=re.exerciseItemId "
					+ " and a.userId=? and re.faultBook.userId=? and re.faultBook.classId=?"
					+ " and a.deleteFlag is false and re.deleteFlag is false ";
			
			hql_analisis = "select a from ExerciseItemAnalisi a, ExerciseFault re"
					+ " where a.exerciseItemId=re.exerciseItemId "
					+ " and re.faultBook.userId=? and re.faultBook.classId=?"
					+ " and a.deleteFlag is false and re.deleteFlag is false ";
			
			hql_item = "select re.exerciseItemId from ExerciseFault re"
					+ " where re.faultBook.userId=? and re.faultBook.classId=? "
					+ " and re.deleteFlag is false order by re.createTime";
			
		}else if(Constants.EXERCISE_TYPE_FAVORT.equals(exerciseType)){// 收藏
			
			hql_analisisU =  "select a from ExerciseItemAnalisiU a,ExerciseFavorite re"
					+ " where a.exerciseItemId=re.exerciseItemId "
					+ " and a.userId=? and re.favorBook.userId=? and re.favorBook.classId=?"
					+ " and a.deleteFlag is false and re.deleteFlag is false ";
			
			hql_analisis = "select a from ExerciseItemAnalisi a, ExerciseFavorite re"
					+ " where a.exerciseItemId=re.exerciseItemId "
					+ " and re.favorBook.userId=? and re.favorBook.classId=?"
					+ " and a.deleteFlag is false and re.deleteFlag is false ";
			
			hql_item =  "select re.exerciseItemId from ExerciseFavorite re"
					+ " where re.favorBook.userId=? and re.favorBook.classId=? "
					+ " and re.deleteFlag is false order by re.createTime";
		}
		
		List<Map<String, Object>> resultLst = this.doQueryExerciseItemStatisicsData(hql_analisisU, hql_analisis, hql_item);
		
		return resultLst;
	}
	
	/**
	 * 查询错题题目统计
	 * @return
	 */
	private List<Map<String, Object>> doQueryExerciseItemStatisicsData(String hql_analisisU,
			String hql_analisis, String hql_item) {
		// 1.查询个人统计
		List<ExerciseItemAnalisiU> lstAnalisiU = this.find(hql_analisisU,
				CollectionUtils.newList(ClientUtils.getUserId(),ClientUtils.getUserId(),ClientUtils.getClassId()), ExerciseItemAnalisiU.class);
		
		Map<String, ExerciseItemAnalisiU> anasisUMap = new HashMap<String, ExerciseItemAnalisiU>(lstAnalisiU.size());
		for(ExerciseItemAnalisiU analisisU:lstAnalisiU){
			anasisUMap.put(analisisU.getExerciseItemId(), analisisU);
		}
		
		// 2.查询全站统计
		List<ExerciseItemAnalisi> lstAnalisi = this.find(hql_analisis,
				CollectionUtils.newList(ClientUtils.getUserId(),ClientUtils.getClassId()), ExerciseItemAnalisi.class);
		Map<String, ExerciseItemAnalisi> anasisMap = new HashMap<String, ExerciseItemAnalisi>(lstAnalisi.size());
		for(ExerciseItemAnalisi analisi:lstAnalisi){
			anasisMap.put(analisi.getExerciseItemId(), analisi);
		}
		
		if(lstAnalisiU.isEmpty() && lstAnalisi.isEmpty()){
			return null;
		}
		
		// 3.查询此组所有题目
		List<String> lstItemIds = this.find(hql_item,
				CollectionUtils.newList(ClientUtils.getUserId(),ClientUtils.getClassId()), String.class);
		
		List<Map<String, Object>> lstResult = new ArrayList<Map<String, Object>>(lstItemIds.size());
		Map<String, Object> resultMap = null;
		ExerciseItemAnalisi analisis;
		ExerciseItemAnalisiU analisisU;
		
		// 3.组装结果 
		
		// 循坏组所有题目
		for(String  exerciseItemId:lstItemIds){
			// 结果map
			resultMap = new HashMap<String, Object>(10);
			
			// 1.个人分析结果
			analisisU = anasisUMap.get(exerciseItemId);
			// 2.全站分析结果
			analisis = anasisMap.get(exerciseItemId);
			
			resultMap.put("exerciseId", exerciseItemId);
			
			// 3.个人统计
			if(null == analisisU){// 为空
				resultMap.put("doAll_u", 0);
				resultMap.put("doError_u", 0);
				resultMap.put("doAccuracy_u", 0);
			}else{
				resultMap.put("doAll_u", analisisU.getSubmitNumber());
				resultMap.put("doError_u", analisisU.getSubmitNumber().subtract(analisisU.getSubmitCorrectNumber()));
				resultMap.put("doAccuracy_u", analisisU.getAccuracy());
			}
			
			// 4.全站统计
			if(null == analisis){// 为空
				resultMap.put("doAll", 0);
				resultMap.put("doAccuracy", 0);
			}else{
				resultMap.put("doAll", analisis.getSubmitNumber());
				resultMap.put("doAccuracy", analisis.getAccuracy());
			}
			
			lstResult.add(resultMap);
		}
		
		
		return lstResult;
	}
	
	/**
	 * 更新错题book信息
	 * @param faultBookId
	 * @return
	 */
	@SuppressWarnings("unchecked")
	private void updateExerciseFaultBookInfo(ExerciseFaultBook book){
		
		String sql = "SELECT"+
				" count(1) allCount,"+
				" sum(CORRECT = 1) corrCount,"+
				" sum(ANSWER IS NOT NULL) doCount,"+
				" round(sum(CORRECT = 1) / count(1) * 100,2) accuracy,"+
				" round(sum(ANSWER IS NOT NULL) / count(1) * 100,2) rate"+
				" FROM exercise_fault"+
				" WHERE DELETE_FLAG = 0"+
				" AND RESUME_BOOK_ID = ?";

		List<Object[]> lstFault = this.findBySql(sql,  CollectionUtils.newList(book.getResumeBookId()));
		
		Object[] objs = lstFault.get(0);
		book.setAllCount((BigInteger)objs[0]);
		book.setCorrectCount(new BigInteger(String.valueOf(objs[1]==null ? "0" : objs[1])));
		book.setDoCount(new BigInteger(String.valueOf(objs[2]==null ? "0" : objs[2])));
		book.setAccuracy(new BigDecimal(String.valueOf(objs[3]==null ? "0" : objs[3])));
		book.setCompletionRate(new BigDecimal(String.valueOf(objs[4]==null ? "0" : objs[4])));
		book.setScore(book.getAccuracy());
	}
	
	/**
	 * 更新错题book信息 by提交全部错题答案
	 * @param currTitleNum
	 * @param status
	 * @return
	 */
	@Override
	public Result doOperFaultBookBySubmitAllAnswer(String currTitleNum,
			String status,String faultBookId, String exerciseType) {
		ExerciseFaultBook book = null;
		if(StringUtils.isBlank(faultBookId)){// 是否全部错题  仅仅提交操作
			if(Constants.EXERCISE_TYPE_FAULT.equals(exerciseType)
				&& ExerciseRecord.STATUS_SUBMIT.equals(status)){// 全部错题仅提交答案
				
				book = this.findUnique("from ExerciseFaultBook where classId=? and userId=? and type=? and deleteFlag is false ",
						CollectionUtils.newList(ClientUtils.getClassId(), 
						ClientUtils.getUserId(),ExerciseFaultBook.TYPE_ORGANIZATION), ExerciseFaultBook.class);
				
			}else{
				return new Result(false);
			}
			
		}else{// 混合提交
			book = this.read(ExerciseFaultBook.class, faultBookId);
			if(book == null){
				return new Result(false);
			}
		}
		
		// 更新book信息
		this.updateExerciseFaultBookInfo(book);
		
		if(StringUtils.isNotBlank(currTitleNum)){
			book.setTitleMaxNumber(currTitleNum);
		}
		if(StringUtils.isNotBlank(status)){
			book.setStatus("1".equals(status)?"1":"0");// 1：提交 0：未提交
			
			if("1".equals(status)){// 全部错题提交答案时  对应的record也改为提交状态
				
				/** 更新所有错题record记录为提交状态 */
				String hql_record = "update ExerciseFaultRecord t set t.status='1'"
						+ "  where t.resumeBookId=? and t.deleteFlag is false";
				
				this.bulkUpdateInLoop(hql_record, new String[]{book.getResumeBookId()});
			}
		}
		
		TraceUtils.setUpdateTrace(book);
		this.save(book);
		
		return new Result(true);
	}

	/**
	 * 更新收藏book信息
	 * @param faultBookId
	 * @return
	 */
	@SuppressWarnings("unchecked")
	private void updateExerciseFavorBookInfo(ExerciseFavoriteBook book){
		String sql = "SELECT"+
				" count(1) allCount,"+
				" sum(CORRECT = 1) corrCount,"+
				" sum(ANSWER IS NOT NULL) doCount,"+
				" round(sum(CORRECT = 1) / count(1) * 100,2) accuracy,"+
				" round(sum(ANSWER IS NOT NULL) / count(1) * 100,2) rate"+
				" FROM exercise_favorite"+
				" WHERE DELETE_FLAG = 0"+
				" AND FAVORITE_BOOK_ID = ?";

		List<Object[]> lstFault = this.findBySql(sql,  CollectionUtils.newList(book.getFavoriteBookId()));
		
		Object[] objs = lstFault.get(0);
		book.setAllCount((BigInteger)objs[0]);
		book.setCorrectCount(new BigInteger(String.valueOf(objs[1]==null ? "0" : objs[1])));
		book.setDoCount(new BigInteger(String.valueOf(objs[2]==null ? "0" : objs[2])));
		book.setAccuracy(new BigDecimal(String.valueOf(objs[3]==null ? "0" : objs[3])));
		book.setCompletionRate(new BigDecimal(String.valueOf(objs[4]==null ? "0" : objs[4])));
		book.setScore(book.getAccuracy());
	}
	
	/**
	 * 更新收藏book信息 by提交全部收藏答案
	 * @param currTitleNum
	 * @param status
	 * @return
	 */
	@Override
	public Result doOperFavorBookBySubmitAllAnswer(String currTitleNum,
			String status,String favoriteBookId, String exerciseType) {
		
		ExerciseFavoriteBook book = null;
		if(StringUtils.isBlank(favoriteBookId)){// 是否全部收藏  仅仅提交操作
			if(Constants.EXERCISE_TYPE_FAVORT.equals(exerciseType)
				&& ExerciseRecord.STATUS_SUBMIT.equals(status)){// 全部错题仅提交答案
				
				book = this.findUnique("from ExerciseFavoriteBook where classId=? and userId=? and type=? and deleteFlag is false ",
						CollectionUtils.newList(ClientUtils.getClassId(), 
						ClientUtils.getUserId(),ExerciseFaultBook.TYPE_ORGANIZATION), ExerciseFavoriteBook.class);
				
			}else{
				return new Result(false);
			}
			
		}else{// 混合提交
			book = this.read(ExerciseFavoriteBook.class, favoriteBookId);
			if(book == null){
				return new Result(false);
			}
		}
		
		// 更新收藏book信息
		this.updateExerciseFavorBookInfo(book);
		
		if(StringUtils.isNotBlank(currTitleNum)){
			book.setTitleMaxNumber(currTitleNum);
		}
		
		if(StringUtils.isNotBlank(status)){
			book.setStatus("1".equals(status)?"1":"0");// 1：提交 0：未提交
			
			if("1".equals(status)){// 全部收藏提交答案时  对应的record也改为提交状态
				
				/** 更新所有收藏record记录为提交状态 */
				String hql_record = "update ExerciseFavoriteRecord t set t.status='1'"
						+ "  where t.favoriteBookId=? and t.deleteFlag is false";
				
				this.bulkUpdateInLoop(hql_record, new String[]{book.getFavoriteBookId()});
			}
		}
		
		TraceUtils.setUpdateTrace(book);
		this.save(book);
		
		return new Result(true);
	}
	
	/**
	 * 查询错题本book信息
	 */
	@Override
	public Map<String, Object> queryExerFaultInfo() {
		String hql = "from ExerciseFaultBook where classId=? and userId=? and type=? and deleteFlag is false ";
		
		ExerciseFaultBook book = this.findUnique(hql, CollectionUtils.newList(ClientUtils.getClassId(), 
				ClientUtils.getUserId(), ExerciseFaultBook.TYPE_ORGANIZATION), ExerciseFaultBook.class);
		
		Map<String, Object> map = new HashMap<String, Object>(5);
		
		if(book == null){
			map.put("allCount", 0);
			map.put("doCount", 0);
			map.put(UPDATE_TIME, null);
			map.put("currTitleNum",  "0");
			map.put("status",  "0");
			return map;
		}
		
		map.put("allCount", book.getAllCount());
		map.put("doCount", book.getDoCount());
		map.put(UPDATE_TIME, book.getUpdateTime());
		map.put("currTitleNum", StringUtils.isBlank(book.getTitleMaxNumber()) ? "0" :book.getTitleMaxNumber());
		map.put("status",  StringUtils.isBlank(book.getStatus()) ? "0" :book.getStatus());
		
		return map;
	}

	/**
	 * 查询收藏本book信息
	 */
	@Override
	public Map<String, Object> queryExerFavorInfo() {
		String hql = "from ExerciseFavoriteBook where classId=? and userId=? and type=? and deleteFlag is false ";
		
		ExerciseFavoriteBook book = this.findUnique(hql, CollectionUtils.newList(ClientUtils.getClassId(), 
				ClientUtils.getUserId(), ExerciseFavoriteBook.TYPE_ORGANIZATION), ExerciseFavoriteBook.class);
		
		Map<String, Object> map = new HashMap<String, Object>(5);
		
		if(book == null){
			map.put("allCount", 0);
			map.put("doCount", 0);
			map.put(UPDATE_TIME, null);
			map.put("currTitleNum",  "0");
			map.put("status",  "0");
			return map;
		}
		
		map.put("allCount", book.getAllCount());
		map.put("doCount", book.getDoCount());
		map.put(UPDATE_TIME, book.getUpdateTime());
		map.put("currTitleNum", StringUtils.isBlank(book.getTitleMaxNumber()) ? "0" :book.getTitleMaxNumber());
		map.put("status",  StringUtils.isBlank(book.getStatus()) ? "0" :book.getStatus());
		
		return map;	
	}
	
	/**
	 * 计算用户每天做错题的统计信息
	 */
	@SuppressWarnings("unchecked")
	@Override
	public Result doCalcExerFaultStatisticsByDay(){
		log.info("---------------定时器 开始统计做题错题统计信息-----------start ------------------");
		// 1.计算前一天 对应做题人的做题信息
		String sql = "SELECT"
				+ " 	r.CLASS_ID,"
				+ " 	t.USER_ID,"
				+ " 	count(1) doCount,"
				+ " 	sum(t.CORRECT = 0) faultCount,"
				+ " 	r.ORG_ID,"
				+ " 	r.COLLEGE_COURSE_ID,"
				+ " 	r.SUBJECT_ID"
				+ " FROM"
				+ " 	exercise_item_answer_u t,"
				+ " 	exercise_record r"
				+ " WHERE"
				+ " 	t.EXERCISE_RECORD_ID = r.RECORD_ID"
				+ " AND t.UPDATE_TIME >= ?"
				+ " AND t.UPDATE_TIME < ?"
				+ " AND t.DELETE_FLAG = 0"
				+ " AND r.DELETE_FLAG = 0"
				+ " GROUP BY"
				+ " 	r.CLASS_ID,"
				+ " 	t.USER_ID";
		
		String yesterday = DateUtils.getTheDay(-1);
		List<Object[]> resultlst = this.findBySql(sql, CollectionUtils.newList(yesterday, DateUtils.getToday()));
		
		
		// 2.错题信息记录表
		List<ExerciseFaultStatistics> statisLst = new ArrayList<ExerciseFaultStatistics>(resultlst.size());
		ExerciseFaultStatistics faultStatis = null;
		for(Object[] objs:resultlst){
			faultStatis = new ExerciseFaultStatistics();
			
			faultStatis.setClassId(String.valueOf(objs[0]));
			faultStatis.setUserId(String.valueOf(objs[1]));
			faultStatis.setDoCount(new BigInteger(String.valueOf(objs[2])));
			faultStatis.setFaultCount(new BigInteger(String.valueOf(objs[3])));
			faultStatis.setFaultRate( ExerciseUtils.parseStrToBigDecimal(String.valueOf(objs[3]), String.valueOf(objs[2])));
			faultStatis.setOrgId(String.valueOf(objs[4]));
			faultStatis.setCollegeCourseId(String.valueOf(objs[5]));
			faultStatis.setSubjectId(String.valueOf(objs[6]));
			faultStatis.setExerciseTime(DateTimeUtils.stringConvertTS(yesterday));
			
			TraceUtils.setCreateTrace(faultStatis);
			statisLst.add(faultStatis);
		}
		
		this.saveOrUpdateAll(statisLst);
		
		log.info("---------------定时器 开始统计做题错题统计信息-----------end ------------------");
		return new Result(true, "操作成功,统计记录总条数："+statisLst.size());
	}
	
	/**
	 * 查询错题统计信息
	 * @param type:  week 最近一周   month:最近一月  year：最近一年
	 * @return
	 */
	@Override
	public List<Map<String,Object>> doGetFaultStatisInfo(String type) {
		try {
			// 开始时间
			String startDate = "";
			// 结束时间  今天
			String endDate = DateUtils.getToday();
				
			if("week".equals(type)){// 最近一周     7天前到今天 不包含今天
				
				startDate= DateUtils.getTheDay(-7);
			}else if("month".equals(type)){// 最近一月   30天前到今天  不包含今天
				
				startDate= DateUtils.getTheDay(-30);
			}else if("year".equals(type)){// 最近一年 365天前到今天  不包含今天
				
				startDate= DateUtils.getTheDay(-365);
			}
			
			String hql = "select exerciseTime,doCount,faultCount,faultRate"
					+ "  from ExerciseFaultStatistics where deleteFlag is false "
					+ " and userId=? and classId=?"
					+ " and exerciseTime >=? and exerciseTime<=?"
					+ " order by exerciseTime";
			
			// 查询结果
			List<Object[]> statisLst = this.findwithRawResult(hql, 
						CollectionUtils.newList(ClientUtils.getUserId(),ClientUtils.getClassId(), 
								DateUtils.convertStringToDate(startDate, "yyyy-MM-dd"), 
								DateUtils.convertStringToDate(endDate, "yyyy-MM-dd")));
			
			
			Map<String,Object> resultMap = null;
			List<Map<String,Object>> resultLst = new ArrayList<Map<String,Object>>(statisLst.size());
			
			if(statisLst.isEmpty()){
				return resultLst;
			}
			
			for(Object[] objs:statisLst){
				resultMap = new HashMap<String, Object>(4);
				resultMap.put("exerciseTime", objs[0]);
				resultMap.put("doCount", objs[1]);
				resultMap.put("faultCount", objs[2]);
				resultMap.put("faultRate", objs[3]);
			
				resultLst.add(resultMap);
			}
			
			return resultLst;
			
		} catch (ParseException e) {
			log.error("查询错题容错率接口异常", e);
		}
		
		return null;
	}
	
	/**
	 * 操作本次做题记录 错题
	 * @return
	 */
	@Override
	public Result doUpdateExerciseFaultRecord(ExerciseFaultRecord record) {
		//TraceUtils.setUpdateTrace(record);不更新updateTime
		this.save(record);
		return new Result(true);
	}

	/**
	 * 操作本次做题记录 收藏
	 * @return
	 */
	@Override
	public Result doUpdateExerciseFavorRecord(ExerciseFavoriteRecord record) {
		//TraceUtils.setUpdateTrace(record); 不更新updateTime
		this.save(record);
		return new Result(true);
	}
	
	/**
	 * 
	 * 保存app端请求保存的数据
	 * @return
	 */
	@Override
	public String doSaveExerciseDataSubmitLog(String data,
			String exerBussinessId, short type, int status, String url) {
		
		return exerciseVerService.doSaveExerciseDataSubmitLog(data,
				exerBussinessId, type, status, url);
	}
	
	@Override
	public Result doUpdateExerciseFaultBook(String currTitleNum) {
		//  查询此用户是否有收藏记录
		String hql = "from ExerciseFaultBook where classId=? and userId=? and deleteFlag is false ";
		
		List<ExerciseFaultBook> lstFault = this.find(hql,
				CollectionUtils.newList(ClientUtils.getClassId(), 
						ClientUtils.getUserId()), ExerciseFaultBook.class);
		
		
		ExerciseFaultBook book =  lstFault.get(0);
		
		book.setTitleMaxNumber(currTitleNum);
		this.save(book);
		
		return new Result(true);
	}

	@Override
	public Result doUpdateExerciseFavorBook(String currTitleNum) {
		//  查询此用户是否有收藏记录
		String hql = "from ExerciseFavoriteBook where classId=? and userId=? and deleteFlag is false ";
		
		List<ExerciseFavoriteBook> lstFavor = this.find(hql,
				CollectionUtils.newList(ClientUtils.getClassId(), 
						ClientUtils.getUserId()), ExerciseFavoriteBook.class);
		
		
		ExerciseFavoriteBook book =  lstFavor.get(0);
		
		book.setTitleMaxNumber(currTitleNum);
		this.save(book);
		
		return new Result(true);
	}

	/**
	 *提交多套题答案结果到db 
	 */
	@Override
	public Map<String, Object> doSubmitMutiExerciseAnswerData(ExerciseSubmitAnswerDataList answerDataList) {
		// 用户本次做题提交的数据
		List<ExerciseSubmitAnswerData> lstRecord = null;
		ExerciseSubmitAnswerData answerResult= null;
		List<ExerciseItemAnswerData> lstAnswers= null;
		Map<String,Object> resultMap = new HashMap<String,Object>(2);
		Map<String,Object> returnMap = null;
		resultMap.put("success", false);
		resultMap.put("attrs", null);
		
		lstRecord = answerDataList.getDatas();
		
		List<Map<String,Object>> resultList = new ArrayList<Map<String,Object>>(lstRecord.size());
		
		// 错题、收藏本bookid
		String faultBookId = null;
		String favoriteBookId = null;
		for(int i=0; i<lstRecord.size(); i++){
			
			answerResult = lstRecord.get(i);
			if(null == answerResult){
				continue;
			}
			
			lstAnswers = answerResult.getItems();
			
			// 记录id
			String initExerciseRecordId = answerResult.getExerciseRecordId();
						
			String recordData = JSONObject.toJSONString(answerResult);
			
			if(lstAnswers.isEmpty() 
					&& !ExerciseRecord.STATUS_SUBMIT.equals(answerResult.getStatus()) 
					&& answerResult.getSubmitType() != 1){// 提交状态
				this.doSaveExerciseDataSubmitLog(recordData,
						initExerciseRecordId, ExerciseDataSubmitLog.TYPE_SUBMIT_EXTEND_ANSWER,
						ExerciseDataSubmitLog.STATUS_FAILED, "/exercise/Extend/exerExtendMutiAnswers");
				continue;
			}
			
			/**  1.---------记录提交的数据日志 */
			// 记录提交的数据日志
			String exerciseDataLogId = this.doSaveExerciseDataSubmitLog(recordData,
					initExerciseRecordId, ExerciseDataSubmitLog.TYPE_SUBMIT_EXTEND_ANSWER, 
					ExerciseDataSubmitLog.STATUS_SUCCESS, "/exercise/Extend/exerExtendMutiAnswers");
						
			/** 2.提交答案  */
			String exerciseType = answerResult.getType();
			if(Constants.EXERCISE_TYPE_FAULT.equals(exerciseType)){// 错题本
				// 更新 提交练习答案
				returnMap = this.doSubmitExerFaultAnswerDataNew(answerResult);
				
				if(null == returnMap){
					continue;
				}
				
				faultBookId = (String) returnMap.get("exerciseBookId");
			}else if(Constants.EXERCISE_TYPE_FAVORT.equals(exerciseType)){// 收藏
				// 更新 提交练习答案
				returnMap = this.doSubmitExerFavorAnswerDataNew(answerResult);
				
				if(null == returnMap){
					continue;
				}
				
				favoriteBookId = (String) returnMap.get("exerciseBookId");
			}else{
				continue;
			}
			
			/** 3.发送 题目的全站统计  个人统计请求消息  */
			exerciseVerService.sendUpdateExerItemStatisticsMsg(answerResult.getExerciseGroupId(), answerResult);
			
			returnMap.put("type", exerciseType);
			resultList.add(returnMap);
			
			// 4.---------更新本次提交的数据日志exerciseRecordId
			if(StringUtils.isBlank(initExerciseRecordId) 
					&& returnMap.get(EXERCISE_RECORD_ID) != null){// 为空 说明第一次提交  更新日志记录id
				exerciseVerService.doUpdateExerciseDataSubmitLog(exerciseDataLogId, 
						String.valueOf(returnMap.get(EXERCISE_RECORD_ID)));
				
			}
						
		}
		
		/** 4.判断是否全部做题时 统计全部做题信息  */
		this.doOperFaultBookBySubmitAllAnswer(
				answerDataList.getCurrTitleNum(), answerDataList.getStatus(),faultBookId, answerDataList.getExerciseType());
		
		this.doOperFavorBookBySubmitAllAnswer(
				answerDataList.getCurrTitleNum(), answerDataList.getStatus(),favoriteBookId, answerDataList.getExerciseType());
		
		/**  5.返回结果 */
		resultMap.put("success", true);
		resultMap.put("attrs", resultList);
		resultMap.put("msg", "提交成功");
		
		return resultMap;
	}
	
	/**
	 * 提交单套题答案结果到db 
	 */
	@Override
	public Result doSubmitExerciseAnswerData(ExerciseSubmitAnswerData answerResult) {
		// 用户本次做题提交的数据
		Result result = new Result(false);
					
		if(answerResult.getItems().isEmpty() 
				&& !ExerciseRecord.STATUS_SUBMIT.equals(answerResult.getStatus()) 
				&& answerResult.getSubmitType() != 1){// 提交状态
			return result;
		}
		
		String exerciseType = answerResult.getType();
		
		Map<String,Object> resultMap = null;
		if(Constants.EXERCISE_TYPE_FAULT.equals(exerciseType)){// 错题本
			// 更新 提交练习答案
			resultMap = this.doSubmitExerFaultAnswerDataNew(answerResult);
			
			if(null == resultMap){
				return new Result(false,"提交失败");
			}
			
			// 统计全部做题信息/
			this.doOperFaultBookBySubmitAllAnswer(null,null,(String) resultMap.get("exerciseBookId"),null);
			
		}else if(Constants.EXERCISE_TYPE_FAVORT.equals(exerciseType)){// 收藏
			// 更新 提交练习答案
			resultMap = this.doSubmitExerFavorAnswerDataNew(answerResult);
			
			if(null == resultMap){
				return new Result(false,"提交失败");
			}
			
			// 统计全部做题信息/
			this.doOperFavorBookBySubmitAllAnswer(null,null, (String) resultMap.get("exerciseBookId"),null);
		}else{
			
			return new Result(false, "exerciseType传值错误：exerciseType="+exerciseType);
		}
		
		
		// 3.发送 题目的全站统计  个人统计请求消息
		List<ExerciseItemAnswerData> lstAnswers= answerResult.getItems();
		if(!lstAnswers.isEmpty()){
			exerciseVerService.sendUpdateExerItemStatisticsMsg(answerResult.getExerciseGroupId(), answerResult);
		}
		
		result.setData(resultMap);
		result.setResult(true);
			
		return result;
	}
	
	/**
	 * 初始化错题统计数据
	 */
	@SuppressWarnings("unchecked")
	@Override
	public Result doInitFaultStatisData() {
		log.info("---------------定时器 开始统计做题错题统计信息-----------start ------------------");
		// 1.计算前一天 对应做题人的做题信息
		String sql = "SELECT"
				+ " 	r.CLASS_ID,"
				+ " 	t.USER_ID,"
				+ " 	count(1) doCount,"
				+ " 	sum(t.CORRECT = 0) faultCount,"
				+ " 	r.ORG_ID,"
				+ " 	r.COLLEGE_COURSE_ID,"
				+ " 	r.SUBJECT_ID,"
				+ " 	r.UPDATE_TIME"
				+ " FROM"
				+ " 	exercise_item_answer_u t,"
				+ " 	exercise_record r"
				+ " WHERE"
				+ " 	t.EXERCISE_RECORD_ID = r.RECORD_ID"
				+ " AND t.UPDATE_TIME < ?"
				+ " AND t.DELETE_FLAG = 0"
				+ " AND r.DELETE_FLAG = 0"
				+ " GROUP BY"
				+ " 	r.CLASS_ID,"
				+ " 	t.USER_ID,"
				+ " 	r.UPDATE_TIME";
		
		String yesterday = DateUtils.getTheDay(-1);
		List<Object[]> resultlst = this.findBySql(sql, CollectionUtils.newList(yesterday));
		
		
		// 2.错题信息记录表
		List<ExerciseFaultStatistics> statisLst = new ArrayList<ExerciseFaultStatistics>(resultlst.size());
		ExerciseFaultStatistics faultStatis = null;
		for(Object[] objs:resultlst){
			faultStatis = new ExerciseFaultStatistics();
			
			faultStatis.setClassId(String.valueOf(objs[0]));
			faultStatis.setUserId(String.valueOf(objs[1]));
			faultStatis.setDoCount(new BigInteger(String.valueOf(objs[2])));
			faultStatis.setFaultCount(new BigInteger(String.valueOf(objs[3])));
			faultStatis.setFaultRate( ExerciseUtils.parseStrToBigDecimal(String.valueOf(objs[3]), String.valueOf(objs[2])));
			faultStatis.setOrgId(String.valueOf(objs[4]));
			faultStatis.setCollegeCourseId(String.valueOf(objs[5]));
			faultStatis.setSubjectId(String.valueOf(objs[6]));
			faultStatis.setExerciseTime((Date)(objs[7]));
			
			TraceUtils.setCreateTrace(faultStatis);
			statisLst.add(faultStatis);
		}
		
		this.saveOrUpdateAll(statisLst);
		
		log.info("---------------定时器 开始统计做题错题统计信息-----------end ------------------");
		return new Result(true, "操作成功,统计记录总条数："+statisLst.size());
	}

	@Override
	public Result doUpdateExerciseDataSubmitLog(String exerciseDataLogId,
			String exerBussinessId) {
		return exerciseVerService.doUpdateExerciseDataSubmitLog(exerciseDataLogId, exerBussinessId);
	}

	/** -----------------------APP----V2.0--end---------------------------------------- */
	
	/*@SuppressWarnings("unchecked")
	@Override
	public Result doInitExerRecentRecord() {
		
		String sql = " select r.RECORD_ID,"
				+"  r.EXERCISE_GROUP_ID,"
				+"  r.CLASS_ID,"
				+"  r.USER_ID,"
				+"  r.COLLEGE_COURSE_ID,"
				+"  r.ORG_ID,"
				+"  r.SUBJECT_ID,"
				+"  r.CREATE_TIME,"
				+"  r.CREATE_ID,"
				+"  r.CREATOR,"
				+"  r.UPDATE_ID,"
				+"  r.UPDATE_TIME,"
				+"  r.UPDATOR"
				+"  from exercise_record r, "
				+" ("
				+" select max(UPDATE_TIME) uptime,t.USER_ID,t.EXERCISE_GROUP_ID "
				+" from exercise_record t "
				+" group by t.USER_ID,t.EXERCISE_GROUP_ID) tmp"
				+" where r.EXERCISE_GROUP_ID=tmp.EXERCISE_GROUP_ID "
				+" and r.USER_ID=tmp.USER_ID "
				+" and r.UPDATE_TIME=tmp.uptime"
				+" and not EXISTS"
				+" (select 1 from exercise_recent_record re"
				+" where re.EXERCISE_RECORD_ID=r.RECORD_ID)";
		
		List<Object[]> lstData =this.findBySql(sql, new ArrayList<Object>());
		
		if(lstData.isEmpty()){
			return new Result(false,"最近做题记录数据为空");
		}
		
		List<ExerciseRecentRecord> lstRecord = new ArrayList<ExerciseRecentRecord>(lstData.size());
		ExerciseRecentRecord record=null;
		for(Object[] objs:lstData){
			record = new ExerciseRecentRecord();
			record.setExerciseRecordId(String.valueOf(objs[0]));
			record.setExerciseGroupId(String.valueOf(objs[1]));
			record.setClassId(objs[2]==null?null:String.valueOf(objs[2]));
			record.setUserId(String.valueOf(objs[3]));
			record.setCollegeCourseId(objs[4]==null?null:String.valueOf(objs[4]));
			record.setOrgId(objs[5]==null?null:String.valueOf(objs[5]));
			record.setSubjectId(objs[6]==null?null:String.valueOf(objs[6]));
			record.setCreateTime((Date)(objs[7]));
			record.setCreateId(String.valueOf(objs[8]));
			record.setCreator(String.valueOf(objs[9]));
			record.setDeleteFlag(false);
			TraceUtils.setUpdateTrace(record);
			
			lstRecord.add(record);
		}
		
		this.saveOrUpdateAll(lstRecord);
		
		return new Result(true,"此次插入ExerciseRecentRecord条数："+lstRecord.size());
	}

	@SuppressWarnings({ "unchecked" })
	@Override
	public Result doInitFaultRecord() {
		String sql = "select b.USER_ID,re.EXERCISE_GROUP_ID,g.TYPE,g.ALL_COUNT,count(1),b.RESUME_BOOK_ID,b.TITLE_MAX_NUMBER,"
		+" (select count(1) from exercise_fault t where t.EXERCISE_FAULT_ID=f.EXERCISE_FAULT_ID and t.CORRECT=1 ) correctCount,"
		+" (select count(1) from exercise_fault t where t.EXERCISE_FAULT_ID=f.EXERCISE_FAULT_ID and t.answer is not null ) doCount,"
		+ " b.UPDATE_ID,b.UPDATE_TIME,b.UPDATOR,b.CREATE_ID,b.CREATE_TIME,b.CREATOR"
		+" from exercise_fault f,exercise_group_item_re re,exercise_fault_book b,exercise_group g"
		+" where f.EXERCISE_ITEM_ID =re.EXERCISE_ITEM_ID"
		+" and f.RESUME_BOOK_ID=b.RESUME_BOOK_ID"
		+" and re.EXERCISE_GROUP_ID=g.GROUP_ID"
		+" and (f.FAULT_RECORD_ID is null or f.FAULT_RECORD_ID='') "
		+" group by b.USER_ID,re.EXERCISE_GROUP_ID";

		List<Object[]> lstData =this.findBySql(sql, new ArrayList<Object>());
		
		if(lstData.isEmpty()){
			return new Result(false,"错题数据为空,本次没有需要更新的错题数据");
		}
		
		
		String hql_existRecord = "from ExerciseFaultRecord where  resumeBookId=? and exerciseGroupId=? ";
		
		List<ExerciseFaultRecord> lstRecord = new ArrayList<ExerciseFaultRecord>(lstData.size());
		ExerciseFaultRecord record=null;
		BigInteger allCount;
		for(Object[] objs:lstData){
			if(!this.find(hql_existRecord, 
					CollectionUtils.newList(String.valueOf(objs[5]),String.valueOf(objs[1])), ExerciseFaultRecord.class).isEmpty()){
				continue;
			}
			
			record = new ExerciseFaultRecord();
			
			allCount = (BigInteger)objs[4];
			
			if(allCount.compareTo(BigInteger.ZERO) == 0){
				continue;
			}
			record.setResumeBookId(String.valueOf(objs[5]));
			record.setExerciseGroupId(String.valueOf(objs[1]));
			record.setExerciseGroupType((short)objs[2]);
			
			record.setAllCount(allCount);
			record.setDoCount(new BigInteger(String.valueOf(objs[8]==null ? 0 :objs[8])));
			record.setCorrectCount(new BigInteger(String.valueOf(objs[7]==null ? 0 :objs[7])));
			record.setCompletionRate(new BigDecimal(CommonUtils.formatDecimalFormat(
					record.getDoCount().doubleValue()/allCount.doubleValue()*100,
					CommonUtils.PARTEN_TWO)));
			
			record.setAccuracy(new BigDecimal(CommonUtils.formatDecimalFormat(
					record.getCorrectCount().doubleValue()/allCount.doubleValue()*100,
					CommonUtils.PARTEN_TWO)));
			record.setScore(record.getAccuracy());
			record.setStatus("0");
			record.setTitleMaxNumber(objs[6]==null?null:String.valueOf(objs[6]));
			if(StringUtils.isNotBlank(record.getTitleMaxNumber()) && 
							new BigInteger(record.getTitleMaxNumber()).compareTo(record.getAllCount())>0){
				record.setTitleMaxNumber(String.valueOf(record.getAllCount()));
			}
			record.setCreateId(String.valueOf(objs[12]));
			record.setCreateTime((Date)(objs[13]));
			record.setCreator(String.valueOf(objs[14]));
			TraceUtils.setUpdateTrace(record);
			
			lstRecord.add(record);
		}
		
		this.saveOrUpdateAll(lstRecord);
		
		return new Result(true, "插入ExerciseFaultRecord条数："+lstRecord.size());
	}

	@SuppressWarnings("unchecked")
	@Override
	public Result doInitFavorRecord() {
		
		String sql = " select b.USER_ID,re.EXERCISE_GROUP_ID,g.TYPE,g.ALL_COUNT,count(1),b.FAVORITE_BOOK_ID,b.TITLE_MAX_NUMBER,"
				+" (select count(1) from exercise_favorite t where t.EXERCISE_FAVORITE_ID=f.EXERCISE_FAVORITE_ID and t.CORRECT=1 ) correctCount,"
				+" (select count(1) from exercise_favorite t where t.EXERCISE_FAVORITE_ID=f.EXERCISE_FAVORITE_ID and t.answer is not null ) doCount,"
				+" +  b.UPDATE_ID,b.UPDATE_TIME,b.UPDATOR,b.CREATE_ID,b.CREATE_TIME,b.CREATOR"
				+" from exercise_favorite f,exercise_group_item_re re,exercise_favorite_book b,exercise_group g"
				+" where f.EXERCISE_ITEM_ID =re.EXERCISE_ITEM_ID"
				+" and f.FAVORITE_BOOK_ID=b.FAVORITE_BOOK_ID"
				+" and re.EXERCISE_GROUP_ID=g.GROUP_ID"
				+" and (f.FAVORITE_RECORD_ID is null or f.FAVORITE_RECORD_ID = '')"
				+" group by b.USER_ID,re.EXERCISE_GROUP_ID";

				List<Object[]> lstData =this.findBySql(sql, new ArrayList<Object>());
				
				if(lstData.isEmpty()){
					return new Result(false,"收藏数据为空,本次没有需要更新的收藏数据");
				}
				
				String hql_existRecord = "from ExerciseFavoriteRecord where  favoriteBookId=? and exerciseGroupId=? ";
				
				List<ExerciseFavoriteRecord> lstRecord = new ArrayList<ExerciseFavoriteRecord>(lstData.size());
				ExerciseFavoriteRecord record=null;
				BigInteger allCount;
				for(Object[] objs:lstData){
					if(!this.find(hql_existRecord, 
							CollectionUtils.newList(String.valueOf(objs[5]),String.valueOf(objs[1])), ExerciseFavoriteRecord.class).isEmpty()){
						continue;
					}
					
					record = new ExerciseFavoriteRecord();
					
					allCount = (BigInteger)objs[4];
					
					if(allCount.compareTo(BigInteger.ZERO) == 0){
						continue;
					}
					record.setFavoriteBookId(String.valueOf(objs[5]));
					record.setExerciseGroupId(String.valueOf(objs[1]));
					record.setExerciseGroupType((short)objs[2]);
					
					record.setAllCount(allCount);
					record.setDoCount(new BigInteger(String.valueOf(objs[8]==null ? 0 :objs[8])));
					record.setCorrectCount(new BigInteger(String.valueOf(objs[7]==null ? 0 :objs[7])));
					record.setCompletionRate(new BigDecimal(CommonUtils.formatDecimalFormat(
							record.getDoCount().doubleValue()/allCount.doubleValue()*100,
							CommonUtils.PARTEN_TWO)));
					
					record.setAccuracy(new BigDecimal(CommonUtils.formatDecimalFormat(
							record.getCorrectCount().doubleValue()/allCount.doubleValue()*100,
							CommonUtils.PARTEN_TWO)));
					record.setScore(record.getAccuracy());
					record.setStatus("0");
					record.setTitleMaxNumber(objs[6]==null?null:String.valueOf(objs[6]));
					if(record.getTitleMaxNumber() != null && 
							new BigInteger(record.getTitleMaxNumber()).compareTo(record.getAllCount())>0){
						record.setTitleMaxNumber(String.valueOf(record.getAllCount()));
					}
					record.setCreateId(String.valueOf(objs[12]));
					record.setCreateTime((Date)(objs[13]));
					record.setCreator(String.valueOf(objs[14]));
					TraceUtils.setUpdateTrace(record);
					
					lstRecord.add(record);
				}
				
				this.saveOrUpdateAll(lstRecord);
				
				
				return new Result(true,"插入ExerciseFavoriteRecord条数："+lstRecord.size());
	}

	@Override
	public Result doInitFaultItem() {
		// 2.
		String sql2="select f,re.exerciseGroupId"
				+" from ExerciseFault f,ExerciseGroupItemRe re"
				+" where f.exerciseItemId=re.exerciseItemId"
				+" and (f.faultRecordId is null or f.faultRecordId='') order by f.exerciseFaultId";
		
		List<Object[]> lstData2 =this.findwithRawResult(sql2, new ArrayList<Object>());
		
		if(lstData2.isEmpty()){//抛异常回滚
			return new Result(false,"错题数据为空2222");
		}
		
		String hql_existRecord = "from ExerciseFaultRecord where  resumeBookId=? and exerciseGroupId=? ";
		List<ExerciseFault> lstFaults = new ArrayList<ExerciseFault>(lstData2.size());
		ExerciseFault fault=null;
		ExerciseFault newFault=null;
		String exerciseFaultId="";
		List<ExerciseFaultRecord> lstRecord = null;
		for(Object[] objs:lstData2){
			fault = (ExerciseFault)objs[0];
			if(fault.getExerciseFaultId().equals(exerciseFaultId)){
				newFault = new ExerciseFault();
				BeanUtils.copyProperties(fault, newFault);
				newFault.setExerciseFaultId(null);
				
				lstRecord = this.find(hql_existRecord, CollectionUtils.newList(newFault.getResumeBookId(),String.valueOf(objs[1])), ExerciseFaultRecord.class);
				if(lstRecord.isEmpty()){
					continue;
				}
				
				newFault.setFaultRecordId(lstRecord.get(0).getFaultRecordId());
				TraceUtils.setUpdateTrace(newFault);
				lstFaults.add(newFault);
			}else{
				lstRecord = this.find(hql_existRecord, CollectionUtils.newList(fault.getResumeBookId(),String.valueOf(objs[1])), ExerciseFaultRecord.class);
				if(lstRecord.isEmpty()){
					continue;
				}
				
				fault.setFaultRecordId(lstRecord.get(0).getFaultRecordId());
				TraceUtils.setUpdateTrace(fault);
				lstFaults.add(fault);
			}
			
			exerciseFaultId=fault.getExerciseFaultId();
		}
		
		this.saveOrUpdateAll(lstFaults);
		
		return new Result(true, "更新ExerciseFault条数："+lstFaults.size());
	}

	@Override
	public Result doInitFavorItem() {
		// 2.
		String sql2="select f,re.exerciseGroupId"
				+" from ExerciseFavorite f,ExerciseGroupItemRe re"
				+" where f.exerciseItemId=re.exerciseItemId"
				+" and (f.favoriteRecordId is null or f.favoriteRecordId = '') order by f.exerciseFavoriteId";
		
		List<Object[]> lstData2 =this.findwithRawResult(sql2, new ArrayList<Object>());
		
		if(lstData2.isEmpty()){//抛异常回滚
			return new Result(false,"收藏数据为空2222");
		}
		
		String hql_existRecord = "from ExerciseFavoriteRecord where  favoriteBookId=? and exerciseGroupId=? ";
		List<ExerciseFavoriteRecord> lstRecord = null;
		List<ExerciseFavorite> lstFavors = new ArrayList<ExerciseFavorite>(lstData2.size());
		ExerciseFavorite favor=null;
		ExerciseFavorite newFavor=null;
		String exerciseFavoriteId="";
		for(Object[] objs:lstData2){
			favor = (ExerciseFavorite)objs[0];
			if(favor.getExerciseFavoriteId().equals(exerciseFavoriteId)){
				
				newFavor = new ExerciseFavorite();
				BeanUtils.copyProperties(favor, newFavor);
				newFavor.setExerciseFavoriteId(null);
				
				lstRecord = this.find(hql_existRecord, CollectionUtils.newList(newFavor.getFavoriteBookId(),String.valueOf(objs[1])), ExerciseFavoriteRecord.class);
				if(lstRecord.isEmpty()){
					continue;
				}
				
				newFavor.setFavoriteRecordId(lstRecord.get(0).getFavoriteRecordId());
				TraceUtils.setUpdateTrace(newFavor);
				lstFavors.add(newFavor);
			}else{
				lstRecord = this.find(hql_existRecord, CollectionUtils.newList(favor.getFavoriteBookId(),String.valueOf(objs[1])), ExerciseFavoriteRecord.class);
				if(lstRecord.isEmpty()){
					continue;
				}
				
				favor.setFavoriteRecordId(lstRecord.get(0).getFavoriteRecordId());
				TraceUtils.setUpdateTrace(favor);
				lstFavors.add(favor);
			}
			
			exerciseFavoriteId = favor.getExerciseFavoriteId();
		}
		
		this.saveOrUpdateAll(lstFavors);
		
		return new Result(true,"|更新ExerciseFavorite条数："+lstFavors.size());
	}

	@Override
	public Result doSavetoDB(Object obj) {
		this.save(obj);
		return new Result(true);
	}*/
}