package com.qxueyou.scc.exercise.action;
|
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.logging.log4j.LogManager;
|
import org.apache.logging.log4j.Logger;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Controller;
|
import org.springframework.web.bind.annotation.RequestMapping;
|
import org.springframework.web.bind.annotation.RequestMethod;
|
import org.springframework.web.bind.annotation.RequestParam;
|
import org.springframework.web.bind.annotation.ResponseBody;
|
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.qxueyou.scc.base.dao.CommonDAO;
|
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.exercise.model.ExciseExtendReqData;
|
import com.qxueyou.scc.exercise.model.ExciseExtendReqListData;
|
import com.qxueyou.scc.exercise.model.ExerGroupResponseData;
|
import com.qxueyou.scc.exercise.model.ExerItemResponseData;
|
import com.qxueyou.scc.exercise.model.ExerciseDataSubmitLog;
|
import com.qxueyou.scc.exercise.model.ExerciseExtendRecordData;
|
import com.qxueyou.scc.exercise.model.ExerciseFaultRecord;
|
import com.qxueyou.scc.exercise.model.ExerciseFavoriteRecord;
|
import com.qxueyou.scc.exercise.model.ExerciseRecord;
|
import com.qxueyou.scc.exercise.model.ExerciseSubmitAnswerData;
|
import com.qxueyou.scc.exercise.model.ExerciseSubmitAnswerDataList;
|
import com.qxueyou.scc.exercise.service.IExerciseExtendService;
|
|
/**
|
* Á·Ï°À©Õ¹¿ØÖÆ
|
* ÈçÊÕ²Ø ´íÌ⠱ʼÇ
|
* @author zhiyong
|
*
|
*/
|
@Controller
|
@RequestMapping(value = "/exercise/Extend")
|
public class ExerciseExtendController {
|
/** ÈÕÖ¾ */
|
private static final Logger log = LogManager.getLogger("ExerciseExtendController");
|
|
/** commonDAO */
|
@Autowired
|
private CommonDAO commonDAO;
|
|
/** Á·Ï°À©Õ¹service */
|
@Autowired
|
private IExerciseExtendService exerciseExtendService;
|
|
/**-----------------------------------------APP V2.0 ½Ó¿Ú start----------------------------------------------------------- */
|
|
/**
|
* APP2.0: ²éѯ´íÌâ±¾ListItem
|
* URL: /exercise/Extend/faultList
|
*
|
* ÇëÇó²ÎÊý={
|
subjectId:¿Î³Ìid£¬//¿ÉÑ¡£¬ÓÃÓÚ¸ßУ°æ
|
exerType:Á·Ï°ÀàÐÍ,//±Ø´«
|
page:µ±Ç°Ò³,//±Ø´«,´óÓÚ0
|
limit:ÿҳÏÞÖÆÌõÊý,//±Ø´«,´óÓÚ0
|
}
|
·µ»Ø²ÎÊý=[
|
{
|
"groupId":"×éid",
|
"classId":°à¼¶id,
|
"courseId":¿ÆÄ¿id,
|
"orgId":»ú¹¹id,
|
"subjectId":¿Î³Ìid,
|
"name":"×éÃû",
|
"type":×éÀàÐÍ ,
|
"updateTime":¸üÐÂʱ¼ä,
|
"answerUpdateTime":±¾Ì×Ìâ´ðÌâ¸üÐÂʱ¼ä,
|
"allCount":ÌâÄ¿×ÜÊý,
|
"exerciseTime":"¿¼ÊÔʱ¼ä",
|
"exerciseRecordId":"¼Ç¼id",
|
"doCount": ×öÌâ¸öÊý,
|
"correctCount": ÕýÈ·¸öÊý,
|
"submitNumber":ÒÑÌá½»ÈËÊý(¼ÒÍ¥×÷Òµ),
|
"currTitleNumber":µ±Ç°×öÌâÐòºÅ,
|
"status":×öÌâ״̬(0£ºÎ´Ìá½» 1£ºÒÑÌá½»),
|
"completionRate": Íê³ÉÂÊ,
|
"accuracy": ÕýÈ·ÂÊ,
|
"score": ·ÖÊý,
|
"extendAllCount":´íÌâ±¾¡¢Êղر¾×ÜÊý
|
},
|
...Ñ»·¶à¸ö
|
]
|
*
|
* @return
|
*/
|
@RequestMapping(value = "faultList", method = RequestMethod.GET)
|
public @ResponseBody List<ExerGroupResponseData> queryFaultList(
|
@RequestParam(value="exerType") int exerType,// 0 ±íʾȫ²¿´íÌâ
|
@RequestParam(value="subjectId", required = false) String subjectId,
|
@RequestParam(value="page", required = false) Integer page,
|
@RequestParam(value="limit", required = false) Integer limit) {
|
|
// µÃµ½·ÖÒ³Êý¾Ý
|
Pager pager = getPager(page, limit);
|
|
// ²éѯ½á¹û
|
List<ExerGroupResponseData> lstResult = exerciseExtendService.
|
queryExerciseFaultListData(exerType, null, pager);
|
|
if(null == lstResult){// ½á¹ûת»»³É []
|
lstResult = new ArrayList<ExerGroupResponseData>();
|
}
|
|
return lstResult;
|
}
|
|
/**
|
* APP2.0: ²éѯÊղر¾ListItem
|
* URL: /exercise/Extend/favorList
|
*
|
* @return
|
*/
|
@RequestMapping(value = "favorList", method = RequestMethod.GET)
|
public @ResponseBody List<ExerGroupResponseData> queryFavorList(
|
@RequestParam(value="exerType") int exerType,// 0È«²¿ÊÕ²Ø
|
@RequestParam(value="subjectId", required = false) String subjectId,
|
@RequestParam(value="page", required = false) Integer page,
|
@RequestParam(value="limit", required = false) Integer limit) {
|
|
// µÃµ½·ÖÒ³Êý¾Ý
|
Pager pager = getPager(page, limit);
|
|
// ²éѯ½á¹û
|
List<ExerGroupResponseData> lstResult = exerciseExtendService.
|
queryExerciseFavorListData(exerType, null, pager);
|
|
if(null == lstResult){// ½á¹ûת»»³É []
|
lstResult = new ArrayList<ExerGroupResponseData>();
|
}
|
|
return lstResult;
|
}
|
|
|
/**
|
* APP2.0: »ñÈ¡´íÌâÁ·Ï°ÌâÄ¿Êý¾Ý
|
* URL: /exercise/Exercise/faultExercise
|
* @param groupId ×éid
|
* @param exerciseRecordId Á·Ï°¼Ç¼id
|
* @return
|
*/
|
@RequestMapping(value = "faultExercise", method = RequestMethod.GET)
|
public @ResponseBody ExerItemResponseData getFaultExerciseData(
|
@RequestParam(value = "groupId") String groupId) {
|
|
// ²éѯ½á¹û
|
ExerItemResponseData resultData = exerciseExtendService.queryExerciseFaultData(groupId);
|
|
return resultData;
|
}
|
|
/**
|
* ²éѯ¶àÌ×ÌâÊÕ²ØÌâÄ¿
|
* @param groupId ¸ñʽ"111,222,333...."
|
* @return
|
*/
|
@RequestMapping(value = "faultMutiExercise", method = RequestMethod.GET)
|
public @ResponseBody List<Map<String,Object>> getFaultrMutiExerciseData(
|
@RequestParam(value = "groupId") String groupId) {
|
|
String[] groupIds = groupId.split(",");
|
|
if(groupIds.length<1){
|
return null;
|
}
|
|
List<Map<String,Object>> resultDataLst = new ArrayList<Map<String,Object>>(groupIds.length);
|
|
|
for(String exerGroupId:groupIds){
|
try{
|
// ²éѯ½á¹û
|
resultDataLst.add(exerciseExtendService.queryExerciseMutiFaultData(exerGroupId));
|
|
}catch(Exception e){
|
|
log.error("²éѯ¶àÌ×ÌâfaultMutiExercise½á¹ûʧ°Ü£¬groupId="+exerGroupId,e);
|
}
|
}
|
|
return resultDataLst;
|
}
|
|
/**
|
*
|
* @param page
|
* @param limit
|
* @return
|
*/
|
private Pager getPager(Integer page, Integer limit){
|
|
Integer pageNum = page;
|
Integer pageSize = limit;
|
|
Pager pager = new Pager();
|
|
if(pageNum == null){
|
pageNum = 1;
|
pageSize=Integer.MAX_VALUE;
|
}
|
|
pager.setPageNum(pageNum);
|
pager.setPageSize(pageSize);
|
|
return pager;
|
}
|
|
/**
|
* APP2.0: »ñÈ¡È«²¿´íÌâÁ·Ï°ÌâÄ¿Êý¾Ý
|
* URL: /exercise/Extend/allFaultExercise
|
* @return
|
*/
|
@RequestMapping(value = "allFaultExercise", method = RequestMethod.GET)
|
public @ResponseBody ExerItemResponseData getAllFaultExerciseData(
|
@RequestParam(value="limit", required = false) Integer limit,
|
@RequestParam(value="page", required = false) Integer page) {
|
|
// µÃµ½·ÖÒ³Êý¾Ý
|
Pager pager = getPager(page, limit);
|
|
// ²éѯ½á¹û
|
ExerItemResponseData resultData = exerciseExtendService.queryAllExerciseFaultData(pager);
|
|
return resultData;
|
}
|
|
/**
|
* APP2.0: »ñÈ¡ÊÕ²ØÁ·Ï°ÌâÄ¿Êý¾Ý
|
* URL: /exercise/Exercise/favorExercise
|
*
|
·µ»ØÊý¾Ý={
|
"items":[// ÌâÄ¿¼¯ºÏ
|
{
|
"exerciseId":Á·Ï°id,
|
"chapterId":null,
|
"lessonId":null,
|
"title":±êÌâ,
|
"type":ÌâÄ¿ÀàÐÍ,
|
"answer":ÕýÈ·´ð°¸,
|
"options":[
|
{
|
"optionId":Ñ¡Ïîid,
|
"checked":true,
|
"content":ÄÚÈÝ,
|
"optionOrder":ÌâÄ¿ÐòºÅ,
|
"exerciseItemId":"Á·Ï°id",
|
"imgs":[
|
{
|
"imgId":"ͼƬid",
|
"exerciseObjectId":null,
|
"imgPath":ͼƬ·¾¶,
|
"imgOrder":ÅÅÐò,
|
"objectType":ͼƬÀàÐÍ 1£ºÌâÄ¿ 2£ºÑ¡Ïî
|
},
|
... Ñ»·¶à¸ö
|
]
|
},
|
... Ñ»·¶à¸ö
|
],
|
"scores":null,
|
"itemNo":null,
|
"analisisResult":{
|
"allAccuracy":ȫվͳ¼Æ ÕýÈ·ÂÊ,
|
"analysis":"½âÎö",
|
"submitAllNumber":È«Õ¾ Ìá½»×ÜÊý,
|
"usualFaultAnswers":Ò×´íÌâ,
|
"exerciseAnalisisUId":null,
|
"accuracy":¸öÈËͳ¼Æ ÕýÈ·ÂÊ,
|
"submitNumber":¸öÈËͳ¼Æ Ìá½»×ÜÊý,
|
"submitErrorNumber":¸öÈËͳ¼Æ Ìá½»´íÎó×ÜÊý,
|
},
|
"imgs":[
|
{
|
"imgId":"ͼƬid",
|
"exerciseObjectId":null,
|
"imgPath":ͼƬ·¾¶,
|
"imgOrder":ÅÅÐò,
|
"objectType":ͼƬÀàÐÍ 1£ºÌâÄ¿ 2£ºÑ¡Ïî
|
},
|
... Ñ»·¶à¸ö
|
],
|
"commentFlag": null,
|
}
|
],
|
"answers":[// ¸öÈ˴𰸼¯ºÏ
|
{
|
"answerUId":"Ö÷¼üid",
|
"answer":Ñ¡Ôñ´ð°¸ È磺¶àѡΪ(A,B,C),
|
"correct":0,
|
"exerciseItemId":Á·Ï°id,
|
"exerciseRecordId":¼Ç¼id,
|
"userId":Óû§id
|
},
|
... Ñ»·¶à¸ö
|
]
|
}
|
*
|
* @param groupId ×éid
|
* @param exerciseRecordId Á·Ï°¼Ç¼id
|
* @return
|
*/
|
@RequestMapping(value = "favorExercise", method = RequestMethod.GET)
|
public @ResponseBody ExerItemResponseData getFavorExerciseData(
|
@RequestParam(value = "groupId") String groupId) {
|
|
// ²éѯ½á¹û
|
ExerItemResponseData resultData = exerciseExtendService.queryExerciseFavorData(groupId);
|
|
return resultData;
|
}
|
|
/**
|
* ²éѯ¶àÌ×ÌâÊÕ²ØÌâÄ¿
|
* @param groupId ¸ñʽ"111,222,333...."
|
* @return
|
*/
|
@RequestMapping(value = "favorMutiExercise", method = RequestMethod.GET)
|
public @ResponseBody List<Map<String,Object>> getFavorMutiExerciseData(
|
@RequestParam(value = "groupId") String groupId) {
|
|
String[] groupIds = groupId.split(",");
|
|
if(groupIds.length<1){
|
return null;
|
}
|
|
List<Map<String,Object>> resultDataLst = new ArrayList<Map<String,Object>>(groupIds.length);
|
|
|
for(String exerGroupId:groupIds){
|
try{
|
// ²éѯ½á¹û
|
resultDataLst.add(exerciseExtendService.queryExerciseMutiFavorData(exerGroupId));
|
|
}catch(Exception e){
|
|
log.error("²éѯ¶àÌ×ÌâfavorMutiExercise½á¹ûʧ°Ü£¬groupId="+exerGroupId,e);
|
}
|
}
|
|
return resultDataLst;
|
}
|
|
|
|
/**
|
* APP2.0: »ñÈ¡È«²¿ÊÕ²ØÁ·Ï°ÌâÄ¿Êý¾Ý
|
* URL: /exercise/Exercise/allFavorExercise
|
* @return
|
*/
|
@RequestMapping(value = "allFavorExercise", method = RequestMethod.GET)
|
public @ResponseBody ExerItemResponseData getAllFavorExerciseData(
|
@RequestParam(value="limit", required = false) Integer limit,
|
@RequestParam(value="page", required = false) Integer page) {
|
|
// µÃµ½·ÖÒ³Êý¾Ý
|
Pager pager = getPager(page, limit);
|
|
// ²éѯ½á¹û
|
ExerItemResponseData resultData = exerciseExtendService.queryAllExerciseFavorData(pager);
|
|
return resultData;
|
}
|
|
/**
|
* APP2.0: Ìá½»´íÌâ±¾µÄ¼Ç¼µ½DB
|
* URL: /exercise/Extend/submitFaultData
|
*
|
* ·µ»ØÊý¾Ý={
|
"exerciseGroupType": Á·Ï°ÀàÐÍ,
|
"exerciseGroupId": Á·Ï°×éid,
|
"items":[
|
{
|
"exerciseId": Á·Ï°id,
|
"flag": ״̬, // (true:Ìí¼Ó false:ÒƳý)
|
|
},
|
.....
|
]
|
}
|
|
* @param records
|
* @return
|
*/
|
@RequestMapping(value = "submitFaultData", method = RequestMethod.POST)
|
public @ResponseBody Result doSubmitExerFaultRecord(
|
@RequestParam(value = "records") String records,
|
@RequestParam(value="subjectId", required = false) String subjectId) {
|
|
Result result = new Result(false);
|
|
try {
|
ObjectMapper mapper = new ObjectMapper();
|
// ×°»»jsonµ½¶ÔÏó
|
ExciseExtendReqData recordResult = mapper.readValue(records, ExciseExtendReqData.class);
|
List<ExerciseExtendRecordData> lstRecords = recordResult.getItems();
|
|
if(lstRecords.isEmpty()){
|
return result;
|
}
|
|
// Ìá½»½á¹û
|
Map<String,Object> resultMap = exerciseExtendService.doOperExerciseFaultRecordData(null, recordResult);
|
result.setResult(true);
|
result.setData(resultMap);
|
|
} catch (Exception e) {
|
result = new Result(false);
|
log.error(e);
|
}
|
|
return result;
|
}
|
|
|
/**
|
* APP2.0: Ìá½»´íÌâ±¾µÄ¼Ç¼µ½DB
|
* URL: /exercise/Extend/submitFaultData
|
*
|
* ·µ»ØÊý¾Ý={
|
"exerciseGroupType": Á·Ï°ÀàÐÍ,
|
"exerciseGroupId": Á·Ï°×éid,
|
"items":[
|
{
|
"exerciseId": Á·Ï°id,
|
"flag": ״̬, // (true:Ìí¼Ó false:ÒƳý)
|
|
},
|
.....
|
]
|
}
|
|
* @param records
|
* @return
|
*/
|
@RequestMapping(value = "submitFaultMutiData", method = RequestMethod.POST)
|
public @ResponseBody Object doSubmitExerFaultMutiRecord(
|
@RequestParam(value = "records") String records) {
|
|
Map<String,Object> resultMap = new HashMap<String,Object>(2);
|
Map<String,Object> returnMap = null;
|
resultMap.put("success", false);
|
resultMap.put("attrs", null);
|
List<Map<String,Object>> resultList = null;
|
try {
|
ObjectMapper mapper = new ObjectMapper();
|
|
// ×°»»jsonµ½¶ÔÏó
|
ExciseExtendReqListData recordData = mapper.readValue(records, ExciseExtendReqListData.class);
|
|
//String subjectId = recordData.getSubjectId();
|
List<ExciseExtendReqData> recordResults = recordData.getDatas();
|
|
resultList = new ArrayList<Map<String,Object>>(recordResults.size());
|
// Ñ»·¼Ç¼
|
List<ExerciseExtendRecordData> lstRecords = null;
|
for(ExciseExtendReqData recordResult:recordResults){
|
|
lstRecords = recordResult.getItems();
|
|
if(lstRecords.isEmpty()){
|
continue;
|
}
|
|
// Ìá½»½á¹û
|
returnMap = exerciseExtendService.doOperExerciseFaultRecordData(null, recordResult);
|
|
resultList.add(returnMap);
|
}
|
|
resultMap.put("success", true);
|
resultMap.put("attrs", resultList);
|
resultMap.put("msg", "Ìá½»³É¹¦");
|
} catch (Exception e) {
|
resultMap.put("msg", "Ìύʧ°Ü");
|
log.error(e);
|
}
|
|
return resultMap;
|
}
|
|
/**
|
* APP2.0: Ìá½»Êղر¾µÄ¼Ç¼µ½DB
|
* URL: /exercise/Extend/submitFavorData
|
*
|
* @param records json×Ö·û´®
|
* @return
|
*/
|
@RequestMapping(value = "submitFavorData", method = RequestMethod.POST)
|
public @ResponseBody Result doSubmitExerFavorRecord(
|
@RequestParam(value = "records") String records,
|
@RequestParam(value="subjectId", required = false) String subjectId) {
|
|
Result result = new Result(false);
|
try {
|
ObjectMapper mapper = new ObjectMapper();
|
// ×°»»jsonµ½¶ÔÏó
|
ExciseExtendReqData recordResult = mapper.readValue(records, ExciseExtendReqData.class);
|
List<ExerciseExtendRecordData> lstRecords = recordResult.getItems();
|
|
if(lstRecords.isEmpty()){
|
return result;
|
}
|
|
// Ìá½»½á¹û
|
Map<String,Object> resultMap = exerciseExtendService.doOperExerciseFavorRecordData(null, recordResult);
|
result.setResult(true);
|
result.setData(resultMap);
|
|
} catch (Exception e) {
|
result = new Result(false);
|
log.error(e);
|
}
|
|
return result;
|
}
|
|
|
/**
|
* APP2.0: Ìá½»Êղر¾µÄ¼Ç¼µ½DB
|
* URL: /exercise/Extend/submitFavorData
|
*
|
* @param records json×Ö·û´®
|
* @return
|
*/
|
@RequestMapping(value = "submitFavorMutiData", method = RequestMethod.POST)
|
public @ResponseBody Object doSubmitExerFavorMutiRecord(
|
@RequestParam(value = "records") String records) {
|
|
Map<String,Object> resultMap = new HashMap<String,Object>(2);
|
Map<String,Object> returnMap = null;
|
resultMap.put("success", false);
|
resultMap.put("attrs", null);
|
List<Map<String,Object>> resultList = null;
|
try {
|
|
ObjectMapper mapper = new ObjectMapper();
|
|
// ×°»»jsonµ½¶ÔÏó
|
ExciseExtendReqListData recordData = mapper.readValue(records, ExciseExtendReqListData.class);
|
|
//String subjectId = recordData.getSubjectId();
|
List<ExciseExtendReqData> recordResults = recordData.getDatas();
|
resultList = new ArrayList<Map<String,Object>>(recordResults.size());
|
|
// Ñ»·¼Ç¼
|
List<ExerciseExtendRecordData> lstRecords = null;
|
for(ExciseExtendReqData recordResult:recordResults){
|
|
lstRecords = recordResult.getItems();
|
|
if(lstRecords.isEmpty()){
|
continue;
|
}
|
|
// Ìá½»½á¹û
|
returnMap = exerciseExtendService.doOperExerciseFavorRecordData(null, recordResult);
|
|
resultList.add(returnMap);
|
}
|
resultMap.put("success", true);
|
resultMap.put("attrs", resultList);
|
resultMap.put("msg", "Ìá½»³É¹¦");
|
|
} catch (Exception e) {
|
log.error(e);
|
}
|
|
return resultMap;
|
}
|
|
/**
|
* »ñµÃ¶àÌ×Ìâ´ð°¸
|
* @param groupId ¸ñʽ"111,222,333...."
|
* @return
|
*/
|
@RequestMapping(value = "getExtendAnswers", method = RequestMethod.GET)
|
public @ResponseBody List<ExerItemResponseData> getExtendAnswersData(
|
@RequestParam(value = "groupId") String groupId,
|
@RequestParam(value = "exerciseType") String exerciseType) {
|
|
String[] groupIds = groupId.split(",");
|
|
if(groupIds.length<1){
|
return null;
|
}
|
|
List<ExerItemResponseData> resultDataLst = new ArrayList<ExerItemResponseData>(groupIds.length);
|
|
|
for(String exerGroupId:groupIds){
|
try{
|
|
if(Constants.EXERCISE_TYPE_FAULT.equals(exerciseType)){// ´íÌâ±¾
|
|
// ²éѯ½á¹û
|
resultDataLst.add(exerciseExtendService.queryExerciseFaultAnswerData(exerGroupId));
|
|
}else if(Constants.EXERCISE_TYPE_FAVORT.equals(exerciseType)){// ÊÕ²Ø
|
// ²éѯ½á¹û
|
resultDataLst.add(exerciseExtendService.queryExerciseFavorAnswerData(exerGroupId));
|
}else{
|
return null;
|
}
|
|
}catch(Exception e){
|
|
log.error("»ñµÃ¶àÌ×Ìâ´ð°¸getExtendAnswers½á¹ûʧ°Ü£¬groupId="+exerGroupId,e);
|
}
|
}
|
|
return resultDataLst;
|
}
|
|
|
/**
|
* APP2.0: Ìá½»Á·Ï°´ð°¸
|
* URL: /exercise/Extend/exerExtendAnswers
|
*
|
* ÇëÇóÊý¾Ý= answers={
|
"exerciseGroupId": ×éid,
|
"exerciseRecordId": ¼Ç¼id,
|
"exerciseExtendId": null,
|
"currTitleNum": "µ±Ç°ÌâºÅ",
|
"status": ״̬,
|
"type": Á·Ï°ÀàÐÍ,// ÕûÐÍ
|
"doCount": Á·Ï°ÀàÐÍ,
|
"correctCount": ÕýÈ·¸öÊý,
|
"allCount":ÌâÄ¿×ÜÊý,
|
"items": [
|
{
|
"exerciseId": "Á·Ï°id",
|
"type": Á·Ï°ÀàÐÍ,// ÕûÊýÐÍ
|
"answer": "Ñ¡Ôñ´ð°¸",
|
"correct": ÊÇ·ñÕýÈ·(0:´íÎó 1£ºÕýÈ· 2:δ֪)
|
},
|
{
|
"exerciseId": "Á·Ï°id",
|
"type": Á·Ï°ÀàÐÍ,
|
"answer": "Ñ¡Ôñ´ð°¸",
|
"correct": ÊÇ·ñÕýÈ·(0:´íÎó 1£ºÕýÈ· 2:δ֪)
|
}
|
]
|
}
|
|
·µ»ØÊý¾Ý= {"success":true,//true:³É¹¦ false:ʧ°Ü
|
"attrs":{"exerciseRecordId":Á·Ï°¼Ç¼id,
|
"updateTime":ÐÞ¸Äʱ¼ä
|
},
|
"msg":"Ìá½»³É¹¦",//½á¹ûÐÅÏ¢
|
}
|
*
|
* @param answers
|
* @return
|
*/
|
@RequestMapping(value = "exerExtendAnswers", method = RequestMethod.POST)
|
public @ResponseBody Result doSubmitExerExtendAnswer(
|
@RequestParam(value = "answers") String answers) {
|
// Óû§±¾´Î×öÌâÌá½»µÄÊý¾Ý
|
Result result = new Result(false);
|
String initExerciseRecordId = "";
|
try {
|
ObjectMapper mapper = new ObjectMapper();
|
// ×°»»jsonµ½¶ÔÏó
|
ExerciseSubmitAnswerData answerResult = mapper.readValue(answers, ExerciseSubmitAnswerData.class);
|
|
// 1.---------¼Ç¼Ìá½»µÄÊý¾ÝÈÕÖ¾
|
// ¼Ç¼id
|
initExerciseRecordId = answerResult.getExerciseRecordId();
|
|
if(answerResult.getItems().isEmpty()
|
&& !ExerciseRecord.STATUS_SUBMIT.equals(answerResult.getStatus())
|
&& answerResult.getSubmitType() != 1){// Ìύ״̬
|
|
exerciseExtendService.doSaveExerciseDataSubmitLog(answers,
|
initExerciseRecordId, ExerciseDataSubmitLog.TYPE_SUBMIT_EXTEND_ANSWER,
|
ExerciseDataSubmitLog.STATUS_FAILED,"/exercise/Extend/exerExtendAnswers");
|
|
return result;
|
}
|
|
// 2.Ìá½»´ð°¸
|
result = exerciseExtendService.doSubmitExerciseAnswerData(answerResult);
|
|
int status = 0;
|
if(result.isSuccess()){
|
status = ExerciseDataSubmitLog.STATUS_SUCCESS;
|
}else{
|
status = ExerciseDataSubmitLog.STATUS_FAILED;
|
}
|
|
// ¼Ç¼Ìá½»µÄÊý¾ÝÈÕÖ¾
|
String exerciseDataLogId = exerciseExtendService.doSaveExerciseDataSubmitLog(answers,
|
initExerciseRecordId, ExerciseDataSubmitLog.TYPE_SUBMIT_EXTEND_ANSWER,
|
status,"/exercise/Extend/exerExtendAnswers");
|
|
if(StringUtils.isBlank(initExerciseRecordId)
|
&& result.getData("exerciseRecordId") != null){// Ϊ¿Õ ˵Ã÷µÚÒ»´ÎÌá½» ¸üÐÂÈÕÖ¾¼Ç¼id
|
exerciseExtendService.doUpdateExerciseDataSubmitLog(exerciseDataLogId,
|
String.valueOf(result.getData("exerciseRecordId")));
|
|
}
|
|
} catch (Exception e) {
|
result = new Result(false);
|
log.error(e);
|
|
// ¼Ç¼Ìá½»µÄÊý¾ÝÈÕÖ¾
|
exerciseExtendService.doSaveExerciseDataSubmitLog(answers,
|
initExerciseRecordId, ExerciseDataSubmitLog.TYPE_SUBMIT_EXTEND_ANSWER,
|
ExerciseDataSubmitLog.STATUS_FAILED,"/exercise/Extend/exerExtendAnswers");
|
}
|
|
return result;
|
}
|
|
|
/**
|
* APP2.0: Ìá½»Á·Ï°´ð°¸
|
* URL: /exercise/Extend/exerExtendMutiAnswers
|
*
|
* ÇëÇóÊý¾Ý= answers=[{
|
"exerciseGroupId": ×éid,
|
"exerciseRecordId": ¼Ç¼id,
|
"exerciseExtendId": null,
|
"currTitleNum": "µ±Ç°ÌâºÅ",
|
"status": ״̬,
|
"type": Á·Ï°ÀàÐÍ,// ÕûÐÍ
|
"doCount": Á·Ï°ÀàÐÍ,
|
"correctCount": ÕýÈ·¸öÊý,
|
"allCount":ÌâÄ¿×ÜÊý,
|
"items": [
|
{
|
"exerciseId": "Á·Ï°id",
|
"type": Á·Ï°ÀàÐÍ,// ÕûÊýÐÍ
|
"answer": "Ñ¡Ôñ´ð°¸",
|
"correct": ÊÇ·ñÕýÈ·(0:´íÎó 1£ºÕýÈ· 2:δ֪)
|
},
|
{
|
"exerciseId": "Á·Ï°id",
|
"type": Á·Ï°ÀàÐÍ,
|
"answer": "Ñ¡Ôñ´ð°¸",
|
"correct": ÊÇ·ñÕýÈ·(0:´íÎó 1£ºÕýÈ· 2:δ֪)
|
}
|
]
|
}]
|
|
·µ»ØÊý¾Ý= {"success":true,//true:³É¹¦ false:ʧ°Ü
|
"attrs":{"exerciseRecordId":Á·Ï°¼Ç¼id,
|
"updateTime":ÐÞ¸Äʱ¼ä
|
},
|
"msg":"Ìá½»³É¹¦",//½á¹ûÐÅÏ¢
|
}
|
*
|
* @param answers
|
* @return
|
*/
|
@RequestMapping(value = "exerExtendMutiAnswers", method = RequestMethod.POST)
|
public @ResponseBody Object doSubmitExerExtendMutiAnswer(
|
@RequestParam(value = "answers") String answers) {
|
// Óû§±¾´Î×öÌâÌá½»µÄÊý¾Ý
|
Map<String,Object> resultMap = new HashMap<String,Object>(2);
|
resultMap.put("success", false);
|
resultMap.put("attrs", null);
|
try {
|
ObjectMapper mapper = new ObjectMapper();
|
// ×°»»jsonµ½¶ÔÏó
|
ExerciseSubmitAnswerDataList answerDataList = mapper.readValue(answers, ExerciseSubmitAnswerDataList.class);
|
|
// Ìá½»´ð°¸
|
resultMap = exerciseExtendService.doSubmitMutiExerciseAnswerData(answerDataList);
|
|
} catch (Exception e) {
|
log.error(e);
|
resultMap.put("msg", "Ìá½»Á·Ï°´ð°¸ÇëÇóÒì³£");
|
|
exerciseExtendService.doSaveExerciseDataSubmitLog(answers,
|
"exerExtendMutiAnswers", ExerciseDataSubmitLog.TYPE_SUBMIT_EXTEND_ANSWER,
|
ExerciseDataSubmitLog.STATUS_FAILED, "/exercise/Extend/exerExtendMutiAnswers");
|
}
|
|
return resultMap;
|
}
|
|
/**
|
* APP2.0: app¶ËÖØпªÊ¼×öÌâ ¸üÐÂ״̬
|
* URL: /exercise/Extend/updateNewExerRecordNew
|
*
|
* @param groupId Ï°Ìâ×éID Èç¹ûΪAllʱ£¬±íʾȫ²¿´íÌâ
|
* @return
|
*/
|
@RequestMapping(value = "updateNewExerRecordNew", method = RequestMethod.GET)
|
public @ResponseBody Result doUpdateExerItemNumber(
|
@RequestParam(value = "groupId") String groupId,// Ï°Ìâ×éID Èç¹ûΪAllʱ£¬±íʾȫ²¿´íÌ⡢ȫ²¿ÊÕ²Ø
|
@RequestParam(value = "exerciseType") String exerciseType) {
|
|
Map<String,Object> map = null;
|
Result result = new Result(true, "״̬¸üгɹ¦");
|
if(Constants.EXERCISE_TYPE_FAULT.equals(exerciseType)){// ´íÌâ±¾
|
|
map = exerciseExtendService.doUpdateFaultExerRecordNew(groupId);
|
|
}else if(Constants.EXERCISE_TYPE_FAVORT.equals(exerciseType)){// ÊÕ²Ø
|
|
map = exerciseExtendService.doUpdateFavortExerRecordNew(groupId);
|
}else{
|
|
result = new Result(false, "exerciseType´«Öµ´íÎó£ºexerciseType="+exerciseType);
|
}
|
|
result.setData(map);
|
|
return result;
|
}
|
|
/**
|
* APP2.0: ¸üÐÂÁ·Ï°×÷ÒµÌâºÅ app¶ËÖØпªÊ¼×öÌâ
|
* URL: /exercise/Extend/updateExerciseRecord
|
*
|
* @param groupId Ï°Ìâ×éID
|
* @return
|
*/
|
@RequestMapping(value = "updateExerciseRecord", method = RequestMethod.GET)
|
public @ResponseBody Result doUpdateExerciseRecord(
|
@RequestParam(value = "groupId") String groupId,// all ±íʾȫ²¿´íÎó»òÊÕ²Ø
|
@RequestParam(value = "exerciseType") String exerciseType,
|
@RequestParam(value = "exerciseRecordId") String exerciseRecordId,
|
@RequestParam(value = "currTitleNum", required = false) String currTitleNum) {
|
|
|
Result result = new Result(true, "״̬¸üгɹ¦");
|
|
if(StringUtils.isBlank(exerciseRecordId) && !"All".equals(groupId)){
|
return new Result(false, "¸üÐÂʧ°Ü£¬exerciseRecordIdΪ¿Õ");
|
}
|
|
if(Constants.EXERCISE_TYPE_FAULT.equals(exerciseType)){// ´íÌâ±¾
|
|
if("All".equals(groupId)){// È«²¿´íÌâ
|
return exerciseExtendService.doUpdateExerciseFaultBook(currTitleNum);
|
}
|
|
ExerciseFaultRecord record = commonDAO.read(ExerciseFaultRecord.class, exerciseRecordId);
|
record.setTitleMaxNumber(currTitleNum);
|
|
result = exerciseExtendService.doUpdateExerciseFaultRecord(record);
|
|
}else if(Constants.EXERCISE_TYPE_FAVORT.equals(exerciseType)){// ÊÕ²Ø
|
|
if("All".equals(groupId)){// È«²¿ÊÕ²Ø
|
return exerciseExtendService.doUpdateExerciseFavorBook(currTitleNum);
|
}
|
|
ExerciseFavoriteRecord record = commonDAO.read(ExerciseFavoriteRecord.class, exerciseRecordId);
|
record.setTitleMaxNumber(currTitleNum);
|
|
result = exerciseExtendService.doUpdateExerciseFavorRecord(record);
|
}else{
|
|
result = new Result(false, "exerciseType´«Öµ´íÎó£ºexerciseType="+exerciseType);
|
}
|
|
return result;
|
}
|
|
/**
|
* APP2.0: ²éѯ´íÌâ ÊղرʼǸöÊý
|
* URL: /exercise/Extend/queryExerCount
|
* @return ¼üÖµ¶Ô£ºiFavor ÊղظöÊý iFault ´íÎó¸öÊý
|
*/
|
@RequestMapping(value = "exerBookInfo", method = RequestMethod.GET)
|
public @ResponseBody Result queryExtendListCount(
|
@RequestParam(value = "exerciseType") String exerciseType) {
|
|
Map<String, Object> map = null;
|
Result result = new Result(false);
|
if(Constants.EXERCISE_TYPE_FAULT.equals(exerciseType)){// ´íÌâ±¾
|
|
map = exerciseExtendService.queryExerFaultInfo();
|
|
}else if(Constants.EXERCISE_TYPE_FAVORT.equals(exerciseType)){// ÊÕ²Ø
|
|
map = exerciseExtendService.queryExerFavorInfo();
|
}else{
|
|
result = new Result(false, "exerciseType´«Öµ´íÎó£ºexerciseType="+exerciseType);
|
}
|
|
result = new Result(true, "²éѯ³É¹¦");
|
result.setData(map);
|
|
return result;
|
}
|
|
/**
|
* APP2.0: ÌâÄ¿´ð°¸·ÖÎö
|
* URL: /exercise/Extend/itemstatisics
|
*
|
*
|
*
|
* @param groupId Ï°Ìâ×éID
|
* @return
|
*/
|
@RequestMapping(value = "itemStatisics", method = RequestMethod.GET)
|
public @ResponseBody List<Map<String, Object>> doQueryExerciseItemStatisics(
|
@RequestParam(value = "exerciseType") String exerciseType) {
|
|
// ²éѯ½á¹û
|
List<Map<String, Object>> resultLst = exerciseExtendService.queryExerciseItemStatisics(exerciseType);
|
|
return resultLst;
|
}
|
|
/**
|
* ´íÌâͳ¼Æ½Ó¿Ú
|
* URL: /exercise/Extend/faultStatis
|
*
|
* @return
|
*/
|
@RequestMapping(value = "faultStatis", method = RequestMethod.GET)
|
public @ResponseBody Result doCalcFaultStatisInfo() {
|
|
return exerciseExtendService.doCalcExerFaultStatisticsByDay();
|
}
|
|
/**
|
*µÃµ½ ´íÌâͳ¼ÆÐÅÏ¢
|
* URL: /exercise/Extend/faultStatis
|
*
|
* type :week ×î½üÒ»ÖÜ month:×î½üÒ»Ô year£º×î½üÒ»Äê
|
* @return
|
*/
|
@RequestMapping(value = "getfaultStatis", method = RequestMethod.GET)
|
public @ResponseBody List<Map<String,Object>> doGetFaultStatisInfo(
|
@RequestParam(value = "type") String type ) {
|
|
return exerciseExtendService.doGetFaultStatisInfo(type);
|
}
|
|
/**-----------------------------------------APP V2.0 ½Ó¿Ú end----------------------------------------------------------- */
|
|
@RequestMapping(value = "initFaultStatisData", method = RequestMethod.GET)
|
public @ResponseBody Result doInitExerRecentRecord() {
|
|
return exerciseExtendService.doInitFaultStatisData();
|
}
|
|
|
/*@RequestMapping(value = "initExerRecentRecord", method = RequestMethod.GET)
|
public @ResponseBody Result doInitExerRecentRecord() {
|
|
return exerciseExtendService.doInitExerRecentRecord();
|
}
|
|
@RequestMapping(value = "initFaultRecord", method = RequestMethod.GET)
|
public @ResponseBody Result doInitExerOldGroup() {
|
|
return exerciseExtendService.doInitFaultRecord();
|
}
|
|
@RequestMapping(value = "initFaultItem", method = RequestMethod.GET)
|
public @ResponseBody Result doInitFaultItem() {
|
|
// 2.
|
String sql2="select f,re.exerciseGroupId"
|
+" from ExerciseFault f,ExerciseGroupItemRe re"
|
+" where f.exerciseItemId=re.exerciseItemId"
|
+" and (f.faultRecordId is null or f.faultRecordId='') order by f.exerciseFaultId";
|
|
List<Object[]> lstData2 =commonDAO.findwithRawResult(sql2, new ArrayList<Object>());
|
|
if(lstData2.isEmpty()){//Å×Òì³£»Ø¹ö
|
return new Result(false,"´íÌâÊý¾ÝΪ¿Õ2222");
|
}
|
|
String hql_existRecord = "from ExerciseFaultRecord where resumeBookId=? and exerciseGroupId=? ";
|
ExerciseFault fault=null;
|
ExerciseFault newFault=null;
|
String exerciseFaultId="";
|
List<ExerciseFaultRecord> lstRecord = null;
|
int i=0;
|
for(Object[] objs:lstData2){
|
fault = (ExerciseFault)objs[0];
|
if(fault.getExerciseFaultId().equals(exerciseFaultId)){
|
newFault = new ExerciseFault();
|
BeanUtils.copyProperties(fault, newFault);
|
newFault.setExerciseFaultId(null);
|
|
lstRecord = commonDAO.find(hql_existRecord, CollectionUtils.newList(newFault.getResumeBookId(),String.valueOf(objs[1])), ExerciseFaultRecord.class);
|
if(lstRecord.isEmpty()){
|
continue;
|
}
|
|
newFault.setFaultRecordId(lstRecord.get(0).getFaultRecordId());
|
TraceUtils.setUpdateTrace(newFault);
|
exerciseExtendService.doSavetoDB(newFault);
|
}else{
|
lstRecord = commonDAO.find(hql_existRecord, CollectionUtils.newList(fault.getResumeBookId(),String.valueOf(objs[1])), ExerciseFaultRecord.class);
|
if(lstRecord.isEmpty()){
|
continue;
|
}
|
|
fault.setFaultRecordId(lstRecord.get(0).getFaultRecordId());
|
TraceUtils.setUpdateTrace(fault);
|
exerciseExtendService.doSavetoDB(fault);
|
}
|
|
exerciseFaultId=fault.getExerciseFaultId();
|
i++;
|
}
|
|
return new Result(true, "¸üÐÂExerciseFaultÌõÊý£º"+i);
|
}
|
|
|
|
@RequestMapping(value = "initFavorRecord", method = RequestMethod.GET)
|
public @ResponseBody Result doInitFavorRecord() {
|
|
return exerciseExtendService.doInitFavorRecord();
|
}
|
|
|
@RequestMapping(value = "initFavorItem", method = RequestMethod.GET)
|
public @ResponseBody Result doInitFavorItem() {
|
|
String sql2="select f,re.exerciseGroupId"
|
+" from ExerciseFavorite f,ExerciseGroupItemRe re"
|
+" where f.exerciseItemId=re.exerciseItemId"
|
+" and (f.favoriteRecordId is null or f.favoriteRecordId = '') order by f.exerciseFavoriteId";
|
|
List<Object[]> lstData2 =commonDAO.findwithRawResult(sql2, new ArrayList<Object>());
|
|
if(lstData2.isEmpty()){//Å×Òì³£»Ø¹ö
|
return new Result(false,"ÊÕ²ØÊý¾ÝΪ¿Õ2222");
|
}
|
|
String hql_existRecord = "from ExerciseFavoriteRecord where favoriteBookId=? and exerciseGroupId=? ";
|
List<ExerciseFavoriteRecord> lstRecord = null;
|
ExerciseFavorite favor=null;
|
ExerciseFavorite newFavor=null;
|
String exerciseFavoriteId="";
|
int i=0;
|
for(Object[] objs:lstData2){
|
favor = (ExerciseFavorite)objs[0];
|
if(favor.getExerciseFavoriteId().equals(exerciseFavoriteId)){
|
|
newFavor = new ExerciseFavorite();
|
BeanUtils.copyProperties(favor, newFavor);
|
newFavor.setExerciseFavoriteId(null);
|
|
lstRecord = commonDAO.find(hql_existRecord, CollectionUtils.newList(newFavor.getFavoriteBookId(),String.valueOf(objs[1])), ExerciseFavoriteRecord.class);
|
if(lstRecord.isEmpty()){
|
continue;
|
}
|
|
newFavor.setFavoriteRecordId(lstRecord.get(0).getFavoriteRecordId());
|
TraceUtils.setUpdateTrace(newFavor);
|
exerciseExtendService.doSavetoDB(newFavor);
|
}else{
|
lstRecord = commonDAO.find(hql_existRecord, CollectionUtils.newList(favor.getFavoriteBookId(),String.valueOf(objs[1])), ExerciseFavoriteRecord.class);
|
if(lstRecord.isEmpty()){
|
continue;
|
}
|
|
favor.setFavoriteRecordId(lstRecord.get(0).getFavoriteRecordId());
|
TraceUtils.setUpdateTrace(favor);
|
|
exerciseExtendService.doSavetoDB(favor);
|
}
|
|
i++;
|
}
|
|
return new Result(true,"|¸üÐÂExerciseFavoriteÌõÊý£º"+i);
|
}
|
|
@SuppressWarnings("unchecked")
|
@RequestMapping(value = "updateAnswerU", method = RequestMethod.GET)
|
public @ResponseBody Result doUpdateAnswerU() {
|
|
|
int count = commonDAO.findCount("select count(1) from ExerciseItemAnswerU where correct>1", Collections.EMPTY_LIST);
|
|
Pager page = new Pager();
|
|
int pageSize = 50;
|
|
int maxPage = count/pageSize + (count%pageSize>0?1:0);
|
|
page.setPageSize(pageSize);
|
page.setTotalCount(count);
|
int j=0;
|
String hql2;
|
for(int i=1;i<=maxPage;i++){
|
page.setPageNum(i);
|
List<ExerciseItemAnswerU> lstAnswerU = commonDAO.findList("from ExerciseItemAnswerU where correct>1", page, Collections.EMPTY_LIST, ExerciseItemAnswerU.class);
|
for(ExerciseItemAnswerU answer:lstAnswerU){
|
hql2 = "select answer from ExerciseItem where (answer is not null and answer != '') and exerciseId=? and deleteFlag is false ";
|
|
List<Object[]> lstData2 =commonDAO.findwithRawResult(hql2, CollectionUtils.newList(answer.getExerciseItemId()));
|
|
if(lstData2.isEmpty()){
|
continue;
|
}
|
|
if(!answer.getAnswer().equals(String.valueOf(lstData2.get(0)))
|
&& answer.getCorrect() != 0){
|
answer.setCorrect((byte)0);
|
TraceUtils.setUpdateTrace(answer);
|
exerciseExtendService.doSavetoDB(answer);
|
|
j++;
|
}
|
|
if(answer.getAnswer().equals(String.valueOf(lstData2.get(0)))
|
&& answer.getCorrect() != 1){
|
answer.setCorrect((byte)1);
|
TraceUtils.setUpdateTrace(answer);
|
exerciseExtendService.doSavetoDB(answer);
|
|
j++;
|
}
|
|
}
|
}
|
|
return new Result(true,"|¸üÐÂExerciseItemAnswerUÌõÊý£º"+j);
|
}*/
|
}
|
