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.Collections;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Random;
|
import java.util.concurrent.TimeUnit;
|
|
import org.apache.commons.lang3.ArrayUtils;
|
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.data.redis.core.BoundValueOperations;
|
import org.springframework.data.redis.core.RedisTemplate;
|
import org.springframework.stereotype.Service;
|
|
import com.hankcs.hanlp.HanLP;
|
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.ICacheService;
|
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.exam.model.ExamBatchInfo;
|
import com.qxueyou.scc.exam.model.ExamInfo;
|
import com.qxueyou.scc.exercise.model.ExerGroupResponseData;
|
import com.qxueyou.scc.exercise.model.ExerItemResponseData;
|
import com.qxueyou.scc.exercise.model.ExerciseAnalisisResult;
|
import com.qxueyou.scc.exercise.model.ExerciseDataSubmitLog;
|
import com.qxueyou.scc.exercise.model.ExerciseExamItemType;
|
import com.qxueyou.scc.exercise.model.ExerciseGroup;
|
import com.qxueyou.scc.exercise.model.ExerciseGroupExtend;
|
import com.qxueyou.scc.exercise.model.ExerciseGroupItemRe;
|
import com.qxueyou.scc.exercise.model.ExerciseInfo;
|
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.ExerciseItemOption;
|
import com.qxueyou.scc.exercise.model.ExerciseItemSet;
|
import com.qxueyou.scc.exercise.model.ExerciseItemStatis;
|
import com.qxueyou.scc.exercise.model.ExerciseItemStatistics;
|
import com.qxueyou.scc.exercise.model.ExerciseOptionStatistics;
|
import com.qxueyou.scc.exercise.model.ExerciseRecentRecord;
|
import com.qxueyou.scc.exercise.model.ExerciseRecord;
|
import com.qxueyou.scc.exercise.model.ExerciseSubmitAnswerData;
|
import com.qxueyou.scc.exercise.service.IExerciseExtendService;
|
import com.qxueyou.scc.exercise.service.IExerciseService;
|
import com.qxueyou.scc.exercise.service.IExerciseVerService;
|
import com.qxueyou.scc.exercise.util.ExerciseUtils;
|
import com.qxueyou.scc.msg.model.MsgInfo;
|
import com.qxueyou.scc.msg.service.IMsgInfoService;
|
import com.qxueyou.scc.school.model.SchRank;
|
import com.qxueyou.scc.school.service.IRankService;
|
|
/**
|
* Á·Ï° ʵÏÖservice APP V2.0½Ó¿Ú
|
* @author zhiyong
|
*
|
*/
|
@Service
|
public class ExerciseVerService extends CommonAppService implements IExerciseVerService {
|
/** onsÉú²úÕß */
|
// @Autowired
|
// CommonONSProducer onsProducer;
|
|
private static final String FILL_BLANKS_ANSWER_SPLIT_STR="\\$\\$";
|
|
private static final double SIMILARITY_PASS_LINE =0.8;
|
|
/** »º´æservice */
|
@Autowired
|
ICacheService cacheService;
|
|
/** ÅÅÃûservice */
|
@Autowired
|
IRankService rankService;
|
|
/** À©Õ¹Á·Ï°service */
|
@Autowired
|
private IExerciseExtendService exerciseExtendService;
|
|
/** À©Õ¹Á·Ï°service */
|
@Autowired
|
private IExerciseService exerciseService;
|
|
@SuppressWarnings("rawtypes")
|
@Autowired
|
private RedisTemplate redisTemplate;
|
|
@Autowired
|
IMsgInfoService msgInfoService;
|
|
/** ÈÕÖ¾ */
|
private static Logger log = LogManager.getLogger("ExerciseVerService");
|
|
/** ---------------Á·Ï°³É¼¨Í³¼Æ start---------------- */
|
|
/**
|
* ¸üÐÂͳ¼Æ - Ìá½»Êý¾Ýµ÷Óᢵ¥»÷ͳ¼Æ°´Å¥µ÷ÓÃ
|
* @param groupId Ï°Ìâ×éId
|
* @param orgId »ú¹¹Id
|
* @param classId °à¼¶Id
|
* @param btnFlag µ÷ÓÃÈë¿Ú£¨true£©
|
*/
|
@SuppressWarnings("unchecked")
|
@Override
|
public Result updateRefreshStatistical(String groupId, String orgId, String classId,boolean btnFlag) {
|
|
// ½á¹ûMap
|
Map<String, Object> resultMap = packageMapValue(groupId, orgId, classId, btnFlag);
|
|
if(null == resultMap){
|
return new Result(true);
|
}
|
|
List<ExerciseItemStatistics> newOrgIStaLst = new ArrayList<ExerciseItemStatistics>();
|
List<ExerciseOptionStatistics> newOrgOStaLst = new ArrayList<ExerciseOptionStatistics>();
|
for (ExerciseItem item : (List<ExerciseItem>) resultMap.get("itemLst")) {
|
|
// »ñÈ¡µ±Ç°»ú¹¹¸ÃÌâÄ¿µÄËùÓмǼ
|
for (ExerciseItemStatistics orgItemSta : (List<ExerciseItemStatistics>) resultMap.get("orgIStaLst")) {
|
if (orgItemSta.getExerciseItemId().equals(item.getExerciseId())) {
|
newOrgIStaLst.add(orgItemSta);
|
}
|
}
|
// »ñÈ¡µ±Ç°»ú¹¹¸ÃÌâÄ¿Ñ¡ÏîµÄËùÓмǼ
|
for (ExerciseOptionStatistics orgOptionSta : (List<ExerciseOptionStatistics>)resultMap.get("orgOStaLst")) {
|
if (orgOptionSta.getExerciseItemId().equals(item.getExerciseId())) {
|
newOrgOStaLst.add(orgOptionSta);
|
}
|
}
|
|
updateExerciseStatis(item, newOrgIStaLst, newOrgOStaLst, resultMap);
|
newOrgIStaLst.clear();
|
newOrgOStaLst.clear();
|
}
|
|
return new Result(true);
|
}
|
|
/**
|
* ×é×°Êý¾Ý·µ»ØMapÖµ
|
* @param groupId
|
* @param orgId
|
* @param classId
|
* @param btnFlag
|
* @return
|
*/
|
private Map<String, Object> packageMapValue(String groupId,String orgId,String classId,boolean btnFlag){
|
|
// ×é×°²ÎÊý - Á·Ï°×éId¡¢»ú¹¹Id¡¢°à¼¶Id
|
Map<String, String> paramsMap = new HashMap<String, String>();
|
paramsMap.put("groupId", groupId);
|
paramsMap.put("orgId", orgId);
|
paramsMap.put("classIdTo", classId);
|
|
// ×é×°Ï°Ìâ×éÏÂËùÓÐÌâÄ¿µÄ±àºÅ
|
Map<String, Object> exerciseItemMap = new HashMap<String, Object>();
|
|
List<ExerciseItem> itemLst = packageMapValue1(paramsMap, exerciseItemMap, btnFlag);
|
if(null == itemLst){
|
return null;
|
}
|
|
// ×é×°µ±Ç°°à¼¶µÄExerciseItemStatisticsÊý¾Ý
|
Map<String, ExerciseItemStatistics> itemStatisMap = new HashMap<String, ExerciseItemStatistics>();
|
|
// ×é×°µ±Ç°Ï°Ìâ×éËùÓÐÌâÄ¿µÄËùÓÐ×öÌâ¼Ç¼
|
Map<String, Object> answerUMap = new HashMap<String, Object>();
|
// ×é×°µ±Ç°Ï°Ìâ×éËùÓÐÌâÄ¿µ±Ç°°à¼¶µÄ×öÌâ¼Ç¼
|
Map<String, Object> classAnswerUMap = new HashMap<String, Object>();
|
// ×é×°ËùÓÐÌâÄ¿µÄµ±Ç°°à¼¶Í³¼Æ¼Ç¼
|
Map<String, Object> optionStatisMap = new HashMap<String, Object>();
|
// ×é×°ËùÓÐÌâÄ¿µÄÑ¡Ïî
|
Map<String, Object> itemOptionMap = new HashMap<String, Object>();
|
|
// ×é×°ËùÓÐÌâÄ¿µÄËùÓÐ×öÌâ¼Ç¼
|
String hql_answerUorg = "from ExerciseItemAnswerU where deleteFlag is false and exerciseItemId in (:exerciseItemIds) order by exerciseItemId";
|
List<ExerciseItemAnswerU> answerULstO = this.findByComplexHql(hql_answerUorg, exerciseItemMap, ExerciseItemAnswerU.class);
|
if(answerULstO.isEmpty()){
|
return null;
|
}
|
ExerciseUtils.packageExerciseItemAnswerStatis(answerULstO, answerUMap);
|
|
// ²éѯµ±Ç°ÌâÄ¿µ±Ç°°à¼¶µÄËùÓÐ×öÌâ¼Ç¼
|
String hql_answerUclass = "select u from ExerciseRecord r,ExerciseItemAnswerU u where r.deleteFlag is false "
|
+ "and u.deleteFlag is false and r.recordId = u.exerciseRecordId and r.exerciseGroupId = ? order by u.exerciseItemId";
|
List<ExerciseItemAnswerU> answerULstC = this.find(hql_answerUclass, CollectionUtils.newList(groupId), ExerciseItemAnswerU.class);
|
ExerciseUtils.packageExerciseItemAnswerStatis(answerULstC, classAnswerUMap);
|
|
// ×é×°ËùÓÐÌâÄ¿µÄÑ¡Ïî
|
String hql_option = "from ExerciseItemOption where deleteFlag is false and exerciseItemId in (:exerciseItemIds) order by exerciseItemId";
|
List<ExerciseItemOption> itemOptionLst = this.findByComplexHql(hql_option, exerciseItemMap, ExerciseItemOption.class);
|
ExerciseUtils.packageExerciseItemOption(itemOptionLst, itemOptionMap);
|
|
// µ±Ç°»ú¹¹µÄËùÓÐÌâĿͳ¼Æ ¡ª¡ª ÌâÄ¿µÄȫվͳ¼Æ
|
exerciseItemMap.put("orgId", paramsMap.get("orgId"));
|
String hql_orgItemStatis = "from ExerciseItemStatistics where exerciseItemId in (:exerciseItemIds) and orgId=:orgId and deleteFlag is false";
|
List<ExerciseItemStatistics> orgItemStatisLst = this.findByComplexHql(hql_orgItemStatis, exerciseItemMap, ExerciseItemStatistics.class);
|
List<ExerciseItemStatistics> claItemStatisLst = new ArrayList<ExerciseItemStatistics>(orgItemStatisLst.size());
|
for (ExerciseItemStatistics itemSta : orgItemStatisLst) {
|
if(paramsMap.get("classIdTo").equals(itemSta.getClassId())){
|
claItemStatisLst.add(itemSta);
|
}
|
}
|
for (ExerciseItemStatistics item : claItemStatisLst) {
|
itemStatisMap.put(item.getExerciseItemId(), item);
|
}
|
|
// µ±Ç°»ú¹¹µÄËùÓÐÌâÄ¿Ñ¡Ïîͳ¼Æ ¡ª¡ª ÌâÄ¿Ñ¡ÏîµÄȫվͳ¼Æ
|
String hql_optionStatisO = "from ExerciseOptionStatistics where deleteFlag is false and exerciseItemId in (:exerciseItemIds) and orgId=:orgId";
|
List<ExerciseOptionStatistics> orgOptionStatisLst = this.findByComplexHql(hql_optionStatisO, exerciseItemMap, ExerciseOptionStatistics.class);
|
List<ExerciseOptionStatistics> claOptionStatisLst = new ArrayList<ExerciseOptionStatistics>(orgOptionStatisLst.size());
|
for (ExerciseOptionStatistics optionSta : orgOptionStatisLst) {
|
if(paramsMap.get("classIdTo").equals(optionSta.getClassId())){
|
claOptionStatisLst.add(optionSta);
|
}
|
}
|
ExerciseUtils.packageExerciseOptionStatis(claOptionStatisLst, optionStatisMap);
|
|
Map<String, Object> resultMap = new HashMap<String, Object>(3);
|
resultMap.put("itemLst", itemLst);
|
resultMap.put("paramsMap", paramsMap);
|
resultMap.put("orgIStaLst", orgItemStatisLst);
|
resultMap.put("orgOStaLst", orgOptionStatisLst);
|
|
resultMap.put("itemStatisMap", itemStatisMap);
|
resultMap.put("answerUMap", answerUMap);
|
resultMap.put("classAnswerUMap", classAnswerUMap);
|
resultMap.put("optionStatisMap", optionStatisMap);
|
resultMap.put("itemOptionMap", itemOptionMap);
|
|
return resultMap;
|
}
|
|
/**
|
* ×é×°Êý¾Ý·µ»ØMapÖµ
|
* @param paramsMap
|
* @param exerciseItemMap
|
* @param btnFlag
|
* @return
|
*/
|
@SuppressWarnings("unchecked")
|
private List<ExerciseItem> packageMapValue1(Map<String, String> paramsMap,Map<String, Object> exerciseItemMap,boolean btnFlag){
|
|
String groupId = paramsMap.get("groupId");
|
// ×é×°Ï°Ìâ×éÏÂËùÓÐÌâÄ¿µÄ±àºÅ
|
Object[] itemArgs = null;
|
List<ExerciseItem> itemLst = null;
|
|
if(btnFlag){
|
List<ExerciseItemAnswerU> lstAnswerU = cacheService.get(Constants.REFRESH_STATIS_GROUPID_LSTNEWANSWERU_CACHE_KEY + groupId, List.class);
|
if(lstAnswerU.isEmpty()){
|
return null;
|
}
|
itemArgs = new Object[lstAnswerU.size()];
|
for (int i = 0; i < lstAnswerU.size(); i++) {
|
itemArgs[i] = lstAnswerU.get(i).getExerciseItemId();
|
}
|
exerciseItemMap.put("exerciseItemIds", itemArgs);
|
String hql = "from ExerciseItem where exerciseId in (:exerciseItemIds) and deleteFlag is false";
|
itemLst = findByComplexHql(hql, exerciseItemMap, ExerciseItem.class);
|
}else{
|
// ÅжÏ5·ÖÖÓÄÚ ÊÇ·ñÓе±Ç°×éIDµÄ»º´æ
|
String cache = cacheService.get(Constants.REFRESH_STATIS_GROUPID_CACHE_KEY + groupId , String.class);
|
if (cache != null) {
|
return null;
|
}
|
|
// ½«µ±Ç°×éID·ÅÔÚ»º´æÖÐ
|
cacheService.set(Constants.REFRESH_STATIS_GROUPID_CACHE_KEY + groupId , Constants.EXE_STATIS_UPDATE_MINUTES, groupId);
|
String hql = "select g.items from ExerciseGroup g where g.groupId=? and g.deleteFlag is false";
|
itemLst = find(hql, CollectionUtils.newList(groupId), ExerciseItem.class);
|
if(itemLst.isEmpty()){
|
return null;
|
}
|
|
itemArgs = new Object[itemLst.size()];
|
for (int i = 0; i < itemLst.size(); i++) {
|
itemArgs[i] = itemLst.get(i).getExerciseId();
|
}
|
exerciseItemMap.put("exerciseItemIds", itemArgs);
|
}
|
|
return itemLst;
|
}
|
|
|
/**
|
* ˢиüÐÂͳ¼Æ
|
* @param exerciseItem Á·Ï°
|
* @param newOrgIStaLst
|
* @param newOrgOStaLst
|
* @param resultMap
|
* @return
|
*/
|
@SuppressWarnings("unchecked")
|
public Result updateExerciseStatis(ExerciseItem exerciseItem, List<ExerciseItemStatistics> newOrgIStaLst,
|
List<ExerciseOptionStatistics> newOrgOStaLst, Map<String, Object> resultMap) {
|
|
// ËùÓÐÌâÄ¿µÄËùÓÐ×öÌâ¼Ç¼
|
Map<String, Object> answerUMap = (Map<String, Object>) resultMap.get("answerUMap");
|
// µ±Ç°Ï°Ìâ×éËùÓÐÌâÄ¿µ±Ç°°à¼¶µÄ×öÌâ¼Ç¼
|
Map<String, Object> classAnswerUMap = (Map<String, Object>) resultMap.get("classAnswerUMap");
|
// ËùÓÐÌâÄ¿µÄµ±Ç°°à¼¶Í³¼Æ¼Ç¼
|
Map<String, Object> optionStatisMap = (Map<String, Object>)resultMap.get("optionStatisMap");
|
// ËùÓÐÌâÄ¿µÄÑ¡Ïî
|
Map<String, Object> itemOptionMap = (Map<String, Object>) resultMap.get("itemOptionMap");
|
// µ±Ç°°à¼¶µÄExerciseItemStatisticsÊý¾Ý
|
Map<String, ExerciseItemStatistics> itemStatisMap = (Map<String, ExerciseItemStatistics>) resultMap.get("itemStatisMap");
|
// ×é×°²ÎÊý - Á·Ï°×éId¡¢»ú¹¹Id¡¢°à¼¶Id
|
Map<String, String> paramsMap = (Map<String, String>)resultMap.get("paramsMap");
|
|
// ²éѯµ±Ç°ÌâÄ¿µÄËùÓÐ×öÌâ¼Ç¼
|
List<ExerciseItemAnswerU> answerULstO = (List<ExerciseItemAnswerU>) answerUMap.get(exerciseItem.getExerciseId());
|
if(null == answerULstO){
|
return null;
|
}
|
String orgAnswer = "";// ×é×°ÒÑÑ¡µÄ´ð°¸ - »ú¹¹
|
int orgCorrectNum = 0;// ×é×°ÕýÈ·µÄ´ÎÊý - »ú¹¹
|
for (ExerciseItemAnswerU item : answerULstO) {
|
if (item.getCorrect() == 1) {
|
orgCorrectNum++;
|
}
|
orgAnswer = orgAnswer.concat(item.getAnswer()).concat(",");
|
}
|
|
// ²éѯµ±Ç°ÌâÄ¿µÄµ±Ç°°à¼¶×öÌâ¼Ç¼
|
List<ExerciseItemAnswerU> answerULstC = (List<ExerciseItemAnswerU>) classAnswerUMap.get(exerciseItem.getExerciseId());
|
if(null == answerULstC){
|
return null;
|
}
|
String classAnswer = "";// ×é×°ÒÑÑ¡µÄ´ð°¸ - °à¼¶
|
int classCorrectNum = 0;// ×é×°ÕýÈ·µÄ´ÎÊý - °à¼¶
|
for (ExerciseItemAnswerU item : answerULstC) {
|
if (item.getCorrect() == 1) {
|
classCorrectNum++;
|
}
|
classAnswer = classAnswer.concat(item.getAnswer()).concat(",") ;
|
}
|
|
// ²éѯµ±Ç°°à¼¶ÊÇ·ñÓе±Ç°ÌâÄ¿µÄͳ¼Æ¼Ç¼
|
List<ExerciseOptionStatistics> optionStatisLst = (List<ExerciseOptionStatistics>) optionStatisMap.get(exerciseItem.getExerciseId());
|
// ²éѯµ±Ç°ÌâÄ¿µÄÑ¡Ïî
|
List<ExerciseItemOption> itemOptionLst = (List<ExerciseItemOption>) itemOptionMap.get(exerciseItem.getExerciseId());
|
|
// ¸üÐÂÊý¾Ý - ÌâÄ¿
|
updateItemStatistics(itemStatisMap.get(exerciseItem.getExerciseId()), exerciseItem, paramsMap, orgCorrectNum, classCorrectNum, answerULstO.size(), answerULstC.size());
|
// ¸üÐÂÊý¾Ý - ÌâÄ¿µÄÑ¡Ïî
|
updateOptionStatistics(optionStatisLst, itemOptionLst, newOrgOStaLst, paramsMap, orgAnswer, classAnswer, answerULstO.size(), answerULstC.size());
|
|
// ¸üÐÂÈ«Õ¾Êý¾Ý - ÌâÄ¿
|
for (ExerciseItemStatistics itemStatis : newOrgIStaLst) {
|
itemStatis.setOrgCorrectNum(new BigInteger(String.valueOf(orgCorrectNum)));
|
itemStatis.setOrgTotalNum(new BigInteger(String.valueOf(answerULstO.size())));
|
itemStatis.setOrgAccuracy(new BigDecimal(itemStatis.getOrgCorrectNum().doubleValue() / itemStatis.getOrgTotalNum().doubleValue() * 100));
|
TraceUtils.setUpdateTrace(itemStatis);
|
save(itemStatis);
|
}
|
|
// ¸üÐÂÈ«Õ¾Êý¾Ý - ÌâÄ¿µÄÑ¡Ïî
|
for (ExerciseOptionStatistics optionSta : newOrgOStaLst) {
|
optionSta.setOrgTotalNum(new BigInteger(String.valueOf(answerULstO.size())));
|
optionSta.setOrgAccuracy(new BigDecimal(optionSta.getOrgCorrectNum().doubleValue() / optionSta.getOrgTotalNum().doubleValue() * 100));
|
TraceUtils.setUpdateTrace(optionSta);
|
save(optionSta);
|
}
|
|
return new Result(true);
|
}
|
|
/**
|
* ÐÂÔö»òÐÞ¸ÄExerciseOptionStatistics¼Ç¼
|
*
|
* @param itemStatis Á·Ï°ÌâÄ¿
|
* @param exerciseItem Á·Ï°
|
* @param paramsMap ²ÎÊýmap - Á·Ï°×éId¡¢»ú¹¹Id¡¢°à¼¶Id
|
* @param orgCorrectNum
|
* @param classCorrectNum
|
* @param answerULstO
|
* @param answerULstC
|
* @return
|
*/
|
public Result updateItemStatistics(ExerciseItemStatistics itemStatis, ExerciseItem exerciseItem, Map<String, String> paramsMap,
|
int orgCorrectNum, int classCorrectNum, int answerULstO, int answerULstC) {
|
Result result = null;
|
if (itemStatis != null && StringUtils.isNoneBlank(itemStatis.getItemStatisticsId())) { // ÓмǼ ¸üÐÂ
|
|
itemStatis.setClassTotalNum(new BigInteger(String.valueOf(answerULstC)));
|
itemStatis.setClassCorrectNum(new BigInteger(String.valueOf(classCorrectNum)));
|
itemStatis.setClassAccuracy(new BigDecimal(itemStatis.getClassCorrectNum().doubleValue() / itemStatis.getClassTotalNum().doubleValue() * 100));
|
TraceUtils.setUpdateTrace(itemStatis);
|
save(itemStatis);
|
} else {// ·ñÔòÐÂÔö
|
|
ExerciseItemStatistics newItemStatis = new ExerciseItemStatistics();
|
|
newItemStatis.setClassId(paramsMap.get("classIdTo"));
|
newItemStatis.setOrgId(paramsMap.get("orgId"));
|
newItemStatis.setGroupId(paramsMap.get("groupId"));
|
newItemStatis.setClassCorrectNum(new BigInteger(String.valueOf(classCorrectNum)));
|
newItemStatis.setClassTotalNum(new BigInteger(String.valueOf(answerULstC)));
|
newItemStatis.setClassAccuracy(new BigDecimal(newItemStatis.getClassCorrectNum().doubleValue() / newItemStatis.getClassTotalNum().doubleValue() * 100));
|
newItemStatis.setOrgCorrectNum(new BigInteger(String.valueOf(orgCorrectNum)));
|
newItemStatis.setOrgTotalNum(new BigInteger(String.valueOf(answerULstO)));
|
newItemStatis.setOrgAccuracy(new BigDecimal(newItemStatis.getOrgCorrectNum().doubleValue() / newItemStatis.getOrgTotalNum().doubleValue() * 100));
|
newItemStatis.setCorrectAnswer(exerciseItem.getAnswer());
|
newItemStatis.setExerciseItemId(exerciseItem.getExerciseId());
|
newItemStatis.setExerciseItemTitel(exerciseItem.getTitle());
|
newItemStatis.setExerciseItemType(exerciseItem.getType());
|
TraceUtils.setCreateTrace(newItemStatis);
|
save(newItemStatis);
|
}
|
return result;
|
}
|
|
/**
|
* ÐÂÔö»òÐÞ¸ÄExerciseOptionStatistics¼Ç¼
|
*
|
* @param optionStatisLst Á·Ï°ÌâÄ¿Ñ¡Ïî
|
* @param itemOptionLst Á·Ï°
|
* @param orgOptionStatisLst
|
* @param orgOptionStatisLst Ìá½»ÌâÄ¿µÄ³£¼û´íÎó´ð°¸map
|
* @param paramsMap ²ÎÊýmap - Á·Ï°×éId¡¢»ú¹¹Id¡¢°à¼¶Id
|
* @param classAnswer
|
* @param orgAnswer
|
* @param answerULstO
|
* @param answerULstC
|
* @return
|
*/
|
public Result updateOptionStatistics(List<ExerciseOptionStatistics> optionStatisLst, List<ExerciseItemOption> itemOptionLst,
|
List<ExerciseOptionStatistics> orgOptionStatisLst, Map<String, String> paramsMap,
|
String orgAnswer, String classAnswer, int answerULstO, int answerULstC) {
|
Result result = null;
|
if (null != optionStatisLst) { // ÓмǼ ¸üÐÂ
|
|
for (ExerciseOptionStatistics optionSta : optionStatisLst) {
|
|
optionSta.setOrgCorrectNum(new BigInteger(String.valueOf(getStrCount(orgAnswer, optionSta.getOptionOrder()))));
|
optionSta.setClassTotalNum(new BigInteger(String.valueOf(answerULstC)));
|
optionSta.setClassCorrectNum(new BigInteger(String.valueOf(getStrCount(classAnswer, optionSta.getOptionOrder()))));
|
Double accuracy = optionSta.getClassCorrectNum().doubleValue() / optionSta.getClassTotalNum().doubleValue() * 100;
|
optionSta.setClassAccuracy(new BigDecimal(String.valueOf(accuracy)));
|
TraceUtils.setUpdateTrace(optionSta);
|
save(optionSta);
|
for (ExerciseOptionStatistics item : orgOptionStatisLst) {
|
if (item.getOptionOrder().equals(optionSta.getOptionOrder())) {
|
item.setOrgCorrectNum(new BigInteger(String.valueOf(getStrCount(orgAnswer, optionSta.getOptionOrder()))));
|
item.setOrgAccuracy(new BigDecimal(item.getOrgCorrectNum().doubleValue() / item.getOrgTotalNum().doubleValue() * 100));
|
TraceUtils.setUpdateTrace(item);
|
save(item);
|
}
|
}
|
}
|
} else {// ·ñÔòÐÂÔö
|
|
for (ExerciseItemOption itemOption : itemOptionLst) {
|
ExerciseOptionStatistics newOptionSta = new ExerciseOptionStatistics();
|
newOptionSta.setClassId(paramsMap.get("classIdTo"));
|
newOptionSta.setOrgId(paramsMap.get("orgId"));
|
newOptionSta.setOptionId(itemOption.getOptionId());
|
newOptionSta.setChecked(itemOption.getChecked());
|
newOptionSta.setContent(itemOption.getContent());
|
newOptionSta.setOptionOrder(itemOption.getOptionOrder());
|
newOptionSta.setExerciseItemId(itemOption.getExerciseItemId());
|
newOptionSta.setClassCorrectNum(new BigInteger(String.valueOf(getStrCount(classAnswer, itemOption.getOptionOrder()))));
|
newOptionSta.setClassTotalNum(new BigInteger(String.valueOf(answerULstC)));
|
newOptionSta.setClassAccuracy(new BigDecimal(newOptionSta.getClassCorrectNum().doubleValue() / newOptionSta.getClassTotalNum().doubleValue() * 100));
|
newOptionSta.setOrgTotalNum(new BigInteger(String.valueOf(answerULstO)));
|
newOptionSta.setOrgCorrectNum(new BigInteger(String.valueOf(getStrCount(orgAnswer, itemOption.getOptionOrder()))));
|
newOptionSta.setOrgAccuracy(new BigDecimal(newOptionSta.getOrgCorrectNum().doubleValue() / newOptionSta.getOrgTotalNum().doubleValue() * 100));
|
TraceUtils.setCreateTrace(newOptionSta);
|
save(newOptionSta);
|
for (ExerciseOptionStatistics item : orgOptionStatisLst) {
|
if (item.getOptionOrder().equals(itemOption.getOptionOrder())) {
|
item.setOrgCorrectNum(new BigInteger(String.valueOf(getStrCount(orgAnswer, itemOption.getOptionOrder()))));
|
item.setOrgAccuracy(new BigDecimal(item.getOrgCorrectNum().doubleValue() / item.getOrgTotalNum().doubleValue() * 100));
|
TraceUtils.setUpdateTrace(item);
|
save(item);
|
}
|
}
|
}
|
}
|
return result;
|
}
|
|
/**
|
* »ñȡij¸ö×Ö·ûµÄ¸öÊý
|
*
|
* @return
|
*/
|
public int getStrCount(String strs, String str) {
|
int count = 0;
|
for (int i = 0; i < strs.split(",").length; i++) {
|
if (strs.split(",")[i].equals(str)) {
|
count++;
|
}
|
}
|
return count;
|
}
|
|
/**
|
* Ìá½»ÌâÄ¿·¢ËÍÏûÏ¢ - ±£´æ³É¼¨Í³¼Æ
|
* @param notice
|
* @return
|
*//*
|
private Result sendMsgExerciseStatistics(List<ExerciseItemAnswerU> lstNewAnswerU,String groupId){
|
|
// 4¡¢»ñÈ¡Ìá½»µ±Ç°ÌâÄ¿µÄ¿Í»§¶Ë°à¼¶¡¢»ú¹¹
|
String classId = ClientUtils.getClassId();
|
String orgId = ClientUtils.getOrgId();
|
|
// 2¡¢´ð°¸¼Ç¼·ÅÔÚ»º´æÖÐ
|
cacheService.set(Constants.REFRESH_STATIS_GROUPID_LSTNEWANSWERU_CACHE_KEY + groupId, Constants.EXE_STATIS_UPDATE_MINUTES, lstNewAnswerU);
|
|
// 3¡¢Òì²½µ÷Óà ·¢ËÍÏûÏ¢
|
ONSMsg msg = new ONSMsg(onsProducer.getTopic());
|
|
msg.put("msgType", "EXER_STATIS_SAVE");
|
msg.put("classId", classId);
|
msg.put("orgId", orgId);
|
msg.put("groupId", groupId);
|
|
try {
|
|
onsProducer.sendMsg(msg);
|
|
return new Result(true);
|
|
} catch (Exception e) {
|
log.error("call ExerciseStatistiscSendService fail.userId: " , e);
|
}
|
|
return new Result(false);
|
}*/
|
|
/** ---------------Á·Ï°³É¼¨Í³¼Æ end---------------- */
|
|
/** ------------------------- APP V2.0 start------------------------------------------*/
|
|
|
|
/**
|
* ÖØÐÂ×éװнá¹û
|
* @param answerData
|
* @return
|
*/
|
public ExerciseSubmitAnswerData getExerciseSubmitAnswerDataNew(ExerciseSubmitAnswerData answerData){
|
|
if(answerData.getItems().isEmpty()){
|
return answerData;
|
}
|
|
// 1.×é×°²ÎÊý
|
List<ExerciseItemAnswerData> lstAnswers = answerData.getItems();
|
Map<String, Object> argsMap = new HashMap<String, Object>(lstAnswers.size());
|
|
Object[] args = new Object[lstAnswers.size()];
|
for(int i=0; i<lstAnswers.size(); i++){
|
args[i] = lstAnswers.get(i).getExerciseId();
|
}
|
argsMap.put("exerciseIds", args);
|
|
// 2.²éѯÕýÈ·´ð°¸
|
String hql_answerU = "from ExerciseItem where exerciseId in (:exerciseIds) ";
|
List<ExerciseItem> lstItem= this.findByComplexHql(hql_answerU, argsMap, ExerciseItem.class);
|
|
Map<String, ExerciseItem> itemMap = new HashMap<String, ExerciseItem>(lstAnswers.size());
|
for(ExerciseItem item:lstItem){
|
itemMap.put(item.getExerciseId(), item);
|
}
|
|
ExerciseItem item = null;
|
int correctCount=0;
|
// 2.ÖØÐÂ×é×°½á¹û
|
for(ExerciseItemAnswerData data:lstAnswers){
|
item = itemMap.get(data.getExerciseId());
|
|
if(null == item){
|
continue;
|
}
|
//¼ò´ðÌⶼÐèÒª½øÐÐÖ÷¹ÛÆÀ·Ö£¬Óû§´ð°¸Í³Ò»±êʶΪ´íÎó
|
if(checkIsCorrect(item,data.getAnswer())){// ´ð°¸ÕýÈ·
|
data.setCorrect(String.valueOf(ExerciseItemAnswerU.CORRECT_RIGHT));
|
correctCount++;
|
}else{// ´ð°¸´íÎó
|
data.setCorrect(String.valueOf(ExerciseItemAnswerU.CORRECT_ERROR));
|
}
|
}
|
|
answerData.setCorrectCount(String.valueOf(correctCount));
|
answerData.setDoCount(String.valueOf(lstAnswers.size()));
|
answerData.setItems(lstAnswers);
|
return answerData;
|
}
|
|
private boolean checkIsCorrect(ExerciseItem item,String userAnswer){
|
if(StringUtils.isEmpty(userAnswer) || StringUtils.isEmpty(item.getAnswer())){
|
return false;
|
}
|
|
if(item.getType() == ExerciseItem.TYPE_TRUE_OR_FALSE){
|
if(userAnswer.equals("A")){
|
userAnswer = "True";
|
}else if(userAnswer.equals("B")){
|
userAnswer = "False";
|
}
|
return item.getAnswer().equals(userAnswer);
|
|
}
|
|
if(item.getType() == ExerciseItem.TYPE_FILL_BLANKS){
|
return checkFillBlanksIsCorrect(item.getAnswer(),userAnswer);
|
}else {
|
return item.getAnswer().equals(userAnswer);
|
}
|
|
}
|
|
private boolean checkFillBlanksIsCorrect(String itemAnswer,String useranswer){
|
boolean result =false;
|
|
if(StringUtils.isNotEmpty(itemAnswer) && StringUtils.isNotEmpty(useranswer)){
|
String[] arrUserAnswer = useranswer.split(FILL_BLANKS_ANSWER_SPLIT_STR);
|
String[] arrItemAnswer = itemAnswer.split(FILL_BLANKS_ANSWER_SPLIT_STR);
|
|
String tmpCorrectAsw=null, tmpUsertAsw=null;
|
int tempRightFillCount =0;
|
for(int i =0 ;i<arrUserAnswer.length;i++){
|
tmpCorrectAsw = StringUtils.isEmpty(arrItemAnswer[i])?"":arrItemAnswer[i].trim().toLowerCase().replaceAll("\\s*|\t|\r|\n", "");
|
tmpUsertAsw =StringUtils.isEmpty(arrUserAnswer[i])?"":arrUserAnswer[i].trim().toLowerCase().replaceAll("\\s*|\t|\r|\n", "");
|
|
if(StringUtils.isBlank(tmpCorrectAsw)||StringUtils.isBlank(tmpUsertAsw)){
|
continue;
|
}
|
|
if(tmpCorrectAsw.equals(tmpUsertAsw)){
|
++tempRightFillCount;
|
}else{
|
//Èç¹û²»ÍêÈ«Ïàͬ£¬Ôò¸ù¾Ýhanlp¼ÆËãÏàËƶÈ
|
if(this.checkSimilarity(tmpCorrectAsw, tmpUsertAsw)){
|
++tempRightFillCount;
|
}
|
}
|
}
|
result = tempRightFillCount==arrItemAnswer.length ;
|
}
|
|
return result;
|
}
|
|
/**
|
* ²Ù×÷Óû§ Á·Ï°×éÅÅÃûÐÅÏ¢
|
* @param record
|
* @return
|
*/
|
public Result doOperExerciseGroupRank(ExerciseRecord record){
|
// ²éѯ¸ÃÓû§ÔÚÅÅÃû±íÖÐ ´Ë×éÊÇ·ñÓÐÖµ
|
String hql = "from SchRank where rankType=? and userId=? and scopeType=? and scopeId=? ";
|
|
String userId = record.getUserId();
|
SchRank rank = this.findUnique(hql,
|
CollectionUtils.newList(SchRank.RANK_TYPE_EXERCISE_SCORE,
|
userId,SchRank.SCOPE_TYPE_CLASS_GROUP,
|
record.getExerciseGroupId()), SchRank.class);
|
|
if(null == rank){// ÐÂÔö¼Ç¼
|
rank = new SchRank();
|
|
rank.setRankType(SchRank.RANK_TYPE_EXERCISE_SCORE);
|
rank.setValue(record.getAccuracy());
|
rank.setScopeType(SchRank.SCOPE_TYPE_CLASS_GROUP);
|
rank.setScopeId(record.getExerciseGroupId());
|
rank.setUserId(userId);
|
rank.setDeleteFlag(false);
|
TraceUtils.setCreateTrace(rank);
|
}else{// ¸üмǼ
|
rank.setValue(record.getAccuracy());
|
|
TraceUtils.setUpdateTrace(rank);
|
}
|
|
// ±£´æ½á¹û
|
this.save(rank);
|
|
return new Result(true);
|
}
|
|
/**
|
* ²Ù×÷×î½üÒ»´Î¼Ç¼
|
* @param record
|
* @return
|
*/
|
public String doOperExerciseRecentRecord(ExerciseRecord record){
|
|
String hql = "from ExerciseRecentRecord where deleteFlag is false and exerciseGroupId=? and userId=? ";
|
|
ExerciseRecentRecord rRecord = this.findUnique(hql,
|
CollectionUtils.newList(record.getExerciseGroupId(), record.getUserId()), ExerciseRecentRecord.class);
|
|
String recentRecordId = null;
|
if(null == rRecord){//ÐÂÔö¼Ç¼
|
|
recentRecordId = insertExerciseRecentRecord(record);
|
}else{// ¸üмǼ
|
|
updateExerciseRecentRecord(rRecord, record.getRecordId());
|
|
recentRecordId = rRecord.getRecentRecordId();
|
}
|
|
return recentRecordId;
|
}
|
|
/**
|
* ÐÂÔö¼Ç¼ ×î½üÒ»´Î×öÌâ¼Ç¼
|
* @param record
|
* @return
|
*/
|
public String insertExerciseRecentRecord(ExerciseRecord record){
|
|
ExerciseRecentRecord rRecord = new ExerciseRecentRecord();
|
|
rRecord.setExerciseRecordId(record.getRecordId());
|
rRecord.setExerciseGroupId(record.getExerciseGroupId());
|
rRecord.setUserId(record.getUserId());
|
rRecord.setClassId(record.getClassId());
|
rRecord.setCollegeCourseId(record.getCollegeCourseId());
|
rRecord.setOrgId(record.getOrgId());
|
rRecord.setSubjectId(record.getSubjectId());
|
rRecord.setDeleteFlag(false);
|
TraceUtils.setCreateTrace(rRecord);
|
|
this.save(rRecord);
|
|
return rRecord.getRecentRecordId();
|
}
|
|
/**
|
* ¸üмǼ ×î½üÒ»´Î×öÌâ¼Ç¼
|
* @param record
|
* @return
|
*/
|
public Result updateExerciseRecentRecord(ExerciseRecentRecord rRecord, String recordId){
|
|
rRecord.setExerciseRecordId(recordId);
|
TraceUtils.setUpdateTrace(rRecord);
|
|
this.save(rRecord);
|
|
return new Result(true);
|
}
|
|
/**
|
* ÐÂÔöÁ·Ï°¼Ç¼
|
* @param groupId
|
* @return
|
* @throws ParseException
|
*/
|
public ExerciseRecord insertExerciseRecordMutiNew(ExerciseRecord record, String groupId,
|
String subjectId, String submitTime) {
|
record.setExerciseGroupId(groupId);
|
record.setCollegeCourseId(ClientUtils.getCourseId());
|
record.setOrgId(ClientUtils.getOrgId());
|
record.setSubjectId(subjectId);
|
record.setUserId(ClientUtils.getUserId());
|
record.setDeleteFlag(false);
|
TraceUtils.setCreateTrace(record);
|
this.save(record);
|
return record;
|
}
|
|
/**
|
* ÐÂÔöÁ·Ï°¼Ç¼
|
* @param groupId
|
* @return
|
*/
|
public String insertExerciseRecordNew(ExerciseRecord record, String groupId, String subjectId) {
|
record.setExerciseGroupId(groupId);
|
record.setCollegeCourseId(ClientUtils.getCourseId());
|
record.setOrgId(ClientUtils.getOrgId());
|
record.setSubjectId(subjectId);
|
record.setUserId(ClientUtils.getUserId());
|
record.setDeleteFlag(false);
|
TraceUtils.setCreateTrace(record);
|
|
this.save(record);
|
|
return record.getRecordId();
|
}
|
|
/**
|
* ¸üÐÂÁ·Ï°¼Ç¼
|
* @param groupId
|
* @return
|
*/
|
public ExerciseRecord updateExerciseRecordNew(ExerciseRecord record, ExerciseSubmitAnswerData answerData) {
|
if(StringUtils.isNotBlank(answerData.getCurrTitleNum())){
|
record.setTitleMaxNumber(answerData.getCurrTitleNum());
|
}
|
|
//Èç¹ûÊÇ¿¼ÊÔ
|
if(String.valueOf(ExerciseGroup.TYPE_EXERCISE_EXAM_ITEM).equals(answerData.getType())){
|
if(answerData.getScore()!=null){
|
record.setScore(answerData.getScore());
|
}else{
|
//ÅжÏÊÇ·ñÊÇËæ»ú¿¼ÊÔ£¬Èç¹ûÊÇËæ»ú¿¼ÊÔ£¬Ôò°´ÕÕÅäÖÃÀ´¼ÆËãµÃ·Ö
|
ExamInfo examInfo = null;
|
List<ExerciseItemSet> lstItemSets = null;
|
if(StringUtils.isNotEmpty(record.getExamBatchId())&& StringUtils.isNotEmpty(record.getClassId())){
|
examInfo = this.read(ExamBatchInfo.class,record.getExamBatchId()).getExamInfo();
|
}else {
|
//TODO ÕâÀïÊÇÒòΪ²¹¿¼¿¼ÊÔµÄʱºòÌí¼ÓµÄ¼Ç¼µÄÅú´ÎID¸Ä³ÉÁË¿¼ÊÔID£¬²¢ÇÒûÓÐÌí¼ÓClassID
|
examInfo = this.read(ExamInfo.class,record.getExamBatchId());
|
}
|
|
if(ExamInfo.EXAM_TYPE_RANDOM == examInfo.getExamType() || ExamInfo.EXAM_TYPE_RANDOM_BY_GROUP == examInfo.getExamType()){
|
lstItemSets = this.find( "from ExerciseItemSet s where s.deleteFlag is false and s.exerciseInfoId=?",
|
CollectionUtils.newList(examInfo.getExamId()) , ExerciseItemSet.class);
|
record.setScore(this.calculateScore(answerData.getExerciseGroupId(),lstItemSets ,answerData.getItems()));
|
}else{
|
record.setScore(this.calculateScore(answerData.getExerciseGroupId(),answerData.getItems()));
|
}
|
}
|
}else{
|
//Èç¹ûÊÇ×÷Òµ
|
record.setScore(answerData.getScore());
|
}
|
|
//ÉèÖÃ״̬£¬Èç¹ûûÓÐÖ÷¹ÛÌ⣬²¢ÊÇÌύ״̬£¬ÔòÖ±½ÓÉèÖÃ״̬ΪÒÑÅúÔÄ
|
if(record.getSubItemCount()==0 && answerData.getStatus().equals(String.valueOf(ExerciseRecord.STATUS_SUBMIT))){
|
record.setStatus(ExerciseRecord.STATUS_CHECK);
|
}else{
|
record.setStatus(answerData.getStatus());
|
}
|
|
record.setRemainingSeconds(answerData.getRemainingSeconds());
|
|
//ÉèÖÃÌύʱ¼ä
|
if(answerData.getStatus().equals(String.valueOf(ExerciseRecord.STATUS_SUBMIT))){
|
record.setSubmitTime(new Date());
|
}
|
|
//±£´æ¿Í¹ÛÌâ·ÖÊýºÍÖ÷¹ÛÌâ·ÖÊý
|
if(answerData.getStatus().equals(String.valueOf(ExerciseRecord.STATUS_CHECK))){
|
record.setSubScore(record.getScore().subtract(record.getObjScore()));
|
}else{
|
record.setObjScore(record.getScore());
|
}
|
|
TraceUtils.setUpdateTrace(record);
|
this.save(record);
|
return record;
|
}
|
|
|
//ºǫ́¼ÆË㿼ÊԵ÷Ö
|
private BigDecimal calculateScore(String groupId,List<ExerciseItemAnswerData> items){
|
BigDecimal resultScore = BigDecimal.ZERO;
|
|
if(items==null || items.isEmpty()){
|
return BigDecimal.ZERO;
|
}
|
|
//²éѯÌâÄ¿·ÖÊýÐÅÏ¢
|
List<Object[]> lstObj = this.find("select c.exerciseItemId,c.score,i.answer from ExerciseItemScore c,ExerciseItem i where c.exerciseItemId = i.exerciseId and c.groupId=? and c.deleteFlag is false", CollectionUtils.newList(groupId), Object[].class);
|
if(lstObj==null || lstObj.isEmpty()){
|
return BigDecimal.ZERO;
|
}
|
|
//×é×°ÌâÄ¿·ÖÊýMAP
|
Map<String,Object[]> exerciseScoreMap = new HashMap<String,Object[]>(lstObj.size());
|
for(Object[] arrObj : lstObj){
|
exerciseScoreMap.put((String)arrObj[0],arrObj);
|
}
|
|
BigDecimal tempScore = null,itemScore = null;
|
String itemAnswer = "";
|
for(ExerciseItemAnswerData data : items){
|
//Èç¹ûÕýÈ·²¢ÇÒ´æÔÚ·ÖÊýÐÅÏ¢£¬Ôò´¦Àí
|
if(exerciseScoreMap.containsKey(data.getExerciseId())){
|
itemScore = new BigDecimal((String)exerciseScoreMap.get(data.getExerciseId())[1]);
|
itemAnswer = (String)exerciseScoreMap.get(data.getExerciseId())[2];
|
}else{
|
itemScore =BigDecimal.ZERO;
|
}
|
|
if(data.getType()==ExerciseItem.TYPE_ESSAY_QUESTION){ //ÎÊ´ðÌâ¼ÆËã·ÖÊý
|
if(StringUtils.isNotEmpty(data.getTeacherScore())){
|
tempScore = new BigDecimal(data.getTeacherScore());
|
}else{
|
tempScore = BigDecimal.ZERO;
|
}
|
tempScore = tempScore.compareTo(itemScore)>0?itemScore:tempScore;
|
}else if(data.getType()==ExerciseItem.TYPE_FILL_BLANKS){ //Ìî¿ÕÌâ¼ÆËã·ÖÊý
|
tempScore = this.calFillBlanksItemScore(itemAnswer, data.getAnswer(), itemScore.floatValue());
|
data.setTeacherScore(tempScore.toPlainString()); //ÉèÖÃÌî¿ÕÌâ·ÖÊý
|
}else{
|
tempScore = Integer.valueOf(data.getCorrect())>0?itemScore:BigDecimal.ZERO;
|
}
|
resultScore = resultScore.add(tempScore);
|
}
|
|
return resultScore;
|
}
|
|
/**
|
* ¸ù¾ÝËæ»úÑ¡ÌâÅäÖüÆËãÌâÄ¿µÃ·Ö
|
* @param lstItemSet
|
* @param items
|
* @return
|
*/
|
private BigDecimal calculateScore(String groupId,List<ExerciseItemSet> lstItemSet,List<ExerciseItemAnswerData> items) {
|
//»ñÈ¡Ìî¿ÕÌâ´ð°¸ÐÅÏ¢
|
Map<String,String> exerciseFillItemMap= null;
|
List<Object[]> lstObj = this.find("select i.exerciseId,i.answer from ExerciseGroupItemRe r, ExerciseItem i where r.exerciseItemId=i.exerciseId and r.exerciseGroupId=? and r.deleteFlag is false and i.type=? and i.deleteFlag is false",
|
CollectionUtils.newList(groupId,ExerciseItem.TYPE_FILL_BLANKS), Object[].class);
|
if(lstObj!=null && lstObj.size()>0){
|
exerciseFillItemMap = new HashMap<String,String>(lstObj.size());
|
for(Object[] arrObj : lstObj){
|
exerciseFillItemMap.put((String)arrObj[0],(String)arrObj[1]);
|
}
|
}
|
|
Map<String, Double> scoreMap = new HashMap<String, Double>();
|
for (int i = 0; i < lstItemSet.size(); i++) {
|
if (lstItemSet.get(i).getItemType() == ExerciseItem.TYPE_SINGLE_SELECT) {
|
scoreMap.put("single_right", lstItemSet.get(i).getRightScore());
|
scoreMap.put("single_wrong", lstItemSet.get(i).getWrongScore());
|
scoreMap.put("single_noanswer", lstItemSet.get(i).getBlankScore());
|
} else if (lstItemSet.get(i).getItemType() == ExerciseItem.TYPE_MULTI_SELECT) {
|
scoreMap.put("multi_right", lstItemSet.get(i).getRightScore());
|
scoreMap.put("multi_wrong", lstItemSet.get(i).getWrongScore());
|
scoreMap.put("multi_noanswer", lstItemSet.get(i).getBlankScore());
|
} else if (lstItemSet.get(i).getItemType() == ExerciseItem.TYPE_TRUE_OR_FALSE) {
|
scoreMap.put("judge_right", lstItemSet.get(i).getRightScore());
|
scoreMap.put("judge_wrong", lstItemSet.get(i).getWrongScore());
|
scoreMap.put("judeg_noanswer", lstItemSet.get(i).getBlankScore());
|
} else if (lstItemSet.get(i).getItemType() == ExerciseItem.TYPE_FILL_BLANKS) {
|
scoreMap.put("fill_right", lstItemSet.get(i).getRightScore());
|
scoreMap.put("fill_wrong", lstItemSet.get(i).getWrongScore());
|
scoreMap.put("fill_noanswer", lstItemSet.get(i).getBlankScore());
|
}
|
}
|
double totalScore = 0.00;
|
String tempRightAnswer =null;
|
BigDecimal tempScore = BigDecimal.ZERO;
|
if (items != null && items.size() > 0) {
|
for (ExerciseItemAnswerData data : items) {
|
if (Integer.valueOf(data.getCorrect()) > 0) {
|
if (data.getType() == ExerciseItem.TYPE_SINGLE_SELECT) {
|
totalScore += scoreMap.get("single_right");
|
} else if (data.getType() == ExerciseItem.TYPE_MULTI_SELECT) {
|
totalScore += scoreMap.get("multi_right");
|
} else if (data.getType() == ExerciseItem.TYPE_TRUE_OR_FALSE) {
|
totalScore += scoreMap.get("judge_right");
|
} else if (data.getType() == ExerciseItem.TYPE_FILL_BLANKS) {
|
if(exerciseFillItemMap!=null && exerciseFillItemMap.size()>0){
|
tempRightAnswer = exerciseFillItemMap.get(data.getExerciseId());
|
}
|
tempScore = this.calFillBlanksItemScore(tempRightAnswer,data.getAnswer(), scoreMap.get("fill_right").floatValue());
|
data.setTeacherScore(tempScore.toPlainString());
|
totalScore += tempScore.doubleValue();
|
}else if (data.getType() == ExerciseItem.TYPE_ESSAY_QUESTION) {
|
if(StringUtils.isNotEmpty(data.getTeacherScore())){
|
tempScore = new BigDecimal(data.getTeacherScore());
|
}else{
|
tempScore = BigDecimal.ZERO;
|
}
|
totalScore += tempScore.doubleValue();
|
}
|
} else {
|
if (data.getType() == ExerciseItem.TYPE_SINGLE_SELECT) {
|
totalScore += scoreMap.get("single_wrong");
|
} else if (data.getType() == ExerciseItem.TYPE_MULTI_SELECT) {
|
totalScore += scoreMap.get("multi_wrong");
|
} else if (data.getType() == ExerciseItem.TYPE_TRUE_OR_FALSE) {
|
totalScore += scoreMap.get("judge_wrong");
|
}else if (data.getType() == ExerciseItem.TYPE_FILL_BLANKS) {
|
if(exerciseFillItemMap!=null && exerciseFillItemMap.size()>0){
|
tempRightAnswer = exerciseFillItemMap.get(data.getExerciseId());
|
}
|
tempScore = this.calFillBlanksItemScore(tempRightAnswer,data.getAnswer(), scoreMap.get("fill_right").floatValue());
|
data.setTeacherScore(tempScore.toPlainString());
|
totalScore += tempScore.doubleValue();
|
}else if (data.getType() == ExerciseItem.TYPE_ESSAY_QUESTION) {
|
if(StringUtils.isNotEmpty(data.getTeacherScore())){
|
tempScore = new BigDecimal(data.getTeacherScore());
|
}else{
|
tempScore = BigDecimal.ZERO;
|
}
|
totalScore += tempScore.doubleValue();
|
}
|
}
|
}
|
}
|
return new BigDecimal(totalScore);
|
}
|
|
@Override
|
public BigDecimal calFillBlanksItemScore(String itemAnswer,String useranswer,float itemRightScore){
|
BigDecimal resultScore = null;
|
int tempRightFillCount=0;
|
String[] arrUserAnswer = null;
|
String[] arrItemAnswer = null;
|
|
//Ìî¿ÕÌâ¼ÆËã·ÖÊý
|
tempRightFillCount =0;
|
if(StringUtils.isNotEmpty(itemAnswer) && StringUtils.isNotEmpty(useranswer)){
|
arrUserAnswer = useranswer.split(FILL_BLANKS_ANSWER_SPLIT_STR);
|
arrItemAnswer = itemAnswer.split(FILL_BLANKS_ANSWER_SPLIT_STR);
|
if(arrUserAnswer.length>arrItemAnswer.length){
|
arrItemAnswer = ArrayUtils.subarray(arrItemAnswer, 0, arrItemAnswer.length);
|
}
|
|
String tmpCorrectAsw=null, tmpUsertAsw=null;
|
for(int i =0 ;i<arrUserAnswer.length;i++){
|
tmpCorrectAsw = StringUtils.isEmpty(arrItemAnswer[i])?"":arrItemAnswer[i].trim().toLowerCase().replaceAll("\\s*|\t|\r|\n", "");
|
tmpUsertAsw =StringUtils.isEmpty(arrUserAnswer[i])?"":arrUserAnswer[i].trim().toLowerCase().replaceAll("\\s*|\t|\r|\n", "");
|
|
if(StringUtils.isBlank(tmpCorrectAsw)||StringUtils.isBlank(tmpUsertAsw)){
|
continue;
|
}
|
|
if(tmpCorrectAsw.equals(tmpUsertAsw)){
|
++tempRightFillCount;
|
}else{
|
//Èç¹û²»ÍêÈ«Ïàͬ£¬Ôò¸ù¾Ýhanlp¼ÆËãÏàËƶÈ
|
if(this.checkSimilarity(tmpCorrectAsw, tmpUsertAsw)){
|
++tempRightFillCount;
|
}
|
}
|
}
|
resultScore = new BigDecimal(itemRightScore*tempRightFillCount/arrItemAnswer.length);
|
}else{
|
resultScore = BigDecimal.ZERO;
|
}
|
|
return resultScore;
|
}
|
|
private boolean checkSimilarity(String correctAsw,String userAsw){
|
double matchingDegree=0.0;
|
int correctWord=0;
|
|
List<String> correctLst = HanLP.extractKeyword(StringUtils.isEmpty(correctAsw)?"":correctAsw.trim().toLowerCase().replaceAll("\\s*|\t|\r|\n", ""),100);
|
List<String> userLst = HanLP.extractKeyword(StringUtils.isEmpty(userAsw)?"":userAsw.trim().toLowerCase().replaceAll("\\s*|\t|\r|\n", ""),100);
|
|
// System.out.println(correctLst);
|
// System.out.println(userLst);
|
|
//¸ù¾ÝÕýÈ·µÄlist½øÐвÎÕÕ£¬Èç¹ûuserÖк¬ÓÐÕýÈ·µÄ´Ê»ã+1
|
for(String t :correctLst){
|
if(userLst.contains(t)){
|
correctWord++;
|
}
|
}
|
if(correctLst.size()>0){
|
matchingDegree = correctWord*1.0/correctLst.size();
|
}
|
|
// System.out.println("matchingDegree: "+matchingDegree);
|
|
return matchingDegree>SIMILARITY_PASS_LINE;
|
}
|
|
/**
|
* Ìá½»Óû§±¾´Î×öÌâÊý¾Ý½á¹û ÒÔ¼°·ÖÎö½á¹û
|
* @return
|
*/
|
public Result doSubmitExerciseAnswerDataNew(ExerciseSubmitAnswerData answerData, String exerciseRecordId) {
|
// 1.×é×°²ÎÊý
|
String exerciseGroupId = answerData.getExerciseGroupId();
|
|
List<ExerciseItemAnswerData> lstAnswers = answerData.getItems();
|
//TODO Ìí¼ÓÓû§×öÌâ´ð°¸Ê±£¬ÅжÏÌá½»µÄ×öÌâ¼Ç¼ÊÇ·ñΪ¿Õ
|
if (lstAnswers!=null&& !lstAnswers.isEmpty()) {
|
Object[] args = new Object[lstAnswers.size()];
|
for(int i=0; i<lstAnswers.size(); i++){
|
args[i] = lstAnswers.get(i).getExerciseId();
|
}
|
|
// 1.¼Ç¼Á·Ï°´ð°¸ ExerciseItemAnswerU
|
this.doOperExerciseItemAnswerUNew(lstAnswers, exerciseRecordId,exerciseGroupId, CollectionUtils.newObjectMap("exerciseIds",args));
|
}
|
|
// 2.ÖØмÆËã×öÌâ¼Ç¼ÕýÈ·¸öÊý ×öÌâ¸öÊý ÕýÈ·ÂÊ
|
Result result = this.doCalcExericseRecordStatisData(exerciseGroupId, exerciseRecordId, answerData);
|
|
// 3.¼ÆËã×éÒѾÌá½»ÈËÊý
|
this.doCalcExericseGroupSubmitNumber(exerciseGroupId);
|
|
// 4¡¢¼ÆËã°à¼¶ÕýÈ·ÂÊ
|
this.doUpdateExerGroupClsAccuracy(exerciseGroupId, answerData.getDoCount(), answerData.getCorrectCount());
|
|
return result;
|
}
|
|
/**
|
* ¼ÆËã×éÒѾÌá½»ÈËÊý
|
* @param exerciseGroupId
|
* @return
|
*/
|
public Result doCalcExericseGroupSubmitNumber(String exerciseGroupId){
|
String hql = "select userId from ExerciseRecord where deleteFlag is false and status=? and exerciseGroupId=? group by userId";
|
|
List<String> numberLst = this.find(hql, CollectionUtils.newList(ExerciseRecord.STATUS_SUBMIT,exerciseGroupId),String.class);
|
|
ExerciseGroupExtend extend = this.findUnique("from ExerciseGroupExtend where groupId=? and deleteFlag is false ",
|
CollectionUtils.newList(exerciseGroupId), ExerciseGroupExtend.class);
|
|
if(extend == null){
|
extend = new ExerciseGroupExtend();
|
extend.setGroupId(exerciseGroupId);
|
extend.setDeleteFlag(false);
|
TraceUtils.setCreateTrace(extend);
|
}else{
|
TraceUtils.setUpdateTrace(extend);
|
}
|
|
extend.setSubmitNumber(new BigInteger(String.valueOf(numberLst.size())));
|
this.save(extend);
|
|
return new Result(true);
|
}
|
|
/**
|
* ·¢Ë͸öÈËͳ¼Æ ȫվͳ¼ÆÏûÏ¢
|
* @param lstAnswers
|
* @return
|
*/
|
@Override
|
public Result sendUpdateExerItemStatisticsMsg(String exerciseGroupId, ExerciseSubmitAnswerData answerData){
|
|
// 1¡¢ »ñÈ¡µ±Ç°Ê±¼ä
|
DateUtils objDateUtils = new DateUtils();
|
String currTime = objDateUtils.getDateFormat(objDateUtils.getCurrDateTime(),"yyyyMMddHHmmss");
|
|
// 2¡¢´ð°¸¼Ç¼·ÅÔÚ»º´æÖРĬÈÏ·ÅÈë10·ÖÖÓ
|
cacheService.set(Constants.EXER_ITEM_STATISTICAL_CACHE_KEY
|
+ ClientUtils.getUserId() + exerciseGroupId + currTime, 600, answerData);
|
|
// Òì²½µ÷Óà ·¢ËÍÏûÏ¢
|
// ONSMsg msg = new ONSMsg(onsProducer.getTopic());
|
//
|
// msg.put("msgType", "USER_EXER_ITEM_STATIS");
|
// msg.put("userId", ClientUtils.getUserId());
|
// msg.put("userName", ClientUtils.getUserName());
|
// msg.put("groupId", exerciseGroupId);
|
// msg.put("currTime", currTime);
|
//
|
// try {
|
//
|
// onsProducer.sendMsg(msg);
|
// return new Result(true);
|
//
|
// } catch (Exception e) {
|
// log.error("call sendUpdateExerItemStatisticsMsg fail" , e);
|
// }
|
|
return new Result(false);
|
}
|
|
/**
|
* ÖØмÆËã×öÌâ¼Ç¼ÕýÈ·¸öÊý ×öÌâ¸öÊý ÕýÈ·ÂÊ
|
* @param exerciseGroupId
|
* @param exerciseRecordId
|
* @return
|
*/
|
@SuppressWarnings("unchecked")
|
public Result doCalcExericseRecordStatisData(String exerciseGroupId, String exerciseRecordId
|
, ExerciseSubmitAnswerData answerData){
|
|
// 1.¼ÆËã×öÌâ¸öÊý ×öÌâÕýÈ·¸öÊý
|
String sql_answerU = "select count(1) doCount, sum(CORRECT=1) correctCount"
|
+ " from exercise_item_answer_u where DELETE_FLAG=0 and EXERCISE_RECORD_ID=? ";
|
List<Object[]> lstAnswerU = this.findBySql(sql_answerU, CollectionUtils.newList(exerciseRecordId));
|
|
String doCount = String.valueOf(lstAnswerU.get(0)[0]);
|
String correctCount = String.valueOf(lstAnswerU.get(0)[1] == null ? 0 : lstAnswerU.get(0)[1]);
|
|
// 3.²éѯ×ÜÌâÄ¿Êý
|
ExerciseGroup group = this.read(ExerciseGroup.class, exerciseGroupId);
|
BigInteger allCount = group.getAllCount();
|
|
if(allCount==null || allCount.intValue()==0){
|
allCount = BigInteger.valueOf(this.findCount("from ExerciseGroupItemRe where exerciseGroupId=? and deleteFlag is false", CollectionUtils.newList(exerciseGroupId)));;
|
}
|
|
// 4.²éѯ×öÌâ¼Ç¼obj
|
ExerciseRecord record = this.read(ExerciseRecord.class, exerciseRecordId);
|
|
BigDecimal accuracy = ExerciseUtils.parseStrToBigDecimal(correctCount, String.valueOf(allCount));
|
BigDecimal completionRate = ExerciseUtils.parseStrToBigDecimal(doCount, String.valueOf(allCount));
|
|
// ¸üÐÂ×îÐÂÖµ
|
record.setAccuracy(accuracy);
|
record.setCompletionRate(completionRate);
|
record.setStatus(answerData.getStatus());
|
record.setCorrectCount(new BigInteger(correctCount));
|
record.setDoCount(new BigInteger(doCount));
|
record.setOrgId(ClientUtils.getOrgId());
|
|
this.save(record);
|
|
// 5.²Ù×÷Á·Ï°×é´Ë´ÎÅÅÃûÇé¿ö
|
// doOperExerciseGroupRank(record);
|
|
return new Result(true);
|
}
|
|
/**
|
* ¼ÆË㿼ÊÔ·ÖÊý
|
*
|
* @param exerciseGroupId
|
* @param exerciseRecordId
|
* @return
|
*/
|
@SuppressWarnings({ "unchecked", "unused" })
|
private BigDecimal getExamScore(String exerciseGroupId, String exerciseRecordId) {
|
String examId = this.findUnique("select examId from ExerciseExamReGroup where groupId = ? and deleteFlag is false", CollectionUtils.newList(exerciseGroupId), String.class);
|
|
List<ExerciseExamItemType> lstExerciseExamItemType = this.find("from ExerciseExamItemType where deleteFlag is false and examId = ?",
|
CollectionUtils.newList(examId), ExerciseExamItemType.class);
|
|
if(lstExerciseExamItemType == null || lstExerciseExamItemType.isEmpty()) {
|
return BigDecimal.ZERO;
|
}
|
|
// 1.¼ÆËã×öÌâ¸öÊý ×öÌâÕýÈ·¸öÊý
|
String sql_answerU = "SELECT COUNT(1), SUM(u.CORRECT = 1), SUM(u.CORRECT = 0),"
|
+ "i.TYPE FROM exercise_item_answer_u u, exercise_item i "
|
+ "WHERE u.EXERCISE_RECORD_ID = ? AND i.EXERCISE_ID = u.EXERCISE_ITEM_ID GROUP BY i.type";
|
List<Object[]> lstAnswerU = this.findBySql(sql_answerU, CollectionUtils.newList(exerciseRecordId));
|
if(lstAnswerU == null || lstAnswerU.isEmpty()) {
|
return BigDecimal.ZERO;
|
}
|
|
Double score = 0.0;
|
for(ExerciseExamItemType objExerciseExamItemType : lstExerciseExamItemType) {
|
for(Object[] answerU : lstAnswerU) {
|
Short itemType = (Short)answerU[3];
|
Integer correctCount = ((BigDecimal)answerU[1]).intValue();
|
Integer notCorrectCount = ((BigDecimal)answerU[2]).intValue();
|
Integer totalCount = ((BigInteger)answerU[0]).intValue();
|
|
if(itemType == objExerciseExamItemType.getItemType()) {
|
score += correctCount*objExerciseExamItemType.getRightScore();
|
score += notCorrectCount*objExerciseExamItemType.getWrongScore();
|
score += (objExerciseExamItemType.getItemCount()-totalCount)*objExerciseExamItemType.getBlankScore();
|
}
|
}
|
}
|
|
return BigDecimal.valueOf(score);
|
}
|
|
/**
|
* ²Ù×÷Á·Ï°´ð°¸½á¹û
|
* @param answer
|
* @param userId
|
* @param exerciseRecordId
|
* @return
|
*/
|
public Result doOperExerciseItemAnswerUNew(List<ExerciseItemAnswerData> lstAnswers,
|
String exerciseRecordId, String exerciseGroupId, Map<String, Object> argsMap) {
|
// ¼Ç¼Á·Ï°´ð°¸ ExerciseItemAnswerU
|
String hql_answerU = "from ExerciseItemAnswerU where exerciseItemId in (:exerciseIds) and "
|
+ " exerciseRecordId=:exerciseRecordId and deleteFlag is false ";
|
argsMap.put("exerciseRecordId",exerciseRecordId);
|
List<ExerciseItemAnswerU> lstAnswerU = this.findByComplexHql(hql_answerU, argsMap, ExerciseItemAnswerU.class);
|
|
Map<String, ExerciseItemAnswerU> answerUMap = new HashMap<String, ExerciseItemAnswerU>();
|
for(ExerciseItemAnswerU answerU:lstAnswerU){
|
answerUMap.put(answerU.getExerciseItemId(), answerU);
|
}
|
|
String userId = ClientUtils.getUserId();
|
List<ExerciseItemAnswerU> lstNewAnswerU = new ArrayList<ExerciseItemAnswerU>(lstAnswers.size());
|
ExerciseItemAnswerU answerU = null;
|
byte currCorrect;
|
// ÅúÁ¿²Ù×÷
|
for(ExerciseItemAnswerData answer:lstAnswers){
|
answerU=answerUMap.get(answer.getExerciseId());
|
// 1.×é×°ÅúÁ¿Á·Ï°´ð°¸
|
if(answerU == null){
|
//Ϊ¿Õ ÐÂÔöÒ»¸ö
|
// if(StringUtils.isBlank(answer.getAnswer())){//´ð°¸Îª¿Õ Ìø¹ý
|
// continue;
|
// }
|
|
// ×é×°´ð°¸¼Ç¼
|
answerU = new ExerciseItemAnswerU();
|
answerU.setExerciseItemId(answer.getExerciseId());
|
answerU.setExerciseRecordId(exerciseRecordId);
|
answerU.setAnswer(answer.getAnswer());
|
answerU.setCorrect(Byte.valueOf(answer.getCorrect()));
|
answerU.setUserId(userId);
|
answerU.setDeleteFlag(false);
|
answerU.setTeacherScore(answer.getTeacherScore());
|
answerU.setUpdateStatus(ExerciseItemAnswerU.STATUS_ADD);
|
TraceUtils.setCreateTrace(answerU);
|
}else{//¸üÐÂ
|
// ±¾´ÎÐ޸Ľá¹û
|
currCorrect = Byte.valueOf(answer.getCorrect());
|
if(answerU.getCorrect() == ExerciseItemAnswerU.CORRECT_ERROR &&
|
currCorrect == ExerciseItemAnswerU.CORRECT_RIGHT){//ÉϴδíÎó±¾´ÎÐÞ¸ÄΪÕýÈ· ͳ¼ÆÕýÈ·½á¹û +1
|
answerU.setUpdateStatus(ExerciseItemAnswerU.STATUS_UPDATE_CORRECT);
|
}else if(answerU.getCorrect() == ExerciseItemAnswerU.CORRECT_RIGHT &&
|
currCorrect == ExerciseItemAnswerU.CORRECT_ERROR){// ÉÏ´ÎÕýÈ·±¾´ÎÐÞ¸ÄΪ´íÎó ͳ¼ÆÕýÈ·½á¹û -1
|
answerU.setUpdateStatus(ExerciseItemAnswerU.STATUS_UPDATE_ERROR);
|
}
|
|
answerU.setLastAnswer(answerU.getAnswer());// ´æ´¢ÉÏÒ»´Î´ð°¸
|
answerU.setAnswer(answer.getAnswer());
|
answerU.setCorrect(currCorrect);
|
answerU.setTeacherScore(answer.getTeacherScore());
|
|
if(StringUtils.isBlank(answer.getAnswer())){// È¡Ïû´ð°¸ ɾ³ý
|
answerU.setDeleteFlag(true);
|
}
|
|
TraceUtils.setUpdateTrace(answerU);
|
}
|
|
lstNewAnswerU.add(answerU);
|
}
|
|
//ÅúÁ¿±£´æ
|
this.saveOrUpdateAll(lstNewAnswerU);
|
// this.flush();
|
|
// -----------------¿ªÊ¼´ðÌâ½á¹ûͳ¼Æ-------------------
|
// sendMsgExerciseStatistics(lstNewAnswerU, exerciseGroupId);
|
|
return new Result(true);
|
|
}
|
|
/**
|
*
|
* ͳ¼ÆÓû§×öÌâ½á¹ûÊý¾Ý
|
* @return
|
*/
|
@Override
|
public Result doStatisUserExerciseItemData(String userId, String userName, ExerciseSubmitAnswerData answerData) {
|
|
// Êý¾Ýͳ¼Æ
|
List<ExerciseItemAnswerData> lstAnswers = answerData.getItems();
|
|
if(lstAnswers.isEmpty()){
|
return new Result(false,"Êý¾ÝΪ¿Õ");
|
}
|
|
ExerciseItemAnalisi analisis = null;
|
ExerciseItemAnalisiU analisisU = null;
|
String exerciseItemId = null;
|
int number = 0;
|
Result result;
|
String hql_analisis;
|
String hql_analisisU;
|
|
for(ExerciseItemAnswerData answer:lstAnswers){
|
number = 0;
|
exerciseItemId = answer.getExerciseId();
|
|
if(ExerciseItemAnswerU.CORRECT_RIGHT_STR.equals(answer.getCorrect())){// ´ð°¸ÕýÈ·
|
number = 1;
|
}
|
|
// 1¡¢È«Õ¾Í³¼Æ
|
hql_analisis = "update ExerciseItemAnalisi"
|
+ " set submitNumber=IFNULL(submitNumber,0)+1"
|
+ ",submitCorrectNumber=IFNULL(submitCorrectNumber,0)+"+number
|
+ ",updateId='" + userId
|
+ "',updator='" + userName
|
+ "',accuracy=round(submitCorrectNumber/submitNumber*100, 2)"
|
+ " where exerciseItemId=? and deleteFlag is false";
|
|
result = this.bulkUpdate(hql_analisis, new String[]{exerciseItemId});
|
|
if(Integer.parseInt(String.valueOf(result.getData("doCount"))) < 1){// Ϊ¿Õ ÐÂÔö¼Ç¼
|
analisis = new ExerciseItemAnalisi();
|
analisis.setDeleteFlag(false);
|
analisis.setExerciseItemId(exerciseItemId);
|
analisis.setCreateId(userId);
|
analisis.setCreateTime(DateUtils.getCurrTime());
|
analisis.setCreator(userName);
|
analisis.setUpdateId(userId);
|
analisis.setUpdateTime(DateUtils.getCurrTime());
|
analisis.setUpdator(userName);
|
analisis.setSubmitNumber(BigInteger.ONE);
|
analisis.setSubmitCorrectNumber(new BigInteger(String.valueOf(number)));
|
analisis.setAccuracy(ExerciseUtils.parseStrToBigDecimal(
|
String.valueOf(analisis.getSubmitCorrectNumber()), String.valueOf(analisis.getSubmitNumber())));
|
|
this.save(analisis);
|
}
|
|
// 2¡¢¸öÈËͳ¼Æ
|
hql_analisisU = "update ExerciseItemAnalisiU"
|
+ " set submitNumber=IFNULL(submitNumber,0)+1"
|
+ ",submitCorrectNumber=IFNULL(submitCorrectNumber,0)+"+number
|
+ ",updateId='" + userId
|
+ "',updator='" + userName
|
+ "',accuracy=round(submitCorrectNumber/submitNumber*100, 2)"
|
+ " where exerciseItemId=?"
|
+ " and userId='"+userId
|
+ "' and deleteFlag is false";
|
|
result = this.bulkUpdate(hql_analisisU, new String[]{exerciseItemId});
|
|
if(Integer.parseInt(String.valueOf(result.getData("doCount"))) < 1){// Ϊ¿Õ ÐÂÔö¼Ç¼
|
analisisU = new ExerciseItemAnalisiU();
|
analisisU.setDeleteFlag(false);
|
analisisU.setExerciseItemId(exerciseItemId);
|
analisisU.setUserId(userId);
|
analisisU.setCreateId(userId);
|
analisisU.setCreateTime(DateUtils.getCurrTime());
|
analisisU.setCreator(userName);
|
analisisU.setUpdateId(userId);
|
analisisU.setUpdateTime(DateUtils.getCurrTime());
|
analisisU.setUpdator(userName);
|
analisisU.setSubmitNumber(BigInteger.ONE);
|
analisisU.setSubmitCorrectNumber(new BigInteger(String.valueOf(number)));
|
analisisU.setAccuracy(ExerciseUtils.parseStrToBigDecimal(
|
String.valueOf(analisisU.getSubmitCorrectNumber()), String.valueOf(analisisU.getSubmitNumber())));
|
|
this.save(analisisU);
|
}
|
}
|
|
return new Result(true);
|
}
|
|
|
/**
|
* ²éѯÿµÀÌâ ×öÌâ¸öÊý£¬ÕýÈ·¸öÊý
|
* @return
|
*/
|
private Map<String,ExerciseItemStatis> getExerciseItemAnalisisResultDataList(Map<String, Object> argsMap){
|
|
String sql = "select tmp.EXERCISE_ITEM_ID,sum(allCount),sum(correctCount) from ("
|
+ " select t.EXERCISE_ITEM_ID,count(1) allCount,sum(t.CORRECT=1) correctCount from exercise_item_answer_u t"// 1.£¨¹«¹²´ð°¸±í£©²éѯÿµÀÌâ ×öÌâ¸öÊý£¬ÕýÈ·¸öÊý
|
+ " where t.EXERCISE_ITEM_ID in (:exerciseIds) and t.DELETE_FLAG=0"
|
+ " group by t.EXERCISE_ITEM_ID "
|
+ " union all "
|
+ " select t.EXERCISE_ITEM_ID,count(1) allCount,sum(t.CORRECT=1) correctCount from exercise_fault t" // 2.´íÌâ±¾
|
+ " where t.EXERCISE_ITEM_ID in (:exerciseIds) and t.answer is not null and t.DELETE_FLAG=0"
|
+ " group by t.EXERCISE_ITEM_ID "
|
+ " union all "
|
+ " select t.EXERCISE_ITEM_ID,count(1) allCount,sum(t.CORRECT=1) correctCount from exercise_fault_his t"// 3.´íÌâ±¾ÀúÊ·
|
+ " where t.EXERCISE_ITEM_ID in (:exerciseIds) and t.answer is not null and t.DELETE_FLAG=0"
|
+ " group by t.EXERCISE_ITEM_ID "
|
+ " union all "
|
+ " select t.EXERCISE_ITEM_ID,count(1) allCount,sum(t.CORRECT=1) correctCount from exercise_favorite t"// 4.Êղر¾
|
+ " where t.EXERCISE_ITEM_ID in (:exerciseIds) and t.answer is not null and t.DELETE_FLAG=0"
|
+ " group by t.EXERCISE_ITEM_ID "
|
+ " union all "
|
+ " select t.EXERCISE_ITEM_ID,count(1) allCount,sum(t.CORRECT=1) correctCount from exercise_favorite_his t"// 5.Êղر¾ÀúÊ·
|
+ " where t.EXERCISE_ITEM_ID in (:exerciseIds) and t.answer is not null and t.DELETE_FLAG=0"
|
+ " group by t.EXERCISE_ITEM_ID "
|
+ ") tmp group by tmp.EXERCISE_ITEM_ID ";
|
|
List<Object[]> lstResult = this.findByComplexSql(sql, argsMap, Object[].class);
|
|
if(lstResult.isEmpty()){
|
return null;
|
}
|
|
Map<String,ExerciseItemStatis> resultMap = new HashMap<String, ExerciseItemStatis>(lstResult.size());
|
ExerciseItemStatis statis = null;
|
for(Object[] obj:lstResult){
|
statis = new ExerciseItemStatis();
|
statis.setExerciseId(String.valueOf(obj[0]));
|
statis.setAllCount(Integer.parseInt(String.valueOf(obj[1])));// ×ܸöÊý
|
statis.setCorrectCount(Integer.parseInt(String.valueOf(obj[2])));// ÕýÈ·¸öÊý
|
|
resultMap.put(String.valueOf(obj[0]), statis);// Á·Ï°id
|
}
|
|
return resultMap;
|
}
|
|
/**
|
* Á·Ï°ÌâÄ¿µÄȫվͳ¼Æ
|
* @param answer
|
* @return
|
*/
|
public Result doOperExerciseItemAnalisisNew(String userId, String userName,Map<String, Object> argsMap){
|
Object[] exerIds = (Object[]) argsMap.get("exerciseIds");
|
|
if(exerIds.length<1){
|
return new Result(false,"Êý¾ÝΪ¿Õ");
|
}
|
|
// 1.²éѯÿµÀÌâ ×öÌâ¸öÊý£¬ÕýÈ·¸öÊý
|
Map<String,ExerciseItemStatis> analisResultMap = getExerciseItemAnalisisResultDataList(argsMap);
|
|
if(analisResultMap.isEmpty()){
|
return new Result(false,"²éѯȫվͳ¼ÆÊý¾ÝΪ¿Õ£¬Òì³£");
|
}
|
|
// 2.ÌâÄ¿µÄȫվͳ¼Æ ExerciseItemAnalisi
|
|
String hql_analisis = "from ExerciseItemAnalisi where deleteFlag is false and exerciseItemId in (:exerciseIds) ";
|
List<ExerciseItemAnalisi> lstAnalisis = this.findByComplexHql(hql_analisis, argsMap, ExerciseItemAnalisi.class);
|
Map<String, ExerciseItemAnalisi> analisisMap = new HashMap<String, ExerciseItemAnalisi>();
|
for(ExerciseItemAnalisi analisis:lstAnalisis){
|
analisisMap.put(analisis.getExerciseItemId(), analisis);
|
}
|
|
List<ExerciseItemAnalisi> lstNewAnalisis = new ArrayList<ExerciseItemAnalisi>(exerIds.length);
|
ExerciseItemAnalisi analisis = null;
|
String exerciseItemId = null;
|
|
ExerciseItemStatis statis = null;
|
// ÅúÁ¿²Ù×÷
|
for(Object obj:exerIds){
|
|
exerciseItemId = String.valueOf(obj);
|
// 1.×é×°ÅúÁ¿Á·Ï°´ð°¸
|
if(analisisMap.get(exerciseItemId) == null){//Ϊ¿Õ ÐÂÔöÒ»¸ö
|
// ×é×°´ð°¸¼Ç¼
|
analisis = new ExerciseItemAnalisi();
|
analisis.setDeleteFlag(false);
|
analisis.setExerciseItemId(exerciseItemId);
|
|
analisis.setCreateId(userId);
|
analisis.setCreateTime(DateUtils.getCurrTime());
|
analisis.setCreator(userName);
|
|
}else{
|
analisis = analisisMap.get(exerciseItemId);
|
}
|
|
analisis.setUpdateId(userId);
|
analisis.setUpdateTime(DateUtils.getCurrTime());
|
analisis.setUpdator(userName);
|
|
// ¸üÐÂͳ¼ÆÊý¾Ý
|
statis = analisResultMap.get(exerciseItemId);
|
if(null != statis){
|
analisis.setSubmitNumber(new BigInteger(String.valueOf(statis.getAllCount())));
|
analisis.setSubmitCorrectNumber(new BigInteger(String.valueOf(statis.getCorrectCount())));
|
analisis.setAccuracy(ExerciseUtils.parseStrToBigDecimal(
|
String.valueOf(statis.getCorrectCount()), String.valueOf(statis.getAllCount())));
|
}else{
|
analisis.setSubmitNumber(BigInteger.ZERO);
|
analisis.setSubmitCorrectNumber(BigInteger.ZERO);
|
analisis.setAccuracy(BigDecimal.ZERO);
|
}
|
|
lstNewAnalisis.add(analisis);
|
}
|
|
//ÅúÁ¿±£´æ
|
this.saveOrUpdateAll(lstNewAnalisis);
|
|
return new Result(true);
|
}
|
|
/**
|
* Á·Ï°ÌâÄ¿µÄ¸öÈËͳ¼Æ
|
* @param answer
|
* @return
|
*/
|
public Result doOperExerciseItemAnalisisUNew(String userId, String userName, Map<String, Object> argsMap){
|
Map<String, Object> argsAnalisiMap = argsMap;
|
Object[] exerIds = (Object[]) argsMap.get("exerciseIds");
|
|
if(exerIds.length<1){
|
return new Result(false,"Êý¾ÝΪ¿Õ");
|
}
|
|
// 1. ²éѯ¸öÈË Ã¿µÀÌâ ×öÌâ¸öÊý£¬ÕýÈ·¸öÊý
|
Map<String,ExerciseItemStatis> analisUResultMap = getExerciseItemAnalisisUResultDataList(userId, argsMap);
|
|
if(analisUResultMap.isEmpty()){
|
return new Result(false,"²éѯȫվͳ¼ÆÊý¾ÝΪ¿Õ£¬Òì³£");
|
}
|
|
// 2.ÌâÄ¿µÄ¸öÈËͳ¼Æ ExerciseItemAnalisiU
|
String hql_analisisU = "from ExerciseItemAnalisiU where deleteFlag is false "
|
+ " and exerciseItemId in (:exerciseIds) and userId=:userId ";
|
argsAnalisiMap.put("userId", userId);
|
List<ExerciseItemAnalisiU> lstAnalisiU = this.findByComplexHql(hql_analisisU, argsAnalisiMap, ExerciseItemAnalisiU.class);
|
Map<String, ExerciseItemAnalisiU> analisisUMap = new HashMap<String, ExerciseItemAnalisiU>();
|
for(ExerciseItemAnalisiU analisiU:lstAnalisiU){
|
analisisUMap.put(analisiU.getExerciseItemId(), analisiU);
|
}
|
|
List<ExerciseItemAnalisiU> lstNewAnalisiU = new ArrayList<ExerciseItemAnalisiU>(argsMap.size());
|
ExerciseItemAnalisiU analisisU = null;
|
ExerciseItemStatis statis = null;
|
|
String exerciseItemId = null;
|
// ÅúÁ¿²Ù×÷
|
for(Object obj:exerIds){
|
|
exerciseItemId = String.valueOf(obj);
|
|
// 1.×é×°ÅúÁ¿Á·Ï°´ð°¸
|
if(analisisUMap.get(exerciseItemId) == null){//Ϊ¿Õ ÐÂÔöÒ»¸ö
|
// ×é×°´ð°¸¼Ç¼
|
analisisU = new ExerciseItemAnalisiU();
|
analisisU.setDeleteFlag(false);
|
analisisU.setExerciseItemId(exerciseItemId);
|
analisisU.setUserId(userId);
|
|
analisisU.setCreateId(userId);
|
analisisU.setCreateTime(DateUtils.getCurrTime());
|
analisisU.setCreator(userName);
|
}else{
|
analisisU = analisisUMap.get(exerciseItemId);
|
}
|
|
// ¸üÐÂͳ¼ÆÊý¾Ý
|
statis = analisUResultMap.get(exerciseItemId);
|
if(null != statis){
|
analisisU.setSubmitNumber(new BigInteger(String.valueOf(statis.getAllCount())));
|
analisisU.setSubmitCorrectNumber(new BigInteger(String.valueOf(statis.getCorrectCount())));
|
analisisU.setAccuracy(ExerciseUtils.parseStrToBigDecimal(
|
String.valueOf(statis.getCorrectCount()), String.valueOf(statis.getAllCount())));
|
}else{
|
analisisU.setSubmitNumber(BigInteger.ZERO);
|
analisisU.setSubmitCorrectNumber(BigInteger.ZERO);
|
analisisU.setAccuracy(BigDecimal.ZERO);
|
}
|
|
analisisU.setUpdateId(userId);
|
analisisU.setUpdateTime(DateUtils.getCurrTime());
|
analisisU.setUpdator(userName);
|
|
lstNewAnalisiU.add(analisisU);
|
}
|
|
//ÅúÁ¿±£´æ
|
this.saveOrUpdateAll(lstNewAnalisiU);
|
|
return new Result(true);
|
}
|
|
|
/**
|
* ²éѯ¸öÈË Ã¿µÀÌâ ×öÌâ¸öÊý£¬ÕýÈ·¸öÊý
|
* @return
|
*/
|
private Map<String,ExerciseItemStatis> getExerciseItemAnalisisUResultDataList(String userId, Map<String, Object> argsMap){
|
|
argsMap.put("userId", userId);
|
|
String sql = "select tmp.EXERCISE_ITEM_ID,sum(allCount),sum(correctCount) from ("
|
+ " select t.EXERCISE_ITEM_ID,count(1) allCount,sum(t.CORRECT=1) correctCount from exercise_item_answer_u t"// 1.£¨¹«¹²´ð°¸±í£©²éѯÿµÀÌâ ×öÌâ¸öÊý£¬ÕýÈ·¸öÊý
|
+ " where t.EXERCISE_ITEM_ID in (:exerciseIds) and t.user_id=:userId and t.DELETE_FLAG=0"
|
+ " group by t.EXERCISE_ITEM_ID "
|
+ " union all "
|
+ " select t.EXERCISE_ITEM_ID,count(1) allCount,sum(t.CORRECT=1) correctCount from exercise_fault t, exercise_fault_book b "// 2.´íÌâ±¾
|
+ " where t.RESUME_BOOK_ID=b.RESUME_BOOK_ID and t.EXERCISE_ITEM_ID in (:exerciseIds) and b.user_id=:userId"
|
+ " and t.answer is not null and t.DELETE_FLAG=0"
|
+ " group by t.EXERCISE_ITEM_ID "
|
+ " union all "
|
+ " select t.EXERCISE_ITEM_ID,count(1) allCount,sum(t.CORRECT=1) correctCount from exercise_fault_his t, exercise_fault_book b "// 3.´íÌâ±¾ÀúÊ·
|
+ " where t.RESUME_BOOK_ID=b.RESUME_BOOK_ID and t.EXERCISE_ITEM_ID in (:exerciseIds) and b.user_id=:userId"
|
+ " and t.answer is not null and t.DELETE_FLAG=0"
|
+ " group by t.EXERCISE_ITEM_ID "
|
+ " union all "
|
+ " select t.EXERCISE_ITEM_ID,count(1) allCount,sum(t.CORRECT=1) correctCount from exercise_favorite t, exercise_favorite_book b "// 4.Êղر¾
|
+ " where t.FAVORITE_BOOK_ID=b.FAVORITE_BOOK_ID and t.EXERCISE_ITEM_ID in (:exerciseIds) and b.user_id=:userId"
|
+ " and t.answer is not null and t.DELETE_FLAG=0 "
|
+ " group by t.EXERCISE_ITEM_ID "
|
+ " union all "
|
+ " select t.EXERCISE_ITEM_ID,count(1) allCount,sum(t.CORRECT=1) correctCount from exercise_favorite_his t, exercise_favorite_book b "// 5.Êղر¾ÀúÊ·
|
+ " where t.FAVORITE_BOOK_ID=b.FAVORITE_BOOK_ID and t.EXERCISE_ITEM_ID in (:exerciseIds) and b.user_id=:userId"
|
+ " and t.answer is not null and t.DELETE_FLAG=0 "
|
+ " group by t.EXERCISE_ITEM_ID "
|
+ ") tmp group by tmp.EXERCISE_ITEM_ID ";
|
|
List<Object[]> lstResult = this.findByComplexSql(sql, argsMap, Object[].class);
|
|
if(lstResult.isEmpty()){
|
return null;
|
}
|
|
Map<String,ExerciseItemStatis> resultMap = new HashMap<String, ExerciseItemStatis>(lstResult.size());
|
ExerciseItemStatis statis = null;
|
for(Object[] obj:lstResult){
|
statis = new ExerciseItemStatis();
|
statis.setExerciseId(String.valueOf(obj[0]));
|
statis.setAllCount(Integer.parseInt(String.valueOf(obj[1])));// ×ܸöÊý
|
statis.setCorrectCount(Integer.parseInt(String.valueOf(obj[2])));// ÕýÈ·¸öÊý
|
|
resultMap.put(String.valueOf(obj[0]), statis);// Á·Ï°id
|
}
|
|
return resultMap;
|
}
|
|
/**
|
* ²éѯ×ÔÓÉÁ·Ï°Á·Ï°×öÌâ×é
|
* @param exerType
|
* @param subjectId
|
* @param pager
|
* @param selected
|
* @return
|
*/
|
private List<ExerciseGroup> queryFreeExerciseGroupList(short exerType,
|
String subjectId, Pager pager, int selected){
|
|
StringBuffer hql = new StringBuffer(512);
|
hql.append("select g from ExerciseGroup g, ExerciseRecord r,ExerciseRecentRecord rr "
|
+ " where g.groupId = r. exerciseGroupId"
|
+ " and r.recordId=rr.exerciseRecordId"
|
+ " and g.deleteFlag is false "
|
+ " and r.deleteFlag is false "
|
+ " and g.type=?"
|
+ " and g.classId=? "
|
+ " and r.userId=? and g.status = ?");
|
|
List<Object> args = CollectionUtils.newList((short)exerType, ClientUtils.getClassId(),ClientUtils.getUserId(), ExerciseGroup.STATUS_PUBLISHED);
|
|
if(selected == 1){//δ¿ªÊ¼
|
hql.append(" and r.status=? and (r.doCount=0 or r.doCount is null) ");
|
args.add(ExerciseRecord.STATUS_NOT_SUBMIT);
|
|
}else if(selected == 2){//×öÌâÖÐ
|
|
hql.append(" and r.status=? and r.doCount>0 ");
|
args.add(ExerciseRecord.STATUS_NOT_SUBMIT);
|
|
}else if(selected == 3){//ÒÑÌá½»
|
|
hql.append( " and r.status=? ");
|
args.add(ExerciseRecord.STATUS_SUBMIT);
|
}
|
|
// if(StringUtils.isNotBlank(subjectId)){// ¸ßУ ¿Î³Ìid
|
// hql.append(" and g.subjectId=? ");
|
// args.add(subjectId);
|
// }
|
|
hql.append( " order by g.orderNum asc,g.updateTime desc ");
|
|
List<ExerciseGroup> lstGroup = this.findList(hql.toString(), pager, args, ExerciseGroup.class);
|
|
return lstGroup;
|
}
|
|
/**
|
* ²éѯͨÓÃÁ·Ï°×öÌâ×é
|
* @param exerType
|
* @param subjectId
|
* @param pager
|
* @param selected
|
* @return
|
*/
|
private List<ExerciseGroup> queryCommonExerciseGroupList(short exerType,
|
String subjectId, Pager pager, int selected, String chapterId){
|
StringBuffer hql = new StringBuffer(512);
|
hql.append("from ExerciseGroup g "
|
+ " where g.deleteFlag is false "
|
+ " and g.type=?"
|
+ " and g.classId=? and g.status = ? ");
|
|
List<Object> args = CollectionUtils.newList((short)exerType, ClientUtils.getClassId(), ExerciseGroup.STATUS_PUBLISHED);
|
|
if(selected == 1){//δ¿ªÊ¼
|
hql.append(" and not EXISTS" +
|
" (select 1 from ExerciseRecord r,ExerciseRecentRecord rr " +
|
" where r.recordId=rr.exerciseRecordId " +
|
" and r.exerciseGroupId=g.groupId " +
|
" and r.userId = ?" +
|
" and (r.status = ? or r.doCount > 0)" +
|
" )");
|
|
args.add(ClientUtils.getUserId());
|
args.add(ExerciseRecord.STATUS_SUBMIT);
|
|
}else if(selected == 2){//×öÌâÖÐ
|
hql.append(" and EXISTS" +
|
" (select 1 from ExerciseRecord r,ExerciseRecentRecord rr " +
|
" where r.recordId=rr.exerciseRecordId " +
|
" and r.exerciseGroupId=g.groupId " +
|
" and r.userId = ?" +
|
" and (r.status = ? and r.doCount > 0)" +
|
" )");
|
|
args.add(ClientUtils.getUserId());
|
args.add(ExerciseRecord.STATUS_NOT_SUBMIT);
|
|
}else if(selected == 3){//ÒÑÌá½»
|
hql.append(" and EXISTS" +
|
" (select 1 from ExerciseRecord r,ExerciseRecentRecord rr " +
|
" where r.recordId=rr.exerciseRecordId " +
|
" and r.exerciseGroupId=g.groupId " +
|
" and r.userId = ?" +
|
" and r.status = ? " +
|
" )");
|
|
args.add(ClientUtils.getUserId());
|
args.add(ExerciseRecord.STATUS_SUBMIT);
|
|
}
|
|
if(StringUtils.isNotBlank(subjectId)){// ¸ßУ ¿Î³Ìid
|
hql.append(" and g.subjectId=? ");
|
args.add(subjectId);
|
}
|
if(StringUtils.isNotBlank(chapterId)){// Õ½Úid
|
hql.append(" and (g.chapterId=? or g.chapterId in(select c.chapterId from SchChapter c where c.parentChapterId = ? and c.deleteFlag is false)) ");
|
args.add(chapterId);
|
args.add(chapterId);
|
}
|
|
if(exerType == ExerciseGroup.TYPE_EXERCISE_FREE){
|
|
hql.append(" order by g.updateTime desc ");
|
|
}else{
|
|
hql.append(" order by g.subjectOrder asc,g.chapterOrder asc,g.partOrder asc, g.orderNum asc, g.createTime desc ");
|
}
|
|
List<ExerciseGroup> lstGroup = this.findList(hql.toString(), pager, args, ExerciseGroup.class);
|
|
return lstGroup;
|
}
|
|
/**
|
* ²éѯÁ·Ï°ÁбíÊý¾Ý
|
* @param exerType
|
* @param subjectId
|
* @param pager
|
* @param selected // 0:È«²¿ 1£ºÎ´¿ªÊ¼ 2£º×öÌâÖÐ 3£ºÒÑÌá½»
|
* @return
|
*/
|
@Override
|
public List<ExerGroupResponseData> queryExericseListData(short exerType,
|
String subjectId, Pager pager, Integer selected, String chapterId) {
|
|
List<ExerciseGroup> lstGroup = null;
|
|
// 1.²éѯµ±Ç°Óû§ËùÔڰ༶µÄÁ·Ï°×é
|
if(exerType == ExerciseGroup.TYPE_EXERCISE_FREE){//×ÔÓÉÁ·Ï°
|
|
lstGroup = queryFreeExerciseGroupList(exerType, subjectId, pager, selected);
|
|
}else{// ·Ç×ÔÓÉÁ·Ï°
|
|
lstGroup = queryCommonExerciseGroupList(exerType, subjectId, pager, selected, chapterId);
|
}
|
|
if(lstGroup.isEmpty()){
|
return null;
|
}
|
|
// 3.×é×°²ÎÊý
|
Map<String, Object> argsMap = new HashMap<String, Object>(2);
|
Object[] argss = new Object[lstGroup.size()];
|
for(int i=0; i<lstGroup.size(); i++){
|
argss[i] = lstGroup.get(i).getGroupId();
|
}
|
argsMap.put("groupIds", argss);
|
|
// 4.0²éѯÁ·Ï°×éextend
|
String hql_extend = "from ExerciseGroupExtend "
|
+ " where groupId in (:groupIds) and deleteFlag is false ";
|
List<ExerciseGroupExtend> lstExtend = this.findByComplexHql(hql_extend, argsMap, ExerciseGroupExtend.class);
|
Map<String, ExerciseGroupExtend> extendMap = new HashMap<String, ExerciseGroupExtend>(lstExtend.size());
|
for(ExerciseGroupExtend record:lstExtend){
|
extendMap.put(record.getGroupId(), record);
|
}
|
|
// 4.²éѯ×öÌâ¼Ç¼¼¯ºÏ
|
argsMap.put("userId", ClientUtils.getUserId());
|
String hql_record = "select r from ExerciseRecord r,ExerciseRecentRecord rd "
|
+ " where r.recordId=rd.exerciseRecordId and rd.exerciseGroupId in (:groupIds) and rd.userId=:userId ";
|
List<ExerciseRecord> lstRecord = this.findByComplexHql(hql_record, argsMap, ExerciseRecord.class);
|
Map<String, ExerciseRecord> recordMap = new HashMap<String, ExerciseRecord>(lstRecord.size());
|
for(ExerciseRecord record:lstRecord){
|
recordMap.put(record.getExerciseGroupId(), record);
|
}
|
|
// 4.2»ñÈ¡¸ÃÓû§×éÄÚÅÅÃû
|
Map<String, String> groupRankMap = getUserExerGroupRank(argss);
|
|
// 4.3»ñÈ¡¸öÈËÓû§×é¶ÔÓ¦µÄ´íÌâ¼Ç¼ ÌâÄ¿¸üÐÂʱ¼ä
|
Map<String, Map<String, Object>> faultMap = exerciseExtendService.queryFaultRecordByGroup(subjectId, argss);
|
|
// 4.4»ñÈ¡¸öÈËÓû§×é¶ÔÓ¦µÄÊղؼǼ ÌâÄ¿¸üÐÂʱ¼ä
|
Map<String, Map<String, Object>> favorMap = exerciseExtendService.queryFavorRecordByGroup(subjectId, argss);
|
|
// 5.×é×°²ÎÊý
|
List<ExerGroupResponseData> lstResult = new ArrayList<ExerGroupResponseData>(lstRecord.size());
|
|
ExerGroupResponseData result;
|
for(ExerciseGroup g:lstGroup){
|
// ×é×°Á·Ï°ÁÐ±í·µ»ØÊý¾Ý
|
result = packagingExerciseListData(exerType, extendMap, recordMap,
|
groupRankMap, faultMap, favorMap, g);
|
|
lstResult.add(result);
|
}
|
|
return lstResult;
|
}
|
|
/**
|
* ×é×°Á·Ï°ÁÐ±í·µ»ØÊý¾Ý
|
* @param exerType
|
* @param extendMap
|
* @param recordMap
|
* @param groupRankMap
|
* @param faultMap
|
* @param favorMap
|
* @param g
|
* @return
|
*/
|
private ExerGroupResponseData packagingExerciseListData(short exerType,
|
Map<String, ExerciseGroupExtend> extendMap,
|
Map<String, ExerciseRecord> recordMap,
|
Map<String, String> groupRankMap,
|
Map<String, Map<String, Object>> faultMap,
|
Map<String, Map<String, Object>> favorMap, ExerciseGroup g) {
|
|
String groupId = g.getGroupId();
|
ExerGroupResponseData result = new ExerGroupResponseData();
|
|
// 5.1.¸³ÖµÁ·Ï°¼Ç¼×Ö¶Î
|
ExerciseRecord record=recordMap.get(groupId);
|
if(null != record){
|
BeanUtils.copyProperties(record, result);
|
|
result.setAnswerUpdateTime(record.getUpdateTime());
|
result.setCurrTitleNumber(record.getTitleMaxNumber());
|
result.setExerciseRecordId(record.getRecordId());
|
}else{
|
result.setAccuracy(BigDecimal.ZERO);
|
result.setCompletionRate(BigDecimal.ZERO);
|
result.setDoCount(BigInteger.ZERO);
|
result.setCurrTitleNumber("0");
|
result.setCorrectCount(BigInteger.ZERO);
|
result.setScore(BigDecimal.ZERO);
|
result.setStatus("0");
|
}
|
|
// 5.3.¸³ÖµÁ·Ï°×é×Ö¶Î
|
BeanUtils.copyProperties(g, result);
|
|
// 5.4 »ñÈ¡Á·Ï°×éÀ©Õ¹±í
|
ExerciseGroupExtend extend = extendMap.get(groupId);
|
if(null != extend){// À©Õ¹±í×Ö¶Î
|
result.setExerciseTime(extend.getExerciseTime());
|
result.setExerciseMode(extend.getExerciseMode());
|
result.setExerciseStrategy(extend.getExerciseStrategy());
|
result.setExerciseSource(extend.getExerciseSource());
|
result.setRepeatFlag(!extend.getRepeatFlag());// true ¿ÉÒÔÖØ×ö false²»ÄÜÖØ×ö
|
result.setClassAccuracy(extend.getClassAccuracy() == null ? "--" : extend.getClassAccuracy()+"%");
|
result.setSubmitNumber(extend.getSubmitNumber());
|
}else{
|
result.setClassAccuracy("--");
|
if(exerType == ExerciseGroup.TYPE_HOMEWORK){// ¼ÒÍ¥×÷Òµ
|
result.setRepeatFlag(false);
|
}else{
|
result.setRepeatFlag(true);
|
}
|
}
|
|
// 5.5 »ñÈ¡Óû§×éÄÚÅÅÃû
|
result.setClassRank(groupRankMap.get(groupId) == null ? "--" : groupRankMap.get(groupId));
|
|
// 5.6¸üиöÈËÓû§×é¶ÔÓ¦µÄ´íÌâʱ¼ä
|
if(faultMap != null && faultMap.get(groupId) !=null){
|
result.setFaultUpdateTime((Timestamp)faultMap.get(groupId).get("updateTime"));
|
result.setFaultCount((BigInteger)faultMap.get(groupId).get("allCount"));
|
}
|
|
// 5.7¸üиöÈËÓû§×é¶ÔÓ¦µÄÊÕ²Øʱ¼ä
|
if(favorMap != null && favorMap.get(groupId) !=null){
|
result.setFavorUpdateTime((Timestamp)favorMap.get(groupId).get("updateTime"));
|
result.setFavorCount((BigInteger)favorMap.get(groupId).get("allCount"));
|
}
|
return result;
|
}
|
|
|
|
/**
|
* ¸ù¾ÝgroupidµÃ³ö¸ÃÓû§µÄ×éÄÚÅÅÃû
|
* @param argss
|
* @return
|
*/
|
public Map<String, String> getUserExerGroupRank(Object[] argss) {
|
Map<String, Object> argsMap = new HashMap<String, Object>(4);
|
|
argsMap.put("groupIds", argss);
|
argsMap.put("rankType", SchRank.RANK_TYPE_EXERCISE_SCORE);
|
argsMap.put("scopeType", SchRank.SCOPE_TYPE_CLASS_GROUP);
|
argsMap.put("userId", ClientUtils.getUserId());
|
|
String hql = "select ver.scopeId, his.rank from SchRankHis his,SchRankVer ver " +
|
"where his.versionId=ver.versionId " +
|
"and ver.latest is true " +
|
"and ver.scopeId in (:groupIds) " +
|
"and ver.rankType =:rankType " +
|
"and ver.scopeType =:scopeType " +
|
"and his.userId =:userId ";
|
|
List<Object[]> lstRanks = this.findByComplexHql(hql, argsMap, Object[].class);
|
|
|
Map<String, String> resultMap = new HashMap<String, String>(lstRanks.size());
|
for(Object[] objs:lstRanks){
|
resultMap.put(String.valueOf(objs[0]),
|
StringUtils.isBlank(String.valueOf(objs[1])) ? "--" : String.valueOf(objs[1]));
|
}
|
|
return resultMap;
|
}
|
|
@Override
|
public ExerItemResponseData queryExerItemResponseData(String groupId,
|
String exerciseRecordId, boolean getExercise, boolean getAnswer,
|
short exerType) {
|
|
// 1.»ñÈ¡Á·Ï°ÌâÄ¿
|
List<ExerciseItem> lstItem = null;
|
if(getExercise){
|
lstItem = queryExerciseItemList(groupId);
|
}
|
|
// 2.»ñÈ¡Á·Ï°´ð°¸
|
List<ExerciseItemAnswerU> lstAnswer = null;
|
if(getAnswer && StringUtils.isNotBlank(exerciseRecordId)){
|
lstAnswer = queryExerciseItemAnswerList(exerciseRecordId);
|
}
|
|
// 3.×é×°·µ»Ø²ÎÊý
|
ExerItemResponseData result = new ExerItemResponseData();
|
|
result.setItems(lstItem);
|
|
result.setAnswers(lstAnswer);
|
|
return result;
|
}
|
|
/**
|
* ²éѯÁ·Ï°´ð°¸list
|
* @param groupId
|
* @param exerciseRecordId
|
* @return
|
*/
|
private List<ExerciseItemAnswerU> queryExerciseItemAnswerList(String exerciseRecordId){
|
|
//3.1 ²éѯ¸öÈË×öÌâ´ð°¸
|
String sql_answerU = "from ExerciseItemAnswerU where exerciseRecordId=? and deleteFlag is false order by createTime asc ";
|
|
List<ExerciseItemAnswerU> lstAnswerU = this.find(sql_answerU,
|
CollectionUtils.newList(exerciseRecordId), ExerciseItemAnswerU.class);
|
|
return lstAnswerU;
|
}
|
|
/**
|
* ²éѯÁ·Ï°ÌâÄ¿list
|
* @param groupId
|
* @return
|
*/
|
@SuppressWarnings("unchecked")
|
@Override
|
public List<ExerciseItem> queryExerciseItemList(String groupId){
|
BoundValueOperations<String, List<ExerciseItem>> boundValueOperations = redisTemplate.boundValueOps(groupId);
|
List<ExerciseItem> lstItems = boundValueOperations.get();
|
|
if(lstItems==null){
|
// 1.²éѯÁ·Ï°ÌâÄ¿ÐÅÏ¢
|
String hql = "select item from ExerciseItem item, ExerciseGroupItemRe re, ExerciseGroup g"
|
+ " where item.exerciseId=re.exerciseItemId "
|
+ " and re.exerciseGroupId=g.groupId"
|
+ " and g.groupId = ? "
|
+ " and item.deleteFlag is false "
|
+ " and g.deleteFlag is false"
|
+ " and re.deleteFlag is false"
|
+ " order by re.itemOrder";
|
|
lstItems = this.find(hql, CollectionUtils.newList(groupId), ExerciseItem.class);
|
|
// Ϊ¿Õ
|
if(lstItems.isEmpty()){
|
return lstItems;
|
}
|
// 2.×é×°´ð°¸
|
lstItems = getCommonExerItemDetail(lstItems, groupId);
|
|
boundValueOperations.setIfAbsent(lstItems);
|
boundValueOperations.expire(10, TimeUnit.DAYS);
|
}
|
|
return lstItems;
|
}
|
|
/**
|
* ÖØÐÂ×é×°Á·Ï°Ìâ ¼ÓÈë·ÖÎö½á¹û
|
* @param lstItems
|
* @param exerciseGroupId
|
* @param currTitleNumber
|
* @return
|
*/
|
@SuppressWarnings("unchecked")
|
@Override
|
public List<ExerciseItem> getCommonExerItemDetail(List<ExerciseItem> lstItems, String exerciseGroupId){
|
String userId = ClientUtils.getUserId();
|
|
// 0.×é×°²ÎÊý
|
Map<String, Object> argsMap = new HashMap<String, Object>();
|
Object[] args = new Object[lstItems.size()];
|
for(int i=0; i<lstItems.size(); i++){
|
args[i] = lstItems.get(i).getExerciseId();
|
}
|
argsMap.put("exerciseIds", args);
|
|
// 1.²éѯÁ·Ï°ÌâÄ¿È«Õ¾·ÖÎö
|
String hql_analisis = "from ExerciseItemAnalisi where exerciseItemId in (:exerciseIds) and deleteFlag is false ";
|
List<ExerciseItemAnalisi> lstAnalisis = this.findByComplexHql(hql_analisis, argsMap, ExerciseItemAnalisi.class);
|
Map<String, ExerciseItemAnalisi> analisiMap = new HashMap<String, ExerciseItemAnalisi>(lstAnalisis.size());
|
for(ExerciseItemAnalisi analisis:lstAnalisis){
|
analisiMap.put(analisis.getExerciseItemId(), analisis);
|
}
|
|
// 2.²éѯÁ·Ï°ÌâÄ¿´ð°¸Ñ¡Ïî
|
Map<String, List<ExerciseItemOption>> optionsMap = new HashMap<String, List<ExerciseItemOption>>(lstItems.size());
|
Map<String, String> answerMap = new HashMap<String, String>();
|
String hql_options = "from ExerciseItemOption where exerciseItemId in (:exerciseIds) and deleteFlag is false order by exerciseItemId, optionOrder ";
|
List<ExerciseItemOption> lstAllOptions = this.findByComplexHql(hql_options, argsMap, ExerciseItemOption.class);
|
// 2.1.×é×°²ÎÊý ÓÃÓÚ²éѯÁ·Ï°Ñ¡ÏîͼƬ
|
Map<String, Object> argsImgMap = new HashMap<String, Object>();
|
Object[] argImgs = new Object[lstAllOptions.size()];
|
for(int i=0; i<lstAllOptions.size(); i++){
|
argImgs[i] = lstAllOptions.get(i).getOptionId();
|
}
|
argsImgMap.put("optionIds", argImgs);
|
|
// 2-3-1²éѯÌâÄ¿ÊÇ·ñ¹ØÁªÍ¼Æ¬
|
// String hql_itemImgs = "from ExerciseObjectImg where exerciseObjectId in (:exerciseIds) and deleteFlag is false and objectType=1 order by exerciseObjectId,imgOrder ";
|
// List<ExerciseObjectImg> lstItemImgs = this.findByComplexHql(hql_itemImgs, argsMap, ExerciseObjectImg.class);
|
// Map<String, List<ExerciseObjectImg>> imgItemMap = ExerciseUtils.packageExerciseItemImg(lstItemImgs);
|
|
// 2-3-2²éѯÌâÄ¿Ñ¡ÏîÊÇ·ñ¹ØÁªÍ¼Æ¬
|
// String hql_optionImgs = "from ExerciseObjectImg where exerciseObjectId in (:optionIds) and deleteFlag is false and objectType=2 order by exerciseObjectId,imgOrder ";
|
// List<ExerciseObjectImg> lstOptionImgs = this.findByComplexHql(hql_optionImgs, argsImgMap, ExerciseObjectImg.class);
|
// Map<String, List<ExerciseObjectImg>> imgOptionMap = ExerciseUtils.packageExerciseItemImg(lstOptionImgs);
|
|
// ÖØÐÂ×é×°Á·Ï°
|
ExerciseUtils.packageExerciseItem(optionsMap, answerMap, lstAllOptions, Collections.EMPTY_MAP);
|
|
// 3.²éѯÁ·Ï°ÌâÄ¿¸öÈË·ÖÎö
|
String hql_analisisU = "from ExerciseItemAnalisiU where exerciseItemId in (:exerciseIds) and userId=:userId and deleteFlag is false ";
|
argsMap.put("userId", userId);
|
List<ExerciseItemAnalisiU> lstAnalisisU = this.findByComplexHql(hql_analisisU, argsMap, ExerciseItemAnalisiU.class);
|
Map<String, ExerciseItemAnalisiU> analisiUMap = new HashMap<String, ExerciseItemAnalisiU>(lstAnalisisU.size());
|
for(ExerciseItemAnalisiU analisisU:lstAnalisisU){
|
analisiUMap.put(analisisU.getExerciseItemId(), analisisU);
|
}
|
|
|
// 4.ÖØÐÂ×é×°·µ»Ø½á¹û
|
ExerciseAnalisisResult analisiResult = null;
|
ExerciseItemAnalisi analisis = null;
|
ExerciseItemAnalisiU analisiU = null;
|
String exerciseId = null;
|
for(ExerciseItem item:lstItems){
|
analisiResult = new ExerciseAnalisisResult();
|
|
// 4.0 ·ÖÎö½á¹û
|
exerciseId = item.getExerciseId();
|
|
// µÃµ½Á·Ï°×éid
|
if(StringUtils.isNotBlank(exerciseGroupId)){
|
item.setExerciseGroupId(exerciseGroupId);
|
}
|
|
// 4.1 È«Õ¾·ÖÎö½á¹û
|
analisis = analisiMap.get(exerciseId);
|
if(null != analisis){
|
analisiResult.setAllAccuracy(analisis.getAccuracy());
|
analisiResult.setSubmitAllNumber(analisis.getSubmitNumber());
|
analisiResult.setAnalysis(analisis.getAnalysis());
|
analisiResult.setUsualFaultAnswers(analisis.getUsualFaultAnswers());
|
}else{
|
analisiResult.setAllAccuracy(BigDecimal.ZERO);
|
analisiResult.setSubmitAllNumber(BigInteger.ZERO);
|
}
|
|
// 4.2 ¸öÈË·ÖÎö½á¹û
|
analisiU = analisiUMap.get(exerciseId);
|
if(analisiU != null){
|
analisiResult.setAccuracy(analisiU.getAccuracy());
|
analisiResult.setSubmitNumber(analisiU.getSubmitNumber());
|
analisiResult.setSubmitErrorNumber(analisiU.
|
getSubmitNumber().subtract(analisiU.getSubmitCorrectNumber()));
|
}else{
|
analisiResult.setAccuracy(BigDecimal.ZERO);
|
analisiResult.setSubmitNumber(BigInteger.ZERO);
|
analisiResult.setSubmitErrorNumber(BigInteger.ZERO);
|
}
|
|
// 4.3 ÌâÄ¿Ñ¡Ïî
|
item.setOptions(optionsMap.get(exerciseId));
|
|
// // 4.5ÌâÄ¿ÖÐÊÇ·ñÓÐͼƬ
|
// if(imgItemMap.get(exerciseId) != null){
|
// item.setImgs(imgItemMap.get(exerciseId));
|
// }
|
|
item.setAnalisisResult(analisiResult);
|
|
item.setAnalysises(null);
|
|
item.setScores(null);
|
|
}
|
|
return lstItems;
|
}
|
|
/**
|
* ¸ù¾ÝÌõ¼þ»ñÈ¡×ÔÓÉÁ·Ï°
|
*
|
* * {
|
* source: Á·Ï°À´Ô´(1:Á·Ï°Ìâ¿â 2£º¿¼ÊÔÌâ¿â 3£º¼ÒÍ¥×÷Òµ) ¶à¸öÒÔ¶ººÅ·Ö¿ª
|
strategy:×öÌⷽʽ£¨1£ºÎ´×öÌâÓÅÏÈ 2£º´íÌâÓÅÏÈ£©
|
mode:×öÌâģʽ(1:Á·Ï°Ä£Ê½ 2£º¿¼ÊÔģʽ)
|
count:ÊýÁ¿£¨30 50 100 200£©
|
exerciseTime:Á·Ï°Ê±¼ä
|
* }
|
*
|
* @return
|
*/
|
@Override
|
public ExerItemResponseData doGetFreeExercise(String subjectId, String source,
|
String strategy, String mode, int count, String exerciseTime) {
|
|
Result resultMsg = new Result(false);
|
ExerItemResponseData result = new ExerItemResponseData();
|
/** 1.µÃµ½Á·Ï°ÌâÄ¿ */
|
List<ExerciseItem> lstItems = getExerciseItemListForFree(subjectId, source, strategy, count);
|
|
if(lstItems.isEmpty()){
|
resultMsg.setMsg("µ±Ç°Ìâ¿âÖÐÌâÄ¿ÊýÁ¿Îª¿Õ");
|
result.setResult(resultMsg);
|
return result;
|
}
|
|
if(lstItems.size() < count){//Ìâ¿âÖÐÌâÄ¿²»¹»
|
resultMsg.setMsg("µ±Ç°Ìâ¿âÖÐÌâÄ¿ÊýÁ¿ÉÙÓÚ"+count+"£¬ÇëÖØÐÂ×éºÏ");
|
result.setResult(resultMsg);
|
return result;
|
}
|
|
/** 2.Éú³É´Ë´Î×öÌâÁ·Ï°×é */
|
ExerciseGroup group = generateExerciseGroupByFree(subjectId, source,
|
strategy, mode, count, exerciseTime);
|
|
String exerciseGroupId = group.getGroupId();
|
|
/** 3.Éú³É´Ë´Î×öÌârecord */
|
ExerciseRecord record = generateExerciseRecordByFree(subjectId, exerciseGroupId);
|
|
/** 4.¸ù¾ÝÌâÁ·Ï°×éÉú³ÉÁ·Ï°×é¹ØÁª±íÊý¾Ý */
|
generateExerciseGroupItemRe(lstItems, exerciseGroupId);
|
|
/** 5.×é×°Á·Ï°Êý¾Ý */
|
lstItems = getCommonExerItemDetail(lstItems, exerciseGroupId);
|
|
/** 6.·µ»Ø½á¹û */
|
result.setItems(lstItems);
|
result.setExerciseGroupId(exerciseGroupId);
|
result.setExerciseRecordId(record.getRecordId());
|
resultMsg.setResult(true);
|
|
Map<String, Object> resultMap = new HashMap<String, Object>(2);
|
resultMap.put("exerciseName", group.getName());
|
resultMap.put("updateTime", record.getUpdateTime());
|
|
resultMsg.setData(resultMap);
|
resultMsg.setMsg(group.getName());
|
result.setResult(resultMsg);
|
|
return result;
|
}
|
|
/**
|
* µÃµ½Á·Ï°ÀàÐÍ
|
* @param source
|
* @return
|
*/
|
private Object[] getExerciseTypeForFree(String source){
|
// Á·Ï°À´Ô´(1:Á·Ï°Ìâ¿â 2£º¿¼ÊÔÌâ¿â 3£º¼ÒÍ¥×÷Òµ) ¶à¸öÒÔ¶ººÅ·Ö¿ª
|
String[] types = source.split(",");
|
Object[] groupTypes = new Object[4];
|
|
|
int i = 0;
|
for(String type:types){
|
|
if(type.equals(Constants.EXERCISE_SOURCE_EXERICSE)){//Á·Ï°Ìâ¿â -Õ½ڡ¢×¨Ìâ
|
|
groupTypes[i]= ExerciseGroup.TYPE_CHAPTER_ITEM;
|
|
i++;
|
|
groupTypes[i]= ExerciseGroup.TYPE_EXERCISE_TOPIC;
|
|
i++;
|
|
}else if(type.equals(Constants.EXERCISE_SOURCE_EXAMS)){// ¿¼ÊÔÌâ¿â - Ä£Ä⿼ÊÔ
|
|
groupTypes[i]= ExerciseGroup.TYPE_MOCK_EXAM;
|
|
i++;
|
|
}else if(type.equals(Constants.EXERCISE_SOURCE_HOMEWORK)){// ¼ÒÍ¥×÷Òµ
|
|
groupTypes[i]= ExerciseGroup.TYPE_HOMEWORK;
|
|
i++;
|
}
|
|
}
|
|
return groupTypes;
|
}
|
|
/**
|
* µÃµ½Á·Ï°Ìâ
|
* @param subjectId
|
* @param source
|
* @param strategy
|
* @param count
|
* @return
|
*/
|
private List<ExerciseItem> getExerciseItemListForFree(String subjectId,
|
String source, String strategy, int count){
|
|
// µÃµ½×éÀàÐͼ¯ºÏ
|
Object[] groupTypes = getExerciseTypeForFree(source);
|
|
// ²éѯ½á¹ûÁ·Ï°item list
|
List<ExerciseItem> lstItems = null;
|
|
// ²éѯ½á¹û²»¹»Ê±£¬ÐÂÔöÁ·Ï°item list
|
List<ExerciseItem> lstAddItems = null;
|
|
/** 1.»ñÈ¡ÌâÄ¿ */
|
if(Constants.EXERCISE_STRATEGY_NO_DO.equals(strategy)){// δ×öÌâ
|
|
// 1.»ñȡδ×öÌâ
|
lstItems = getFreeExerciseForNoDo(subjectId, count, groupTypes);
|
|
}else if(Constants.EXERCISE_STRATEGY_FAULT.equals(strategy)){// ´íÌâ
|
|
// 1.»ñÈ¡´íÌâ
|
lstItems = getFreeExerciseForFault(subjectId, count, groupTypes);
|
|
}
|
|
// 2.´íÌâ²»¹»£¬´ÓÆÕͨÌâÄ¿ÖÐÌôÑ¡
|
if(lstItems.size() < count){
|
|
Object[] exerciseIds = new Object[lstItems.size()];
|
for(int i=0; i<lstItems.size(); i++){
|
exerciseIds[i]=lstItems.get(i).getExerciseId();
|
}
|
|
lstAddItems = getFreeExerciseForCommon(subjectId,
|
count-exerciseIds.length, groupTypes,exerciseIds);
|
|
|
// 3.×éºÏΪ×îеÄÒ»¸öÁ·Ï° item list
|
lstItems.addAll(lstAddItems);
|
}
|
|
// ´òÂÒ˳Ðò
|
Collections.shuffle(lstItems);
|
|
return lstItems;
|
}
|
|
/**
|
* Éú³ÉÁ·Ï°×é¹ØÁª¹Øϵ
|
* @param lstItems
|
* @param groupId
|
* @return
|
*/
|
private Result generateExerciseGroupItemRe(List<ExerciseItem> lstItems, String exerciseGroupId){
|
|
List<ExerciseGroupItemRe> lstRe = new ArrayList<ExerciseGroupItemRe>(lstItems.size());
|
ExerciseGroupItemRe re;
|
for(int i=0; i<lstItems.size(); i++){
|
re = new ExerciseGroupItemRe();
|
|
re.setExerciseGroupId(exerciseGroupId);
|
re.setExerciseItemId(lstItems.get(i).getExerciseId());
|
re.setDeleteFlag(false);
|
re.setItemOrder(i+1);
|
re.setDocOrder(i+1);
|
|
lstRe.add(re);
|
}
|
|
this.saveOrUpdateAll(lstRe);
|
|
return new Result(true);
|
}
|
|
/**
|
* Éú³ÉÁ·Ï°recordÊý¾Ý
|
*
|
* @param subjectId
|
* @param exerciseGroupId
|
* @return
|
*/
|
private ExerciseRecord generateExerciseRecordByFree(String subjectId, String exerciseGroupId){
|
|
ExerciseRecord record = new ExerciseRecord();
|
record.setStatus(ExerciseRecord.STATUS_NOT_SUBMIT);
|
|
this.insertExerciseRecordNew(record, exerciseGroupId, subjectId);
|
|
// ²Ù×÷×î½üÒ»´Î×öÌâ¼Ç¼
|
doOperExerciseRecentRecord(record);
|
|
return record;
|
}
|
|
/**
|
* Éú³É Á·Ï°×éÒÔ¼°À©Õ¹Êý¾Ý
|
* @param subjectId
|
* @param source
|
* @param strategy
|
* @param mode
|
* @param count
|
* @param exerciseTime
|
* @return
|
*/
|
private ExerciseGroup generateExerciseGroupByFree(String subjectId, String source,
|
String strategy, String mode, int count, String exerciseTime){
|
|
// 1.Á·Ï°×é
|
ExerciseGroup group = new ExerciseGroup();
|
|
group.setClassId(ClientUtils.getClassId());
|
group.setCollegeCourseId(ClientUtils.getCourseId());
|
group.setOrgId(ClientUtils.getOrgId());
|
group.setSubjectId(subjectId);
|
group.setAllCount(new BigInteger(String.valueOf(count)));
|
group.setType(ExerciseGroup.TYPE_EXERCISE_FREE);
|
group.setDeleteFlag(false);
|
group.setStatus(ExerciseGroup.STATUS_PUBLISHED);
|
TraceUtils.setCreateTrace(group);
|
group.setName("×ÔÓÉÁ·Ï°-"+DateTimeUtils.formatDate(group.getCreateTime(),"MMdd_HHmmss"));
|
|
this.exerciseService.saveExerciseGroup(group);
|
|
// 2.Á·Ï°×éÀ©Õ¹±í
|
ExerciseGroupExtend extend = new ExerciseGroupExtend();
|
extend.setGroupId(group.getGroupId());
|
extend.setExerciseSource(source);
|
extend.setExerciseStrategy(strategy);
|
extend.setExerciseMode(mode);
|
extend.setExerciseTime(exerciseTime);
|
extend.setDeleteFlag(false);
|
TraceUtils.setCreateTrace(extend);
|
|
this.save(extend);
|
|
return group;
|
}
|
|
/**
|
* µÃµ½ÒѾ×öÍêµÄÌâÄ¿ ¸öÈË
|
* @param subjectId
|
* @return
|
*/
|
private Object[] getExerciseIsHasDo(String subjectId){
|
StringBuffer hql = new StringBuffer(512);
|
hql.append(" select distinct u.exerciseItemId from ExerciseItemAnswerU u, ExerciseRecord r"
|
+ " where u.exerciseRecordId=r.recordId"
|
+ " and u.deleteFlag is false"
|
+ " and r.classId=? "
|
+ " and r.userId=? ");
|
|
List<Object> args = CollectionUtils.newList(ClientUtils.getClassId(), ClientUtils.getUserId());
|
|
if(StringUtils.isNotBlank(subjectId)){
|
hql.append(" and r.subjectId=?");
|
args.add(subjectId);
|
}
|
|
|
List<Object[]> lstObjs = this.findwithRawResult(hql.toString(), args);
|
|
// ×é×°Á·Ï°ids
|
Object[] exerciseIds = new Object[lstObjs.size()];
|
|
for(int i=0; i<lstObjs.size(); i++){
|
|
exerciseIds[i] = lstObjs.get(i);
|
|
}
|
|
return exerciseIds;
|
}
|
|
/**
|
* ¸ù¾ÝÌõ¼þ»ñÈ¡´íÌâÁ·Ï° δ×öÌâ
|
* @param subjectId
|
* @param count
|
* @param groupTypes
|
* @return
|
*/
|
private List<ExerciseItem> getFreeExerciseForNoDo(String subjectId, int count, Object[] groupTypes){
|
// »ñÈ¡ÒѾ×öÍêµÄÌâÄ¿
|
Object[] exerciseIds = getExerciseIsHasDo(subjectId);
|
|
StringBuffer hql = new StringBuffer(512);
|
hql.append(" from ExerciseItem i, ExerciseGroup g, ExerciseGroupItemRe re"
|
+ " where i.exerciseId = re.exerciseItemId"
|
+ " and g.groupId = re.exerciseGroupId"
|
+ " and g.type in (:groupTypes) "
|
+ " and g.classId = :classId "
|
+ " and i.deleteFlag is false"
|
+ " and re.deleteFlag is false ");
|
|
Map<String, Object> argsMap = new HashMap<String, Object>(4);
|
argsMap.put("groupTypes", groupTypes);
|
argsMap.put("classId", ClientUtils.getClassId());
|
|
|
if(exerciseIds.length > 0){
|
hql.append(" and i.exerciseId not in (:exerciseIds)");
|
argsMap.put("exerciseIds", exerciseIds);
|
}
|
|
if(StringUtils.isNotBlank(subjectId)){
|
hql.append(" and g.subjectId=:subjectId");
|
argsMap.put("subjectId", subjectId);
|
}
|
|
// 1.²éѯ·ÖÒ³Êý¾Ý
|
Pager pager = getFreeExercisePagerData("select count(distinct i.exerciseId) " + hql.toString(),
|
argsMap, count);
|
|
// 2.·ÖÒ³²éѯ½á¹ûlist
|
List<ExerciseItem> lstItems = this.findByComplexHql("select distinct i " + hql.toString(),
|
pager, argsMap, ExerciseItem.class);
|
|
return lstItems;
|
}
|
|
/**
|
* µÃµ½×ÔÓÉÁ·Ï°·ÖÒ³Êý¾Ý
|
* @param hql
|
* @param argsMap
|
* @param count
|
* @return
|
*/
|
private Pager getFreeExercisePagerData(String hql, Map<String, Object> argsMap, int pageSize){
|
|
int iAllCount = this.findCountByComplexHql(hql, argsMap);
|
|
// ×ÜÒ³Êý
|
int allPage = iAllCount / pageSize;
|
|
// Ò³Âë
|
int pageNum = 0;
|
|
if(allPage < 1){
|
pageNum = 1;
|
}else{
|
pageNum = new Random().nextInt(allPage);//Ëæ»úÈ¡Ò³Êý
|
}
|
|
// ·ÖÒ³
|
Pager page = new Pager();
|
page.setPageNum(pageNum);
|
page.setPageSize(pageSize);
|
|
return page;
|
}
|
|
/**
|
* »ñÈ¡ÌâÄ¿ ¸ù¾ÝÌâÄ¿ÀàÐÍ
|
* @param subjectId
|
* @param count
|
* @param groupTypes
|
* @return
|
*/
|
private List<ExerciseItem> getFreeExerciseForCommon(String subjectId,
|
int count, Object[] groupTypes, Object[] exerciseIds){
|
|
// »ñÈ¡ÌâÄ¿
|
Pager page = new Pager();
|
page.setPageNum(1);
|
page.setPageSize(count);
|
|
StringBuffer hql = new StringBuffer(512);
|
hql.append("select distinct i from ExerciseItem i, ExerciseGroup g, ExerciseGroupItemRe re"
|
+ " where i.exerciseId = re.exerciseItemId"
|
+ " and g.groupId = re.exerciseGroupId"
|
+ " and g.type in (:groupTypes) "
|
+ " and g.classId = :classId "
|
+ " and i.deleteFlag is false"
|
+ " and re.deleteFlag is false");
|
|
Map<String, Object> argsMap = new HashMap<String, Object>(4);
|
|
argsMap.put("groupTypes", groupTypes);
|
argsMap.put("classId", ClientUtils.getClassId());
|
|
if(exerciseIds.length > 0){
|
hql.append(" and i.exerciseId not in (:exerciseIds) ");
|
argsMap.put("exerciseIds", exerciseIds);
|
}
|
|
if(StringUtils.isNotBlank(subjectId)){
|
hql.append(" and g.subjectId=:subjectId");
|
argsMap.put("subjectId", subjectId);
|
}
|
|
|
// »ñÈ¡ÌâÄ¿
|
List<ExerciseItem> lstItem = this.findByComplexHql(hql.toString(), page, argsMap, ExerciseItem.class);
|
|
|
return lstItem;
|
}
|
|
/**
|
* ¸ù¾ÝÌõ¼þ»ñÈ¡´íÌâÁ·Ï° ´íÌâ
|
* @param subjectId
|
* @param count
|
* @param groupTypes
|
* @return
|
*/
|
private List<ExerciseItem> getFreeExerciseForFault(String subjectId, int count, Object[] groupTypes){
|
StringBuffer hql = new StringBuffer(512);
|
hql.append(" from ExerciseItem i ,ExerciseFault f "
|
+ " where i.exerciseId = f.exerciseItemId "
|
+ " and f.faultRecord.exerciseGroupType in (:groupTypes) "
|
+ " and f.faultRecord.faultBook.userId=:userId "
|
+ " and f.faultRecord.faultBook.classId=:classId "
|
+ " and f.answer is null "
|
+ " and i.deleteFlag is false "
|
+ " and f.deleteFlag is false ");
|
|
Map<String, Object> argsMap = new HashMap<String, Object>(4);
|
|
argsMap.put("groupTypes", groupTypes);
|
argsMap.put("userId", ClientUtils.getUserId());
|
argsMap.put("classId", ClientUtils.getClassId());
|
|
if(StringUtils.isNotBlank(subjectId)){
|
hql.append(" and f.faultRecord.faultBook.subjectId=:subjectId");
|
argsMap.put("subjectId", subjectId);
|
}
|
|
// 1.²éѯ·ÖÒ³Êý¾Ý
|
Pager pager = getFreeExercisePagerData("select count(distinct i.exerciseId) " + hql.toString(),
|
argsMap, count);
|
|
// 2.»ñÈ¡ÌâÄ¿list
|
List<ExerciseItem> lstItems = this.findByComplexHql("select distinct i " + hql.toString(),
|
pager, argsMap, ExerciseItem.class);
|
|
return lstItems;
|
}
|
|
/**
|
* ²éѯÌâĿͳ¼Æ·ÖÎö½á¹û ¸öÈËͳ¼Æ ȫվͳ¼Æ
|
* @param groupId
|
* @return
|
*/
|
@Override
|
public List<Map<String, Object>> queryExerciseItemStatisics(String groupId) {
|
// 1.²éѯ¸öÈËͳ¼Æ
|
String hql_analisisU = "select a from ExerciseItemAnalisiU a,ExerciseGroupItemRe re"
|
+ " where a.exerciseItemId=re.exerciseItemId and re.exerciseGroupId=? "
|
+ " and a.userId=? and a.deleteFlag is false and re.deleteFlag is false ";
|
List<ExerciseItemAnalisiU> lstAnalisiU = this.find(hql_analisisU,
|
CollectionUtils.newList(groupId, ClientUtils.getUserId()), ExerciseItemAnalisiU.class);
|
|
Map<String, ExerciseItemAnalisiU> anasisUMap = new HashMap<String, ExerciseItemAnalisiU>(lstAnalisiU.size());
|
for(ExerciseItemAnalisiU analisisU:lstAnalisiU){
|
anasisUMap.put(analisisU.getExerciseItemId(), analisisU);
|
}
|
|
// 2.²éѯȫվͳ¼Æ
|
String hql_analisis = "select a from ExerciseItemAnalisi a,ExerciseGroupItemRe re"
|
+ " where a.exerciseItemId=re.exerciseItemId and re.exerciseGroupId=? "
|
+ " and a.deleteFlag is false and re.deleteFlag is false ";
|
List<ExerciseItemAnalisi> lstAnalisi = this.find(hql_analisis,
|
CollectionUtils.newList(groupId), 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.²éѯ´Ë×éËùÓÐÌâÄ¿
|
String hql_group = "from ExerciseGroupItemRe re where re.deleteFlag is false and re.exerciseGroupId = ? order by re.itemOrder";
|
List<ExerciseGroupItemRe> lstGroup = this.find(hql_group,
|
CollectionUtils.newList(groupId), ExerciseGroupItemRe.class);
|
|
List<Map<String, Object>> lstResult = new ArrayList<Map<String, Object>>(lstGroup.size());
|
Map<String, Object> resultMap = null;
|
String exerciseItemId;
|
ExerciseItemAnalisi analisis;
|
ExerciseItemAnalisiU analisisU;
|
|
// 3.×é×°½á¹û
|
|
// Ñ»µ×éËùÓÐÌâÄ¿
|
for(ExerciseGroupItemRe group:lstGroup){
|
// ½á¹ûmap
|
resultMap = new HashMap<String, Object>(10);
|
|
exerciseItemId = group.getExerciseItemId();
|
// 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;
|
}
|
|
/**
|
* ²Ù×÷±¾´Î×öÌâ¼Ç¼
|
* @return
|
*/
|
@Override
|
public Map<String,Object> doInsertExerRecord(String groupId) {
|
ExerciseRecord record = new ExerciseRecord();
|
record.setDeleteFlag(false);
|
record.setExerciseGroupId(groupId);
|
record.setDoCount(BigInteger.ZERO);
|
record.setCorrectCount(BigInteger.ZERO);
|
record.setTitleMaxNumber("0");
|
record.setStatus("0");
|
record.setScore(BigDecimal.ZERO);
|
record.setUserId(ClientUtils.getUserId());
|
// record.setClassId(ClientUtils.getClassId());
|
record.setOrgId(ClientUtils.getOrgId());
|
TraceUtils.setCreateTrace(record);
|
this.save(record);
|
|
// ²Ù×÷×î½üÒ»´Î×öÌâ¼Ç¼
|
doOperExerciseRecentRecord(record);
|
|
Map<String,Object> resultMap = new HashMap<String, Object>(3);
|
resultMap.put("exerciseRecordId", record.getRecordId());
|
resultMap.put("updateTime", DateTimeUtils.getCurrDateTime(record.getUpdateTime()));
|
resultMap.put("exerciseGroupId", groupId);
|
resultMap.put("record", record);
|
|
return resultMap;
|
}
|
|
/**
|
* ²Ù×÷±¾´Î×öÌâ¼Ç¼
|
* @return
|
*/
|
@Deprecated
|
@Override
|
public Map<String,Object> doInsertExerRecord(String groupId,String examBatchId,String classId,int remainingSeconds) {
|
ExerciseRecord record = new ExerciseRecord();
|
record.setDeleteFlag(false);
|
record.setExerciseGroupId(groupId);
|
record.setExamBatchId(examBatchId);
|
record.setDoCount(BigInteger.ZERO);
|
record.setCorrectCount(BigInteger.ZERO);
|
record.setTitleMaxNumber("0");
|
record.setStatus("0");
|
record.setClassId(classId);
|
record.setRemainingSeconds(remainingSeconds);
|
record.setScore(BigDecimal.ZERO);
|
record.setUserId(ClientUtils.getUserId());
|
record.setOrgId(ClientUtils.getOrgId());
|
TraceUtils.setCreateTrace(record);
|
this.save(record);
|
|
// ²Ù×÷×î½üÒ»´Î×öÌâ¼Ç¼
|
doOperExerciseRecentRecord(record);
|
|
Map<String,Object> resultMap = new HashMap<String, Object>(3);
|
resultMap.put("exerciseRecordId", record.getRecordId());
|
resultMap.put("updateTime", DateTimeUtils.getCurrDateTime(record.getUpdateTime()));
|
resultMap.put("exerciseGroupId", groupId);
|
resultMap.put("record", record);
|
|
return resultMap;
|
}
|
|
|
/**
|
* ¸üÐÂÁ·Ï°×é°à¼¶ÕýÈ·ÂÊÐÅÏ¢
|
* @return
|
*/
|
@Override
|
public Result doUpdateExerGroupClsAccuracy(String groupId, String doCount, String correctCount) {
|
|
String hql_record = "update ExerciseGroupExtend set doCount=IFNULL(doCount,0)+"+doCount+", correctCount=IFNULL(correctCount,0)+"+correctCount
|
+ ", classAccuracy=round(correctCount/doCount*100,2)"
|
+ " where groupId=? and deleteFlag is false";
|
|
this.bulkUpdateInLoop(hql_record, new String[]{groupId});
|
|
return new Result(true);
|
}
|
|
/**
|
* ·¢ËͰ༶ÅÅÃûÇëÇóÏûÏ¢
|
* @return
|
*/
|
@Override
|
public Result sendUpdateClassRankMsg(String groupId) {
|
// ¸üÐÂÁ·Ï°µÃ·ÖÅÅÃû
|
rankService.reqUpdateRank(ClientUtils.getUserId(), SchRank.RANK_TYPE_EXERCISE_SCORE,
|
SchRank.SCOPE_TYPE_CLASS_GROUP, groupId);
|
|
return new Result(true);
|
}
|
|
|
/**
|
* ÇëÇóÐ޸ĸÃ×é°à¼¶ÕýÈ·ÂÊ
|
* @param record
|
* @return
|
*/
|
@Override
|
public Result sendUpdateClassAccuracyMsg(String exerciseGroupId, String doCount, String correctCount){
|
|
// Òì²½µ÷Óà ·¢ËÍÏûÏ¢
|
// ONSMsg msg = new ONSMsg(onsProducer.getTopic());
|
//
|
// msg.put("msgType", "EXER_GROUP_ACCURACY");
|
// msg.put("groupId", exerciseGroupId);
|
// msg.put("doCount", doCount);
|
// msg.put("correctCount", correctCount);
|
//
|
// try {
|
//
|
// onsProducer.sendMsg(msg);
|
//
|
// return new Result(true);
|
//
|
// } catch (Exception e) {
|
// log.error("call sendUpdateClassAccuracyMsg fail.groupId: " + exerciseGroupId , e);
|
// }
|
|
return new Result(false);
|
}
|
|
@Override
|
public Result doUpdateExerciseRecord(String exerciseRecordId,
|
String groupId, String currTitleNum) {
|
|
if(StringUtils.isBlank(exerciseRecordId)){ // ¼Ç¼IDΪ¿Õ
|
return new Result(false, "¼Ç¼idΪ¿Õ");
|
}
|
|
ExerciseRecord record = this.read(ExerciseRecord.class, exerciseRecordId);
|
|
if(record == null
|
|| !ClientUtils.getUserId().equals(record.getUserId())){
|
return new Result(false, "·Ç·¨²Ù×÷£¬²»Êǵ±Ç°Óû§¸üÐÂÌâºÅ");
|
}
|
|
if(StringUtils.isNotBlank(currTitleNum)){// µ±Ç°ÌâºÅ
|
record.setTitleMaxNumber(currTitleNum);
|
}
|
|
this.updateExerciseRecordObj(record);
|
|
return new Result(true);
|
|
/*// 2.ÖØÐÂÉú³ÉеļǼ iosµ¼ÖÂÖØ×ö Ïȹرմ˶δúÂë
|
ExerciseRecord record = new ExerciseRecord();
|
record.setAccuracy(BigDecimal.ZERO);
|
record.setCompletionRate(BigDecimal.ZERO);
|
record.setScore(BigDecimal.ZERO);
|
record.setDoCount(BigInteger.ZERO);
|
record.setCorrectCount(BigInteger.ZERO);
|
record.setStatus(ExerciseRecord.STATUS_NOT_SUBMIT);
|
record.setTitleMaxNumber(currTitleNum);
|
record.setExerciseGroupId(groupId);
|
record.setClassId(ClientUtils.getClassId());
|
record.setCollegeCourseId(ClientUtils.getCourseId());
|
record.setOrgId(ClientUtils.getOrgId());
|
record.setUserId(ClientUtils.getUserId());
|
record.setDeleteFlag(false);
|
TraceUtils.setCreateTrace(record);
|
|
this.save(record);
|
|
// 3.²Ù×÷×î½üÒ»´Î×öÌâ¼Ç¼
|
doOperExerciseRecentRecord(record);*/
|
}
|
|
@Override
|
public Result updateExerciseRecordObj(ExerciseRecord record) {
|
// TraceUtils.setUpdateTrace(record); ---²»¸üÐÂʱ¼ä
|
this.save(record);
|
return new Result(true);
|
}
|
|
/**
|
*
|
* ±£´æapp¶ËÇëÇó±£´æµÄÊý¾Ý
|
* @return
|
*/
|
@Override
|
public String doSaveExerciseDataSubmitLog(String data,
|
String exerBussinessId, short type, int status, String url) {
|
ExerciseDataSubmitLog log = new ExerciseDataSubmitLog();
|
|
log.setExerciseBussinessId(exerBussinessId);
|
log.setData(data);
|
log.setType(type);
|
log.setUpdateId(ClientUtils.getUserId());
|
log.setUpdateTime(DateUtils.getCurrTime());
|
log.setUpdator(ClientUtils.getUserName());
|
log.setStatus(status);
|
log.setUrl(url);
|
|
this.save(log);
|
|
return log.getExerciseDataLogId();
|
}
|
|
@Override
|
public Result doUpdateExerciseDataSubmitLog(String exerciseDataLogId,
|
String exerBussinessId) {
|
ExerciseDataSubmitLog log = this.read(ExerciseDataSubmitLog.class, exerciseDataLogId);
|
|
if(log == null){
|
return new Result(false);
|
}
|
|
log.setExerciseBussinessId(exerBussinessId);
|
|
this.save(log);
|
|
return new Result(false);
|
}
|
|
|
/**
|
* ²Ù×÷Á·Ï°´ð°¸Êý¾Ýͬ²½
|
*/
|
public Map<String,Object> doOperExerciseAnswerData(ExerciseSubmitAnswerData clientAnswerData) {
|
|
// 0.ÖØÐÂÕûÀí´ðÌâÊý¾Ý
|
ExerciseSubmitAnswerData answerData = this.getExerciseSubmitAnswerDataNew(clientAnswerData);
|
|
// 1.µ±Ç°Á·Ï°×é ÅÐ¶Ï ÊÇ·ñмͼ Ìá½»µÄΪͬһ¸ö×é ExerciseRecord
|
Map<String,Object> resultMap = doOperExerciseRecordNew(answerData);
|
|
// 2.Ìá½»Á·Ï°´ð°¸
|
Result result = doSubmitExerciseAnswerDataNew(answerData, String.valueOf(resultMap.get("exerciseRecordId")));
|
|
//Èç¹ûÊÇÊÇÔÄ¾í£¬·¢²¼ÏûÏ¢
|
if(answerData.getStatus().equals(String.valueOf(ExerciseRecord.STATUS_CHECK))){
|
this.doCheckMsg(answerData);
|
}
|
|
// ¸ÃÌ×Ìâ×Ü×öÌâ¸öÊý¡¢ÕýÈ·¸öÊý
|
resultMap.put("doCount", result.getData("doCount"));
|
resultMap.put("correctCount", result.getData("correctCount"));
|
|
return resultMap;
|
}
|
|
private void doCheckMsg(ExerciseSubmitAnswerData answerData){
|
String msg = null;
|
Map<String,String> attrs = null;
|
|
//´ðÌâ¼Ç¼
|
ExerciseRecord record= this.read(ExerciseRecord.class, answerData.getExerciseRecordId());
|
|
//¿¼ÊÔ
|
if(StringUtils.isNotEmpty(record.getExamBatchId())){
|
ExamBatchInfo batchInfo = this.read(ExamBatchInfo.class,record.getExamBatchId());
|
attrs = CollectionUtils.newStringMap("examBatchId",record.getExamBatchId(),"examName",batchInfo.getExamInfo().getExamName(),
|
"subjectId",batchInfo.getExamInfo().getSubjectId(),
|
"subjectName",batchInfo.getExamInfo().getSubject().getName());
|
msg = "ÀÏʦÅú¸ÄÁË¿¼ÊÔ";
|
}else{
|
ExerciseInfo exerciseInfo = this.read(ExerciseInfo.class,answerData.getExerciseInfoId());
|
attrs = CollectionUtils.newStringMap("exerciseInfoId",exerciseInfo.getExerciseInfoId(),"exerciseName",exerciseInfo.getName(),
|
"subjectId",exerciseInfo.getSubjectId(),
|
"subjectName",exerciseInfo.getSubject().getName(),"creator",exerciseInfo.getCreator(),"exerciseType",String.valueOf(exerciseInfo.getType()));
|
msg = "ÀÏʦÅú¸ÄÁË´ðÌâ×÷Òµ";
|
}
|
|
msgInfoService.doSendTextMsgToUsers(new String[]{record.getUserId()}, MsgInfo.TYPE_CHECK, msg, attrs);
|
}
|
|
/**
|
* ²Ù×÷Á·Ï°¼Ç¼
|
* @param answerData
|
* @return
|
*/
|
public Map<String,Object> doUpdateExerciseRecordStatus(ExerciseSubmitAnswerData answerData){
|
String recordId = answerData.getExerciseRecordId();
|
|
ExerciseRecord record = this.read(ExerciseRecord.class, recordId);
|
|
//Èç¹ûÊÇ×÷ÒµÐèÒª´¦Àí
|
if(record == null){// µÚÒ»´Î×öÌâ
|
record = new ExerciseRecord();
|
record.setStatus(answerData.getStatus());
|
record = this.insertExerciseRecordMutiNew(record,
|
answerData.getExerciseGroupId(), answerData.getSubjectId(), answerData.getSubmitTime());
|
|
doOperExerciseRecentRecord(record);
|
}else{
|
// ¸üÐÂ×öÌâ¼Ç¼
|
record = this.updateExerciseRecordNew(record, answerData);
|
}
|
|
Map<String,Object> resultMap = new HashMap<String, Object>(3);
|
resultMap.put("exerciseRecordId", recordId);
|
resultMap.put("updateTime", record.getUpdateTime());
|
resultMap.put("exerciseGroupId", record.getExerciseGroupId());
|
|
return resultMap;
|
}
|
|
|
/**
|
* ²Ù×÷Á·Ï°¼Ç¼
|
* @param answerData
|
* @return
|
*/
|
public Map<String,Object> doOperExerciseRecordNew(ExerciseSubmitAnswerData answerData){
|
ExerciseRecord record = null;
|
String recordId = answerData.getExerciseRecordId();
|
String exerciseGroupId = answerData.getExerciseGroupId();
|
|
if(StringUtils.isNotEmpty(recordId)){
|
record = this.read(ExerciseRecord.class, recordId);
|
}
|
|
// 2.²Ù×÷×öÌâ¼Ç¼
|
if(record != null){
|
// ¸üÐÂ×öÌâ¼Ç¼
|
record = this.updateExerciseRecordNew(record, answerData);
|
}else{
|
record = new ExerciseRecord();
|
record.setStatus(answerData.getStatus());
|
record.setTitleMaxNumber(answerData.getCurrTitleNum());
|
// ÐÂÔö×öÌâ¼Ç¼
|
record = this.insertExerciseRecordMutiNew(record, exerciseGroupId,
|
answerData.getSubjectId(),answerData.getSubmitTime());
|
recordId =record.getRecordId();
|
}
|
|
// 3.²Ù×÷×î½üÒ»´Î×öÌâ¼Ç¼
|
doOperExerciseRecentRecord(record);
|
|
// 4.·µ»Ø½á¹û
|
Map<String,Object> resultMap = new HashMap<String, Object>(4);
|
|
resultMap.put("exerciseRecordId", record.getRecordId());
|
resultMap.put("exerciseGroupId", record.getExerciseGroupId());
|
resultMap.put("updateTime", DateTimeUtils.getCurrDateTime(record.getUpdateTime()));
|
if(null != record && StringUtils.isNotBlank(recordId)){
|
resultMap.put("clientExerRecordId", recordId);
|
}else{
|
resultMap.put("clientExerRecordId", null);
|
}
|
|
resultMap.put("recordId", record.getRecordId());
|
resultMap.put("accuracy",record.getAccuracy());
|
resultMap.put("doCount", record.getDoCount());
|
resultMap.put("correctCount", record.getCorrectCount());
|
resultMap.put("totalScore", record.getTotalScore());
|
resultMap.put("passingScore", record.getPassingScore());
|
resultMap.put("objTotalScore", record.getObjTotalScore());
|
resultMap.put("subTotalScore", record.getSubTotalScore());
|
resultMap.put("objScore", record.getObjScore());
|
resultMap.put("subScore", record.getSubScore());
|
resultMap.put("objItemCount", record.getObjItemCount());
|
resultMap.put("subItemCount", record.getSubItemCount());
|
|
return resultMap;
|
}
|
|
// public static void main(String [] args){
|
// ExerciseVerService s = new ExerciseVerService();
|
// s.checkSimilarity("1981Äê", "1981");
|
// s.checkSimilarity("½ÌÓëѧϵͳ", "½ÌÓëѧµÄϵͳ");
|
// s.checkSimilarity("½ÌÓëѧµÄϵͳ", "½ÌÓëѧϵͳ");
|
// System.out.println(HanLP.extractKeyword("ÖйúÈË", 100));
|
// System.out.println(HanLP.extractKeyword("Öйú ÈË def", 100));
|
// System.out.println(HanLP.segment("ÖйúÈË"));
|
// s.checkSimilarity("ÖйúÈË", "Öйú");
|
// }
|
|
|
}
|
