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