package com.qxueyou.scc.exercise.action;
|
|
import java.io.IOException;
|
import java.io.OutputStream;
|
import java.lang.reflect.InvocationTargetException;
|
import java.math.BigDecimal;
|
import java.math.BigInteger;
|
import java.sql.Timestamp;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
import javax.servlet.http.HttpServletResponse;
|
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.logging.log4j.LogManager;
|
import org.apache.logging.log4j.Logger;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Controller;
|
import org.springframework.web.bind.annotation.PathVariable;
|
import org.springframework.web.bind.annotation.RequestBody;
|
import org.springframework.web.bind.annotation.RequestMapping;
|
import org.springframework.web.bind.annotation.RequestMethod;
|
import org.springframework.web.bind.annotation.RequestParam;
|
import org.springframework.web.bind.annotation.ResponseBody;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.fasterxml.jackson.databind.JavaType;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.qxueyou.scc.admin.classes.model.ClsClass;
|
import com.qxueyou.scc.base.dao.CommonDAO;
|
import com.qxueyou.scc.base.model.Constants;
|
import com.qxueyou.scc.base.model.ExcelExportParam;
|
import com.qxueyou.scc.base.model.Pager;
|
import com.qxueyou.scc.base.model.Result;
|
import com.qxueyou.scc.base.model.ResultJson;
|
import com.qxueyou.scc.base.util.ClientUtils;
|
import com.qxueyou.scc.base.util.CollectionUtils;
|
import com.qxueyou.scc.base.util.ExcelExportUtils;
|
import com.qxueyou.scc.exercise.model.ExerGroupResponseData;
|
import com.qxueyou.scc.exercise.model.ExerItemResponseData;
|
import com.qxueyou.scc.exercise.model.ExerciseAddItemParams;
|
import com.qxueyou.scc.exercise.model.ExerciseChapter;
|
import com.qxueyou.scc.exercise.model.ExerciseDataSubmitLog;
|
import com.qxueyou.scc.exercise.model.ExerciseGroup;
|
import com.qxueyou.scc.exercise.model.ExerciseGroupExtend;
|
import com.qxueyou.scc.exercise.model.ExerciseItem;
|
import com.qxueyou.scc.exercise.model.ExerciseItemAnswerData;
|
import com.qxueyou.scc.exercise.model.ExerciseItemData;
|
import com.qxueyou.scc.exercise.model.ExerciseItemOption;
|
import com.qxueyou.scc.exercise.model.ExerciseItemStatistics;
|
import com.qxueyou.scc.exercise.model.ExerciseObjectImg;
|
import com.qxueyou.scc.exercise.model.ExerciseParseResult;
|
import com.qxueyou.scc.exercise.model.ExerciseRecord;
|
import com.qxueyou.scc.exercise.model.ExerciseSubmitAnswerData;
|
import com.qxueyou.scc.exercise.model.ExerciseSubmitAnswerDataList;
|
import com.qxueyou.scc.exercise.service.IExercisePyService;
|
import com.qxueyou.scc.exercise.service.IExerciseService;
|
import com.qxueyou.scc.exercise.service.IExerciseVerService;
|
import com.qxueyou.scc.org.model.OrgCollegeCourse;
|
import com.qxueyou.scc.org.model.Organization;
|
import com.qxueyou.scc.school.model.SchClassSubject;
|
import com.qxueyou.scc.sys.service.IOssService;
|
import com.qxueyou.scc.user.model.ExportUserScore;
|
|
/**
|
* 练习题目控制
|
* @author zhiyong
|
*
|
*/
|
@Controller
|
@RequestMapping(value = "/exercise/Exercise")
|
public class ExerciseController {
|
/** 日志 */
|
private static final Logger log = LogManager.getLogger("ExerciseController");
|
|
/** commonDAO */
|
@Autowired
|
private CommonDAO commonDAO;
|
|
/** 练习 service */
|
@Autowired
|
private IExerciseService exerciseService;
|
|
/** 练习导入 service */
|
@Autowired
|
private IExercisePyService exercisePyService;
|
|
/** 练习V2.0版本接口service */
|
@Autowired
|
private IExerciseVerService exerciseVerService;
|
|
/** 练习V2.0版本接口service */
|
// @Autowired
|
// IConfigService cfg;
|
|
/** oss service */
|
@Autowired
|
IOssService ossService;
|
|
/** 消息发送 service */
|
// @Autowired
|
// IMsgVenderService easemobService;
|
|
/** 组id */
|
private static final String GROUP_ID = "groupId";
|
|
/** 做题记录id */
|
private static final String EXERCISE_RECORD_ID = "exerciseRecordId";
|
|
/** ---------------------------APP V2.0接口 start----------------------*/
|
/**
|
* APP2.0: 获取家庭作业list
|
* URL: /exercise/Exercise/homeWorkListNew
|
*
|
*
|
*请求参数={
|
subjectId:课程id，//可选，用于高校版
|
page:当前页,//必传,大于0
|
limit:每页限制条数,//必传,大于0
|
}
|
返回参数=[
|
{
|
GROUP_ID:"组id",
|
"classId":班级id,
|
"courseId":科目id,
|
"orgId":机构id,
|
"subjectId":课程id,
|
"name":"组名",
|
"type":组类型 ,
|
"updateTime":更新时间,
|
"answerUpdateTime":本套题答题更新时间,
|
"allCount":题目总数,
|
"exerciseTime":"考试时间",
|
EXERCISE_RECORD_ID:"记录id",
|
"doCount": 做题个数,
|
"correctCount": 正确个数,
|
"submitNumber":已提交人数(家庭作业),
|
"currTitleNumber":当前做题序号,
|
"status":做题状态(0：未提交 1：已提交),
|
"completionRate": 完成率,
|
"accuracy": 正确率,
|
"score": 分数,
|
"extendAllCount":错题本、收藏本总数
|
},
|
...循环多个
|
]
|
*
|
* @return
|
*/
|
@RequestMapping(value = "homeWorkListNew", method = RequestMethod.GET)
|
public @ResponseBody List<ExerGroupResponseData> getHomeWorkExerList(
|
@RequestParam(value="subjectId", required = false) String subjectId,
|
@RequestParam(value="page") int page,
|
@RequestParam(value="limit") int limit,
|
@RequestParam(value="selected", required = false) Integer selected) {// 0:全部 1：未开始 2：做题中 3：已提交
|
|
// 获取group data
|
List<ExerGroupResponseData> lstResult = getExericseListData(ExerciseGroup.TYPE_HOMEWORK,
|
null, page, limit, selected, null);
|
|
return lstResult;
|
}
|
|
|
/**
|
* APP2.0: 获取章节练习list
|
* URL: /exercise/Exercise/chapterListNew
|
*
|
* @return
|
*/
|
@RequestMapping(value = "chapterListNew", method = RequestMethod.GET)
|
public @ResponseBody List<ExerGroupResponseData> getChapterItemList(
|
@RequestParam(value="subjectId", required = false) String subjectId,
|
@RequestParam(value="page") int page,
|
@RequestParam(value="limit") int limit,
|
@RequestParam(value="selected", required = false) Integer selected, String chapterId) {
|
|
// 获取group data
|
List<ExerGroupResponseData> lstResult = getExericseListData(ExerciseGroup.TYPE_CHAPTER_ITEM,
|
subjectId, page, limit, selected, chapterId);
|
|
return lstResult;
|
}
|
|
/**
|
* APP2.0: 获取模拟考试list
|
* URL: /exercise/Exercise/examsListNew
|
*
|
* @return
|
*/
|
@RequestMapping(value = "examsListNew", method = RequestMethod.GET)
|
public @ResponseBody List<ExerGroupResponseData> getExamsExerList(
|
@RequestParam(value="subjectId", required = false) String subjectId,
|
@RequestParam(value="page") int page,
|
@RequestParam(value="limit") int limit,
|
@RequestParam(value="selected", required = false) Integer selected) {
|
|
// 获取group data
|
List<ExerGroupResponseData> lstResult = getExericseListData(ExerciseGroup.TYPE_MOCK_EXAM,
|
null, page, limit, selected, null);
|
|
return lstResult;
|
}
|
|
/**
|
* APP2.0: 获取专题练习list
|
* URL: /exercise/Exercise/topicListNew
|
*
|
* @return
|
*/
|
@RequestMapping(value = "topicListNew", method = RequestMethod.GET)
|
public @ResponseBody List<ExerGroupResponseData> getTopicExerList(
|
@RequestParam(value="subjectId", required = false) String subjectId,
|
@RequestParam(value="page") int page,
|
@RequestParam(value="limit") int limit,
|
@RequestParam(value="selected", required = false) Integer selected) {
|
|
// 获取group data
|
List<ExerGroupResponseData> lstResult = getExericseListData(ExerciseGroup.TYPE_EXERCISE_TOPIC,
|
null, page, limit, selected, null);
|
|
return lstResult;
|
}
|
|
/**
|
* APP2.0: 获取专题练习list
|
* URL: /exercise/Exercise/freeListNew
|
*
|
* @return
|
*/
|
@RequestMapping(value = "freeListNew", method = RequestMethod.GET)
|
public @ResponseBody List<ExerGroupResponseData> getFreeExerList(
|
@RequestParam(value="subjectId", required = false) String subjectId,
|
@RequestParam(value="page") int page,
|
@RequestParam(value="limit") int limit,
|
@RequestParam(value="selected", required = false) Integer selected) {
|
|
// 获取group data
|
List<ExerGroupResponseData> lstResult = getExericseListData(ExerciseGroup.TYPE_EXERCISE_FREE,
|
null, page, limit, selected, null);
|
|
return lstResult;
|
}
|
|
/**
|
* 获取练习列表数据
|
* @param exerType
|
* @param subjectId
|
* @param page
|
* @param limit
|
* @param selected // 0:全部 1：未开始 2：做题中 3：已提交
|
* @return
|
*/
|
private List<ExerGroupResponseData> getExericseListData(short exerType,
|
String subjectId, int page, int limit, Integer selected, String chapterId){
|
int pageNum = page;
|
int pageSize = limit;
|
Integer iSelected = selected;
|
|
// 1.分页信息
|
if(pageNum < 1){
|
pageNum = 1;
|
}
|
if(pageSize < 1){
|
pageSize = 1;
|
}
|
if(iSelected == null){//为空设置为 全部
|
iSelected = 0;
|
}
|
Pager pager = new Pager();
|
pager.setPageNum(pageNum);
|
pager.setPageSize(limit);
|
|
// 2.得到列表数据
|
List<ExerGroupResponseData> lstResult = exerciseVerService.queryExericseListData(exerType,subjectId,pager,iSelected, chapterId);
|
|
if(null == lstResult){// 结果转换成 []
|
lstResult = new ArrayList<ExerGroupResponseData>();
|
}
|
|
return lstResult;
|
}
|
|
/**
|
* APP2.0: 查询做题记录
|
* URL: /exercise/Exercise/exerRecord
|
* 请求参数={
|
exerType:练习类型,//必传
|
subjectId:课程id，//可选，用于高校版
|
page:当前页,//必传,大于0
|
limit:每页限制条数,//必传,大于0
|
}
|
|
返回参数=[
|
{
|
GROUP_ID:"组id",
|
"classId":班级id,
|
"courseId":科目id,
|
"orgId":机构id,
|
"subjectId":课程id,
|
"name":"组名",
|
"type":组类型 ,
|
"updateTime":更新时间,
|
"answerUpdateTime":本套题答题更新时间,
|
"allCount":题目总数,
|
"exerciseTime":"考试时间",
|
EXERCISE_RECORD_ID:"记录id",
|
"doCount": 做题个数,
|
"correctCount": 正确个数,
|
"submitNumber":已提交人数(家庭作业),
|
"currTitleNumber":当前做题序号,
|
"status":做题状态(0：未提交 1：已提交),
|
"completionRate": 完成率,
|
"accuracy": 正确率,
|
"score": 分数,
|
"extendAllCount":错题本、收藏本总数
|
},
|
...循环多个
|
]
|
* @param page
|
* @param start
|
* @param limit
|
* @return
|
*/
|
@RequestMapping(value = "exerRecord", method = RequestMethod.GET)
|
public @ResponseBody List<ExerGroupResponseData> queryExerRecordListNew(
|
@RequestParam(value="exerType") int exerType,
|
@RequestParam(value="subjectId", required = false) String subjectId,
|
@RequestParam(value="page") int page,
|
@RequestParam(value="limit") int limit) {
|
|
int pageNum = page;
|
int pageSize = limit;
|
|
// 1.分页信息
|
if(pageNum < 1){
|
pageNum = 1;
|
}
|
if(pageSize < 1){
|
pageSize = 1;
|
}
|
|
Pager pager = new Pager();
|
pager.setPageNum(pageNum);
|
pager.setPageSize(pageSize);
|
|
|
StringBuffer hql = new StringBuffer(512);
|
// 2.查询结果
|
hql.append("select g,"
|
+ " r.recordId,r.updateTime,r.doCount,r.titleMaxNumber,r.status,"
|
+ " r.correctCount,r.completionRate,r.score,r.accuracy,e.repeatFlag,e.classAccuracy, "
|
+ " e.exerciseTime,e.exerciseStrategy,e.exerciseSource,e.exerciseMode"
|
+ " from ExerciseRecord r, ExerciseGroup g,ExerciseGroupExtend e "
|
+ " where r.exerciseGroupId=g.groupId"
|
+ " and g.groupId=e.groupId"
|
+ " and g.deleteFlag is false "
|
+ " and r.userId=?"
|
+ " and g.type=?"
|
+ " and g.classId=? ");
|
|
List<Object> args = CollectionUtils.newList(ClientUtils.getUserId(), (short)exerType, ClientUtils.getClassId());
|
|
/*if(StringUtils.isNotBlank(subjectId)){
|
hql.append(" and g.subjectId=? ");
|
args.add(subjectId);
|
}*/
|
|
hql.append(" order by r.updateTime desc ");
|
|
List<Object[]> lstRecord = commonDAO.findList(hql.toString(), pager, args, Object[].class);
|
|
List<ExerGroupResponseData> lstResult = new ArrayList<ExerGroupResponseData>(lstRecord.size());
|
|
// 3.重组字段
|
for(Object[] obj:lstRecord){
|
|
// 组装练习做题记录列表数据
|
lstResult.add(packagingExerciseRecordListData(exerType, obj));
|
|
}
|
|
return lstResult;
|
}
|
|
/**
|
* 组装练习做题记录列表数据
|
* @param exerType
|
* @param obj
|
* @param group
|
* @param result
|
* @return
|
*/
|
private ExerGroupResponseData packagingExerciseRecordListData(int exerType,
|
Object[] obj) {
|
ExerciseGroup group = (ExerciseGroup)obj[0];
|
ExerGroupResponseData result = new ExerGroupResponseData();
|
|
// 赋值字段值
|
BeanUtils.copyProperties(group, result);
|
|
result.setExerciseRecordId(String.valueOf(obj[1]));
|
result.setAnswerUpdateTime((Timestamp)obj[2]);
|
if(obj[3] == null){
|
result.setDoCount(BigInteger.ZERO);
|
}else{
|
result.setDoCount((BigInteger)obj[3]);
|
}
|
result.setCurrTitleNumber(String.valueOf(obj[4]));
|
result.setStatus(String.valueOf(obj[5]));
|
|
// 组装练习做题记录部分参数
|
packagingExerciseRecordListParam(obj, result);
|
|
result.setExtendAllCount(group.getAllCount());
|
|
if(obj[10] == null){
|
if(exerType == ExerciseGroup.TYPE_HOMEWORK){// 家庭作业
|
result.setRepeatFlag(false);
|
}else{
|
result.setRepeatFlag(true);
|
}
|
}else{
|
result.setRepeatFlag(!(boolean)obj[10]);// true 可以重做 false不能重做
|
}
|
|
// 班级正确率
|
result.setClassAccuracy(obj[11] == null ? "--" :obj[11]+"%");
|
|
if(exerType == ExerciseGroup.TYPE_EXERCISE_FREE
|
|| exerType == ExerciseGroup.TYPE_MOCK_EXAM ){// 自由练习 模拟考试
|
result.setExerciseTime(String.valueOf(obj[12]));
|
result.setExerciseStrategy(String.valueOf(obj[13]));
|
result.setExerciseSource(String.valueOf(obj[14]));
|
result.setExerciseMode(String.valueOf(obj[15]));
|
}
|
return result;
|
}
|
|
/**
|
* 组装练习做题记录部分参数 拆分方法
|
* @param obj
|
* @param result
|
*/
|
private void packagingExerciseRecordListParam(Object[] obj,
|
ExerGroupResponseData result) {
|
if(obj[6] == null){
|
result.setCorrectCount(BigInteger.ZERO);
|
}else{
|
result.setCorrectCount(new BigInteger(String.valueOf(obj[6])));
|
}
|
if(obj[7] == null){
|
result.setCompletionRate(BigDecimal.ZERO);
|
}else{
|
result.setCompletionRate(new BigDecimal(String.valueOf(obj[7])));
|
}
|
if(obj[8] == null){
|
result.setScore(BigDecimal.ZERO);
|
}else{
|
result.setScore(new BigDecimal(String.valueOf(obj[8])));
|
}
|
if(obj[9] == null){
|
result.setAccuracy(BigDecimal.ZERO);
|
}else{
|
result.setAccuracy(new BigDecimal(String.valueOf(obj[9])));
|
}
|
}
|
|
/**
|
* APP2.0: 获取家庭作业练习题目数据
|
* URL: /exercise/Exercise/homeworkExercise
|
*
|
* 请求参数={
|
groupId:组id，//必传
|
exerciseRecordId:当前页,//必传,没有传""
|
getExercise:是否更新题目,//必传,
|
boolean值，没有传false
|
getAnswer:是否更新答案,//必传,
|
boolean值，没有传false
|
}
|
|
返回参数={
|
"items":[// 题目集合
|
{
|
"exerciseId":练习id,
|
"chapterId":null,
|
"lessonId":null,
|
"title":标题,
|
"type":题目类型,
|
"answer":正确答案,
|
"options":[
|
{
|
"optionId":选项id,
|
"checked":true,
|
"content":内容,
|
"optionOrder":题目序号,
|
"exerciseItemId":"练习id",
|
"imgs":[
|
{
|
"imgId":"图片id",
|
"exerciseObjectId":null,
|
"imgPath":图片路径,
|
"imgOrder":排序,
|
"objectType":图片类型 1：题目 2：选项
|
},
|
... 循环多个
|
]
|
},
|
... 循环多个
|
],
|
"scores":null,
|
"itemNo":null,
|
"analisisResult":{
|
"allAccuracy":全站统计 正确率,
|
"analysis":"解析",
|
"submitAllNumber":全站 提交总数,
|
"usualFaultAnswers":易错题,
|
"exerciseAnalisisUId":null,
|
"accuracy":个人统计 正确率,
|
"submitNumber":个人统计 提交总数,
|
"submitErrorNumber":个人统计 提交错误总数,
|
},
|
"imgs":[
|
{
|
"imgId":"图片id",
|
"exerciseObjectId":null,
|
"imgPath":图片路径,
|
"imgOrder":排序,
|
"objectType":图片类型 1：题目 2：选项
|
},
|
... 循环多个
|
],
|
"commentFlag": null,
|
}
|
],
|
"answers":[// 个人答案集合
|
{
|
"answerUId":"主键id",
|
"answer":选择答案 如：多选为(A,B,C),
|
"correct":0,
|
"exerciseItemId":练习id,
|
EXERCISE_RECORD_ID:记录id,
|
"userId":用户id
|
},
|
... 循环多个
|
]
|
}
|
* @param groupId 组id
|
* @param exerciseRecordId 练习记录id
|
* @param getExercise 是否获取练习题
|
* @param getAnswer 是否获取答案
|
* @return
|
*/
|
@RequestMapping(value = "homeworkExercise", method = RequestMethod.GET)
|
public @ResponseBody ExerItemResponseData getHomeworkExerciseData(
|
@RequestParam(value = GROUP_ID) String groupId,
|
@RequestParam(value = EXERCISE_RECORD_ID) String exerciseRecordId,
|
@RequestParam(value = "getExercise") boolean getExercise,
|
@RequestParam(value = "getAnswer") boolean getAnswer) {
|
|
// 获取结果
|
ExerItemResponseData result = exerciseVerService.queryExerItemResponseData(groupId,
|
exerciseRecordId, getExercise, getAnswer, ExerciseGroup.TYPE_HOMEWORK);
|
|
return result;
|
}
|
|
/**
|
* APP2.0: 获取模拟考试练习题目数据
|
* URL: /exercise/Exercise/examExercise
|
* @param groupId 组id
|
* @param exerciseRecordId 练习记录id
|
* @param getExercise 是否获取练习题
|
* @param getAnswer 是否获取答案
|
* @return
|
*/
|
@RequestMapping(value = "examExercise", method = RequestMethod.GET)
|
public @ResponseBody ExerItemResponseData getExamExerciseData(
|
@RequestParam(value = GROUP_ID) String groupId,
|
@RequestParam(value = EXERCISE_RECORD_ID) String exerciseRecordId,
|
@RequestParam(value = "getExercise") boolean getExercise,
|
@RequestParam(value = "getAnswer") boolean getAnswer) {
|
|
// 获取结果
|
ExerItemResponseData result = exerciseVerService.queryExerItemResponseData(groupId,
|
exerciseRecordId, getExercise, getAnswer, ExerciseGroup.TYPE_MOCK_EXAM);
|
|
return result;
|
}
|
|
|
/**
|
* APP2.0: 获取章节练习题目数据
|
* URL: /exercise/Exercise/chapterExercise
|
* @param groupId 组id
|
* @param exerciseRecordId 练习记录id
|
* @param getExercise 是否获取练习题
|
* @param getAnswer 是否获取答案
|
* @return
|
*/
|
@RequestMapping(value = "chapterExercise", method = RequestMethod.GET)
|
public @ResponseBody ExerItemResponseData getChapterExerciseData(
|
@RequestParam(value = GROUP_ID) String groupId,
|
@RequestParam(value = EXERCISE_RECORD_ID) String exerciseRecordId,
|
@RequestParam(value = "getExercise") boolean getExercise,
|
@RequestParam(value = "getAnswer") boolean getAnswer) {
|
|
// 获取结果
|
ExerItemResponseData result = exerciseVerService.queryExerItemResponseData(groupId,
|
exerciseRecordId, getExercise, getAnswer, ExerciseGroup.TYPE_CHAPTER_ITEM);
|
|
return result;
|
}
|
|
/**
|
* APP2.0: 获取专题练习题目数据
|
* URL: /exercise/Exercise/topicExercise
|
* @param groupId 组id
|
* @param exerciseRecordId 练习记录id
|
* @param getExercise 是否获取练习题
|
* @param getAnswer 是否获取答案
|
* @return
|
*/
|
@RequestMapping(value = "topicExercise", method = RequestMethod.GET)
|
public @ResponseBody ExerItemResponseData getTopicExerciseData(
|
@RequestParam(value = GROUP_ID) String groupId,
|
@RequestParam(value = EXERCISE_RECORD_ID) String exerciseRecordId,
|
@RequestParam(value = "getExercise") boolean getExercise,
|
@RequestParam(value = "getAnswer") boolean getAnswer) {
|
|
// 获取结果
|
ExerItemResponseData result = exerciseVerService.queryExerItemResponseData(groupId,
|
exerciseRecordId, getExercise, getAnswer, ExerciseGroup.TYPE_EXERCISE_TOPIC);
|
|
return result;
|
}
|
|
|
/**
|
* APP2.0: 获取专题练习题目数据
|
* URL: /exercise/Exercise/freeExercise
|
* @param groupId 组id
|
* @param exerciseRecordId 练习记录id
|
* @param getExercise 是否获取练习题
|
* @param getAnswer 是否获取答案
|
* @return
|
*/
|
@RequestMapping(value = "freeExercise", method = RequestMethod.GET)
|
public @ResponseBody ExerItemResponseData getFreeExerciseData(
|
@RequestParam(value = GROUP_ID) String groupId,
|
@RequestParam(value = EXERCISE_RECORD_ID) String exerciseRecordId,
|
@RequestParam(value = "getExercise") boolean getExercise,
|
@RequestParam(value = "getAnswer") boolean getAnswer) {
|
|
// 获取结果
|
ExerItemResponseData result = exerciseVerService.queryExerItemResponseData(groupId,
|
exerciseRecordId, getExercise, getAnswer, ExerciseGroup.TYPE_EXERCISE_FREE);
|
|
|
return result;
|
}
|
|
/**
|
* APP2.0: 获取专题练习题目数据
|
* URL: /exercise/Exercise/newFreeExercise
|
*
|
* {
|
* source: 练习来源(1:练习题库 2：考试题库 3：家庭作业) 多个以逗号分开
|
strategy:做题方式（1：未做题优先 2：错题优先）
|
mode:做题模式(1:练习模式 2：考试模式)
|
count:数量（30 50 100 200）
|
exerciseTime:练习时间
|
* }
|
*
|
* @return
|
*/
|
@RequestMapping(value = "newFreeExercise", method = RequestMethod.GET)
|
public @ResponseBody ExerItemResponseData getFreeExerciseData(
|
@RequestParam(value="subjectId", required = false) String subjectId,
|
@RequestParam(value = "source") String source,
|
@RequestParam(value = "strategy") String strategy,
|
@RequestParam(value = "mode") String mode,
|
@RequestParam(value = "count") int count,
|
@RequestParam(value = "exerciseTime") String exerciseTime) {
|
|
if(StringUtils.isBlank(source)
|
|| StringUtils.isBlank(strategy)
|
|| StringUtils.isBlank(exerciseTime)
|
|| count < 1){
|
return null;
|
}
|
|
// 根据条件获取自由练习
|
ExerItemResponseData result = exerciseVerService.doGetFreeExercise(
|
null, source, strategy, mode, count, exerciseTime);
|
|
return result;
|
}
|
|
|
/**
|
* APP2.0: 提交练习答案
|
* URL: /exercise/Exercise/exerAnswers
|
*
|
* 请求参数={
|
"exerciseGroupId": 组id,
|
EXERCISE_RECORD_ID: 记录id,
|
"exerciseExtendId": null,
|
"currTitleNum": "当前题号",
|
"status": 状态,
|
"type": 练习类型,// 整型
|
"doCount": 练习类型,
|
"correctCount": 正确个数,
|
"allCount":题目总数,
|
"items": [
|
{
|
"exerciseId": "练习id",
|
"type": 练习类型,// 整数型
|
"answer": "选择答案",
|
"correct": 是否正确(0:错误 1：正确 2:未知)
|
},
|
{
|
"exerciseId": "练习id",
|
"type": 练习类型,
|
"answer": "选择答案",
|
"correct": 是否正确(0:错误 1：正确 2:未知)
|
}
|
]
|
}
|
|
返回参数={
|
"success":true,//true:成功 false:失败
|
"attrs":{EXERCISE_RECORD_ID:练习记录id,
|
"updateTime":修改时间
|
},
|
"msg":"提交成功",//结果信息
|
}
|
|
*
|
* @param answers
|
* @return
|
*/
|
@RequestMapping(value = "exerAnswers", method = RequestMethod.POST)
|
public @ResponseBody Object doSubmitExerAnswer(
|
@RequestParam(value = "answers") String answers) {
|
|
// 用户本次做题提交的数据
|
List<ExerciseItemAnswerData> lstAnswers = null;
|
|
Result result = new Result(false);
|
String exerciseRecordId = null;
|
try {
|
ObjectMapper mapper = new ObjectMapper();
|
|
// 装换json到对象
|
ExerciseSubmitAnswerData answerData = mapper.readValue(answers, ExerciseSubmitAnswerData.class);
|
|
lstAnswers = answerData.getItems();
|
|
// 记录id
|
String initExerciseRecordId = answerData.getExerciseRecordId();
|
|
if(lstAnswers.isEmpty()
|
&& !ExerciseRecord.STATUS_SUBMIT.equals(answerData.getStatus())
|
&& answerData.getSubmitType() != 1){
|
|
exerciseVerService.doSaveExerciseDataSubmitLog(answers,
|
initExerciseRecordId, ExerciseDataSubmitLog.TYPE_SUBMIT_ANSWER,
|
ExerciseDataSubmitLog.STATUS_FAILED, "/exercise/Exercise/exerAnswers");
|
|
return new Result(false,"提交数据异常");
|
}
|
|
// 1.---------记录提交的数据日志
|
// 记录提交的数据日志
|
String exerciseDataLogId = exerciseVerService.doSaveExerciseDataSubmitLog(answers,
|
initExerciseRecordId, ExerciseDataSubmitLog.TYPE_SUBMIT_ANSWER,
|
ExerciseDataSubmitLog.STATUS_SUCCESS,"/exercise/Exercise/exerAnswers");
|
|
// 2.-------- 提交答案
|
// 操作练习数据
|
Map<String,Object> resultMap = exerciseVerService.doOperExerciseAnswerData(answerData);
|
|
result = new Result(true, "答案提交成功");
|
result.setData(resultMap);
|
|
// 3.-------- 班级统计数据
|
if(resultMap.get("exerciseGroupId") != null){
|
|
String exerciseGroupId = String.valueOf(resultMap.get("exerciseGroupId"));
|
|
// 2.发送班级排名请求
|
exerciseVerService.sendUpdateClassRankMsg(exerciseGroupId);
|
|
// 3.发送 题目的全站统计 、个人统计、班级正确率请求消息
|
exerciseVerService.sendUpdateExerItemStatisticsMsg(exerciseGroupId, answerData);
|
//exerciseVerService.doStatisUserExerciseItemData(ClientUtils.getUserId(), ClientUtils.getUserName(), answerData);
|
}
|
|
// 4.---------更新本次提交的数据日志exerciseRecordId
|
if(StringUtils.isBlank(initExerciseRecordId)
|
&& resultMap.get(EXERCISE_RECORD_ID) != null){// 为空 说明第一次提交 更新日志记录id
|
|
exerciseRecordId = String.valueOf(resultMap.get(EXERCISE_RECORD_ID));
|
|
exerciseVerService.doUpdateExerciseDataSubmitLog(exerciseDataLogId, exerciseRecordId);
|
}
|
|
} catch (Exception e) {
|
|
result = new Result(false, "提交练习答案请求异常");
|
log.error("提交练习答案请求异常===",e);
|
|
exerciseVerService.doSaveExerciseDataSubmitLog(answers,
|
exerciseRecordId, ExerciseDataSubmitLog.TYPE_SUBMIT_ANSWER,
|
ExerciseDataSubmitLog.STATUS_FAILED, "/exercise/Exercise/exerAnswers");
|
}
|
|
return result;
|
}
|
|
|
/**
|
* APP2.0: 提交练习答案
|
* URL: /exercise/Exercise/exerAnswers
|
*
|
* 请求参数=[{
|
"exerciseGroupId": 组id,
|
EXERCISE_RECORD_ID: 记录id,
|
"exerciseExtendId": null,
|
"currTitleNum": "当前题号",
|
"status": 状态,
|
"type": 练习类型,// 整型
|
"doCount": 练习类型,
|
"correctCount": 正确个数,
|
"allCount":题目总数,
|
"items": [
|
{
|
"exerciseId": "练习id",
|
"type": 练习类型,// 整数型
|
"answer": "选择答案",
|
"correct": 是否正确(0:错误 1：正确 2:未知)
|
},
|
{
|
"exerciseId": "练习id",
|
"type": 练习类型,
|
"answer": "选择答案",
|
"correct": 是否正确(0:错误 1：正确 2:未知)
|
}
|
]
|
},
|
...
|
]
|
|
返回参数={"success":true,//true:成功 false:失败
|
"attrs":[{EXERCISE_RECORD_ID:练习记录id,
|
exerciseGroupId:练习组id，
|
isNewRecord：是否为新增的record(true:是 false:否)
|
"updateTime":修改时间
|
},...],
|
"msg":"提交成功",//结果信息
|
}
|
|
*
|
* @param answers
|
* @return
|
*/
|
@RequestMapping(value = "exerMutiAnswers", method = RequestMethod.POST)
|
public @ResponseBody Object doSubmitMutiExerAnswer(
|
@RequestParam(value = "answers") String answers) {
|
|
// 用户本次做题提交的数据
|
List<ExerciseSubmitAnswerData> lstRecord = null;
|
List<ExerciseItemAnswerData> lstAnswers= null;
|
String exerciseRecordId = null;
|
ExerciseSubmitAnswerData answerData = null;
|
|
Map<String,Object> resultMap = new HashMap<String,Object>(2);
|
Map<String,Object> returnMap = null;
|
resultMap.put("success", false);
|
resultMap.put("attrs", null);
|
List<Map<String,Object>> resultList = null;
|
try {
|
ObjectMapper mapper = new ObjectMapper();
|
|
// 装换json到对象
|
ExerciseSubmitAnswerDataList answerDataList = mapper.readValue(answers, ExerciseSubmitAnswerDataList.class);
|
|
lstRecord = answerDataList.getDatas();
|
|
resultList = new ArrayList<Map<String,Object>>(lstRecord.size());
|
for(int i=0; i<lstRecord.size(); i++){
|
|
answerData = lstRecord.get(i);
|
if(null == answerData){
|
continue;
|
}
|
|
// 记录id
|
String initExerciseRecordId = answerData.getExerciseRecordId();
|
|
// 记录提交的数据日志
|
String recordData = JSONObject.toJSONString(answerData);
|
|
lstAnswers = answerData.getItems();
|
|
if(lstAnswers.isEmpty()
|
&& !ExerciseRecord.STATUS_SUBMIT.equals(answerData.getStatus())
|
&& answerData.getSubmitType() != 1){// 仅提交 或仅仅本地无网重做
|
|
exerciseVerService.doSaveExerciseDataSubmitLog(recordData,
|
initExerciseRecordId, ExerciseDataSubmitLog.TYPE_SUBMIT_ANSWER,
|
ExerciseDataSubmitLog.STATUS_FAILED,"/exercise/Exercise/exerMutiAnswers");
|
|
continue;
|
}
|
|
// 1.---------记录提交的数据日志
|
String exerciseDataLogId = exerciseVerService.doSaveExerciseDataSubmitLog(recordData,
|
initExerciseRecordId, ExerciseDataSubmitLog.TYPE_SUBMIT_ANSWER,
|
ExerciseDataSubmitLog.STATUS_SUCCESS,"/exercise/Exercise/exerMutiAnswers");
|
|
// 2.-------- 提交答案
|
// 操作练习数据
|
returnMap = exerciseVerService.doOperExerciseAnswerData(answerData);
|
if(StringUtils.isBlank(initExerciseRecordId)){// 表示recordId为新增
|
returnMap.put("isNewRecord", true);
|
}else{
|
returnMap.put("isNewRecord", false);
|
}
|
|
resultList.add(returnMap);
|
// 3.-------- 班级统计数据;
|
if(returnMap.get("exerciseGroupId") != null){
|
|
String exerciseGroupId = String.valueOf(returnMap.get("exerciseGroupId"));
|
|
// 2.发送班级排名请求
|
exerciseVerService.sendUpdateClassRankMsg(exerciseGroupId);
|
|
// 3.发送 题目的全站统计 个人统计请求消息
|
exerciseVerService.sendUpdateExerItemStatisticsMsg(exerciseGroupId, answerData);
|
}
|
|
// 4.---------更新本次提交的数据日志exerciseRecordId
|
if(StringUtils.isBlank(initExerciseRecordId)
|
&& returnMap.get(EXERCISE_RECORD_ID) != null){// 为空 说明第一次提交 更新日志记录id
|
|
exerciseRecordId = String.valueOf(returnMap.get(EXERCISE_RECORD_ID));
|
|
exerciseVerService.doUpdateExerciseDataSubmitLog(exerciseDataLogId, exerciseRecordId);
|
}
|
|
}
|
|
resultMap.put("success", true);
|
resultMap.put("attrs", resultList);
|
resultMap.put("msg", "提交成功");
|
|
} catch (Exception e) {
|
|
log.error("提交练习答案请求异常===",e);
|
resultMap.put("msg", "提交练习答案请求异常");
|
|
exerciseVerService.doSaveExerciseDataSubmitLog(answers,
|
"exerMutiAnswers", ExerciseDataSubmitLog.TYPE_SUBMIT_ANSWER,
|
ExerciseDataSubmitLog.STATUS_FAILED,"/exercise/Exercise/exerMutiAnswers");
|
}
|
|
return resultMap;
|
}
|
|
/**
|
* APP2.0: 更新练习家庭作业、模拟考试是否提交
|
* URL: /exercise/Exercise/updateHomeExerSubmitNew
|
*
|
* @param exerciseRecordId 练习记录ID
|
* @return
|
*/
|
@RequestMapping(value = "updateHomeExerSubmitNew", method = RequestMethod.GET)
|
public @ResponseBody Result doUpdateHomeExerSubmit(
|
@RequestParam(value = EXERCISE_RECORD_ID) String exerciseRecordId) {
|
Result result = new Result(false);
|
|
ExerciseRecord record = commonDAO.read(ExerciseRecord.class, exerciseRecordId);
|
if(record == null
|
|| !ClientUtils.getUserId().equals(record.getUserId())){
|
return new Result(false, "非法操作，不是当前用户操作");
|
}
|
|
record.setStatus(ExerciseRecord.STATUS_SUBMIT);
|
result = exerciseVerService.updateExerciseRecordObj(record);
|
|
return result;
|
}
|
|
/**
|
* APP2.0: 更新练习家庭作业、模拟考试是否提交
|
* URL: /exercise/Exercise/updateExerciseRecord
|
*
|
* @param exerciseRecordId 练习记录ID
|
* @return
|
*/
|
@RequestMapping(value = "updateExerciseRecord", method = RequestMethod.GET)
|
public @ResponseBody Result doUpdateExerciseRecord(
|
@RequestParam(value = EXERCISE_RECORD_ID) String exerciseRecordId,
|
@RequestParam(value = GROUP_ID) String groupId,
|
@RequestParam(value = "currTitleNum", required = false) String currTitleNum) {
|
|
Result result = exerciseVerService.doUpdateExerciseRecord(exerciseRecordId, groupId, currTitleNum);
|
|
return result;
|
}
|
|
/**
|
* APP2.0: 更新练习作业题号 app端重新开始做题
|
* URL: /exercise/Exercise/updateNewExerRecordNew
|
*
|
* @param groupId 习题组ID
|
* @return
|
*/
|
@RequestMapping(value = "updateNewExerRecordNew", method = RequestMethod.GET)
|
public @ResponseBody Result doUpdateExerItemNumber(
|
@RequestParam(value = GROUP_ID) String groupId) {
|
|
Map<String,Object> map = exerciseVerService.doInsertExerRecord(groupId);
|
|
Result result = new Result(true, "状态更新成功");
|
result.setData(map);
|
|
return result;
|
}
|
|
/**
|
* APP2.0: 题目答案分析
|
* URL: /exercise/Exercise/itemstatisics
|
*
|
*
|
*
|
* @param groupId 习题组ID
|
* @return
|
*/
|
@RequestMapping(value = "itemStatisics", method = RequestMethod.GET)
|
public @ResponseBody List<Map<String, Object>> doQueryExerciseItemStatisics(
|
@RequestParam(value = GROUP_ID) String groupId) {
|
|
// 查询结果
|
List<Map<String, Object>> resultLst = exerciseVerService.queryExerciseItemStatisics(groupId);
|
|
return resultLst;
|
}
|
|
|
|
/** -----------------------------------------------APP V2.0接口 end--------------------------------------------------------*/
|
|
|
/**------------------------------ web 后端------------------------------------------------------------------------*/
|
|
/**
|
* 练习管理主页
|
*
|
* @return
|
*/
|
@RequestMapping(method = RequestMethod.GET)
|
public String listPage() {
|
return "/exercise/Exercise";
|
}
|
|
/**
|
* 机构练习管理主页
|
*
|
* @return
|
*/
|
@RequestMapping(value = "/org",method = RequestMethod.GET)
|
public String listOrgPage() {
|
return "/exercise/OrgExercise";
|
}
|
|
/**
|
* （后台管理系统）
|
*
|
* 练习管理列表，获取列表数据
|
*
|
* @return
|
*/
|
@RequestMapping(value = "list", method = RequestMethod.GET)
|
public @ResponseBody List<ExerciseGroup> data(String tid, String classId) {
|
classId = StringUtils.isEmpty(classId)?ClientUtils.getClassId():classId;
|
|
String sql = " select g.ORIGIN_EXERCISE_ID as originExerciseId,g.NAME AS name ,g.GROUP_ID AS groupId,g.TYPE AS type,g.ORDER_NUM as orderNum,g.all_count as allCount,e.exercise_time as attribute1 "
|
+ " from exercise_group g left join exercise_group_extend e "
|
+ " on g.group_id = e.group_id and e.delete_flag = 0 "
|
+ " where g.delete_flag = 0 "
|
+ " and g.type != ? "
|
+ " and g.type != ? "
|
+ " and g.type != ? "
|
+ " and g.type != ? "
|
+ " and g.type != ? "
|
+ " and g.type != ? "
|
+ " and g.class_id = ? ";
|
if(StringUtils.isNotBlank(tid)){
|
sql = sql.concat(" and g.subject_id = ? ");
|
}
|
sql = sql.concat(" order by g.order_num asc");
|
|
//剔除互动及教学评估
|
List<ExerciseGroup> result = new ArrayList<ExerciseGroup>();
|
if(StringUtils.isNotBlank(tid)){
|
result = exerciseService.queryExerciceGroupList(sql, CollectionUtils.newList(ExerciseGroup.TYPE_EXERCISE_FREE,
|
ExerciseGroup.TYPE_INTERACT,ExerciseGroup.TYPE_EXERCISE_TEACH_EVALUATE,ExerciseGroup.TYPE_EXERCISE_SEQUENCE,
|
ExerciseGroup.TYPE_EXERCISE_RANDOM, ExerciseGroup.TYPE_CHAPTER_ITEM,classId,tid));
|
}else{
|
result = exerciseService.queryExerciceGroupList(sql, CollectionUtils.newList(ExerciseGroup.TYPE_EXERCISE_FREE,
|
ExerciseGroup.TYPE_INTERACT,ExerciseGroup.TYPE_EXERCISE_TEACH_EVALUATE,ExerciseGroup.TYPE_EXERCISE_SEQUENCE,
|
ExerciseGroup.TYPE_EXERCISE_RANDOM, ExerciseGroup.TYPE_CHAPTER_ITEM ,classId));
|
}
|
|
for (ExerciseGroup exerciseGroup : result) {
|
if(StringUtils.isNotBlank(exerciseGroup.getOriginExerciseId())){
|
exerciseGroup.setEditFlag(false);
|
}else{
|
exerciseGroup.setEditFlag(true);
|
}
|
|
}
|
return result;
|
}
|
|
/**
|
* （后台管理系统）
|
*
|
* 机构练习管理列表，获取列表数据
|
*
|
* @return
|
*/
|
@RequestMapping(value = "orgList", method = RequestMethod.GET)
|
public @ResponseBody List<Map<String,Object>> orgData(String collegeCourseId) {
|
List<Map<String,Object>> list = new ArrayList<Map<String,Object>>();
|
List<Object[]> result = new ArrayList<Object[]>();
|
String hql = "select e,o.name,c.exerciseCourseId,c.orderNum from ExerciseGroup e ,OrgCollegeCourse o ,ExerciseReCourse c "
|
+ " where e.groupId = c.groupId"
|
+ " and o.collegeCourseId = c.collegeCourseId "
|
+ " and c.orgId=? "
|
+ " and o.deleteFlag is false "
|
+ " and c.deleteFlag is false "
|
+ " and e.deleteFlag is false ";
|
|
if(StringUtils.isNotBlank(collegeCourseId)){
|
hql = hql.concat( " and c.collegeCourseId = ? order by c.orderNum asc ");
|
result = commonDAO.findwithRawResult(hql, CollectionUtils.newList(ClientUtils.getOrgId(),collegeCourseId));
|
}else{
|
hql = hql.concat( " order by c.orderNum asc ");
|
result = commonDAO.findwithRawResult(hql, CollectionUtils.newList(ClientUtils.getOrgId()));
|
}
|
|
for (Object[] objects : result) {
|
ExerciseGroup group = (ExerciseGroup) objects[0];
|
Map<String,Object> map = new HashMap<String, Object>();
|
map.put("name", group.getName());
|
map.put("typeName", group.getTypeName());
|
map.put("allCount", group.getAllCount());
|
map.put("attribute1", group.getAttribute1());
|
map.put("type", group.getType());
|
map.put(GROUP_ID, group.getGroupId());
|
map.put("courseName", objects[1]);
|
map.put("exerciseCourseId", objects[2]);
|
map.put("orderNum", objects[3]);
|
//findAlreadyOrg(group,map);
|
map.put("meFlag", ClientUtils.getOrgId().equals(group.getOrgId()));
|
list.add(map);
|
|
}
|
|
return list;
|
}
|
|
/**
|
* 查看练习已经指定的机构和班级
|
* @param groupId
|
* @return
|
*/
|
@RequestMapping(value = "/exerOrgIds", method = RequestMethod.GET)
|
public @ResponseBody Result findAlreadyOrg(String groupId){
|
Map<String,Object> map = new HashMap<String, Object>();
|
String hql = " select r from ExerciseReCourse c,Organization r"
|
+ " where c.orgId = r.organizationId"
|
+ " and c.deleteFlag is false"
|
+ " and r.deleteFlag is false"
|
+ " and c.groupId = ?";
|
List<Organization> lstOrg = commonDAO.find(hql, CollectionUtils.newList(groupId), Organization.class);
|
//StringBuffer sbName = new StringBuffer();
|
StringBuffer sbId = new StringBuffer();
|
List<String> classIds = new ArrayList<String>();
|
//String orgNames = "";
|
String orgIds = "";
|
for (Organization org : lstOrg) {
|
//sbName.append(org.getName()+",");
|
sbId.append(org.getOrganizationId()).append(',');
|
}
|
|
if(classIds.isEmpty()){
|
map.put("classIds", "");
|
}else{
|
hql = "select distinct classId from ExerciseGroup where classId in (:classIds) and deleteFlag is false and originExerciseId = :groupId";
|
Map<String,Object> args = new HashMap<String,Object>();
|
|
args.put("classIds", classIds.toArray());
|
|
|
args.put(GROUP_ID, groupId);
|
List<String> objs = commonDAO.findByComplexHql(hql, args, String.class);
|
map.put("classIds", StringUtils.join(objs.toArray(), ","));
|
}
|
|
/*if(sbName.length()>0){
|
orgNames = sbName.deleteCharAt(sbName.length()-1).toString();
|
}*/
|
if(sbId.length()>0){
|
orgIds = sbId.deleteCharAt(sbId.length()-1).toString();
|
}
|
//map.put("orgNames", orgNames);
|
map.put("orgIds", orgIds);
|
Result result = new Result(true);
|
result.setData(map);
|
return result;
|
}
|
/**
|
* 获取练习组数据
|
*
|
* @return
|
*/
|
@RequestMapping(value = "group/{groupId}", method = RequestMethod.GET)
|
public @ResponseBody ExerciseGroup readGroup(@PathVariable String groupId) {
|
|
String hql = "from ExerciseGroup where groupId=? and deleteFlag is false";
|
|
ExerciseGroup group = commonDAO.findUnique(hql, CollectionUtils.newList(groupId), ExerciseGroup.class);
|
|
group.setItems(null);
|
|
return group;
|
}
|
|
/**
|
* 获取练习数据
|
*
|
* @return
|
*/
|
@RequestMapping(value = "item/{exerciseId}", method = RequestMethod.GET)
|
public @ResponseBody ExerciseItem readExerciseItem(@PathVariable String exerciseId) {
|
|
String hql = "from ExerciseItem where exerciseId=? and deleteFlag is false";
|
|
ExerciseItem item = commonDAO.findUnique(hql, CollectionUtils.newList(exerciseId), ExerciseItem.class);
|
|
return item;
|
}
|
|
/**
|
* 获取练习数据
|
*
|
* @return
|
*/
|
@RequestMapping(value = "itemNew/{exerciseId}", method = RequestMethod.GET)
|
public @ResponseBody ExerciseItem readExerciseItem(@PathVariable String exerciseId,String groupId) {
|
|
String hql = "from ExerciseItem where exerciseId=? and deleteFlag is false";
|
|
ExerciseItem item = commonDAO.findUnique(hql, CollectionUtils.newList(exerciseId), ExerciseItem.class);
|
|
String hqlForNo = "select itemOrder from ExerciseGroupItemRe where exerciseItemId=? and exerciseGroupId=?";
|
|
Integer itemOrder = commonDAO.findUnique(hqlForNo, CollectionUtils.newList(exerciseId,groupId), Integer.class);
|
|
if(null != itemOrder){
|
item.setItemNo(itemOrder);
|
}
|
|
return item;
|
}
|
|
@RequestMapping(value = "checkDeleteNew", method = RequestMethod.POST)
|
@ResponseBody
|
public boolean checkDeleteNew(String groupId){
|
|
String[] arrId = groupId.split(",");
|
StringBuffer replaceCode = new StringBuffer(1024);
|
replaceCode.append(" ( ");
|
List<Object> lstArgs = new ArrayList<Object>(arrId.length);
|
for(int i = 0; i < arrId.length ; i++ ){
|
lstArgs.add(arrId[i]);
|
if( i == arrId.length - 1 ){
|
replaceCode.append( " ? ) ") ;
|
}else{
|
replaceCode.append(" ? , ") ;
|
}
|
}
|
|
String hql = "select count(1) from ExerciseItemAnswerU u where deleteFlag is false and exerciseItemId in " +
|
"( select i.exerciseId from ExerciseGroup g,ExerciseItem i,ExerciseGroupItemRe r where g.groupId=r.exerciseGroupId " +
|
" and i.exerciseId = r.exerciseItemId and g.groupId in " + replaceCode.toString() + " and g.deleteFlag is false and i.deleteFlag is false ) ";
|
|
int iCount = commonDAO.findCount(hql, lstArgs);
|
|
return iCount > 0 ? true : false;
|
|
}
|
|
|
/**
|
* （后台管理系统）
|
* 删除练习组(优化)
|
*
|
* 更新20150907：更新习题组最后修改时间
|
* @return
|
*/
|
@RequestMapping(value = "deleteNew", method = RequestMethod.POST)
|
@ResponseBody
|
public Result deleteNew(String groupId,String type) {
|
|
return exerciseService.deleteExerciseGroup(groupId,type,"class",null,null,null);
|
}
|
|
/**
|
* （后台管理系统）
|
* 删除练习组(优化)
|
*
|
* 更新20150907：更新习题组最后修改时间
|
* @return
|
*/
|
@RequestMapping(value = "deleteOrg", method = RequestMethod.POST)
|
@ResponseBody
|
public Result deleteOrg(String groupId,String type,Integer delAll, String orgIds[], String classIds[]) {
|
|
return exerciseService.deleteExerciseGroup(groupId,type,"org",delAll,orgIds,classIds);
|
}
|
|
|
|
/**
|
* 获取习题列表
|
*
|
* @return
|
*/
|
@RequestMapping(value = "item/data/{groupId}", method = RequestMethod.GET)
|
@ResponseBody
|
public List<ExerciseItem> listItems(@PathVariable String groupId) {
|
|
|
List<ExerciseItem> items = exerciseService.readExerciseItemsWithNo(groupId);
|
|
return items;
|
}
|
|
/**
|
* （后台管理系统）
|
* 管理员同步习题到班级
|
*
|
* @param exerciseItemId
|
* @return
|
* @throws InvocationTargetException
|
* @throws IllegalAccessException
|
*/
|
@RequestMapping(value = "/item/synExercise", method = RequestMethod.POST)
|
@ResponseBody
|
public Result synExercise(String[] exerciseIds) throws IllegalAccessException, InvocationTargetException {
|
return exerciseService.doSynExercise(exerciseIds);
|
}
|
|
/**
|
* （后台管理系统）
|
* 增加习题
|
*
|
* 更新20150617：更新习题组最后修改时间
|
* @return
|
*/
|
@RequestMapping(value = "item/addOrUpdate", method = RequestMethod.POST)
|
@ResponseBody
|
public Result addOrUpdateItem(ExerciseAddItemParams params) {
|
|
String groupId = params.getGroupId();
|
|
short type = params.getType();
|
boolean checkA = params.getCheckA();
|
boolean checkB = params.getCheckB();
|
boolean checkC = params.getCheckC();
|
boolean checkD = params.getCheckD();
|
boolean checkE = params.getCheckE();
|
boolean checkF = params.getCheckF();
|
boolean checkG = params.getCheckG();
|
boolean checkH = params.getCheckH();
|
boolean checkI = params.getCheckI();
|
boolean checkJ = params.getCheckJ();
|
boolean checkK = params.getCheckK();
|
boolean checkL = params.getCheckL();
|
boolean checkM = params.getCheckM();
|
boolean checkN = params.getCheckN();
|
boolean checkO = params.getCheckO();
|
|
List<ExerciseItemOption> lstOptions = new ArrayList<ExerciseItemOption>(8);
|
createItemOption(getOptionOrder(type,'A'),params.getOptionA(), checkA, params.getOptionA_Id(), params.getOptionA_imgIds(), lstOptions);
|
createItemOption(getOptionOrder(type,'B'),params.getOptionB(), checkB, params.getOptionB_Id(), params.getOptionB_imgIds(), lstOptions);
|
createItemOption(getOptionOrder(type,'C'),params.getOptionC(), checkC, params.getOptionC_Id(), params.getOptionC_imgIds(), lstOptions);
|
createItemOption(getOptionOrder(type,'D'),params.getOptionD(), checkD, params.getOptionD_Id(), params.getOptionD_imgIds(), lstOptions);
|
createItemOption(getOptionOrder(type,'E'),params.getOptionE(), checkE, params.getOptionE_Id(), params.getOptionE_imgIds(), lstOptions);
|
createItemOption(getOptionOrder(type,'F'),params.getOptionF(), checkF, params.getOptionF_Id(), params.getOptionF_imgIds(), lstOptions);
|
createItemOption(getOptionOrder(type,'G'),params.getOptionG(), checkG, params.getOptionG_Id(), params.getOptionG_imgIds(), lstOptions);
|
createItemOption(getOptionOrder(type,'H'),params.getOptionH(), checkH, params.getOptionH_Id(), params.getOptionH_imgIds(), lstOptions);
|
createItemOption(getOptionOrder(type,'I'),params.getOptionI(), checkI, params.getOptionI_Id(), params.getOptionI_imgIds(), lstOptions);
|
createItemOption(getOptionOrder(type,'J'),params.getOptionJ(), checkJ, params.getOptionJ_Id(), params.getOptionJ_imgIds(), lstOptions);
|
createItemOption(getOptionOrder(type,'K'),params.getOptionK(), checkK, params.getOptionK_Id(), params.getOptionK_imgIds(), lstOptions);
|
createItemOption(getOptionOrder(type,'L'),params.getOptionL(), checkL, params.getOptionL_Id(), params.getOptionL_imgIds(), lstOptions);
|
createItemOption(getOptionOrder(type,'M'),params.getOptionM(), checkM, params.getOptionM_Id(), params.getOptionM_imgIds(), lstOptions);
|
createItemOption(getOptionOrder(type,'N'),params.getOptionN(), checkN, params.getOptionN_Id(), params.getOptionN_imgIds(), lstOptions);
|
createItemOption(getOptionOrder(type,'O'),params.getOptionO(), checkO, params.getOptionO_Id(), params.getOptionO_imgIds(), lstOptions);
|
|
// 得到正确答案
|
if(StringUtils.isBlank(params.getOptionE())){
|
checkE=false;
|
}
|
if(StringUtils.isBlank(params.getOptionF())){
|
checkF=false;
|
}
|
|
String answer = getCorrectAnswer(params, type);
|
|
if(StringUtils.isEmpty(params.getExerciseId())){
|
ExerciseItem item = new ExerciseItem();
|
item.setAnswer(answer);
|
item.setTitle(params.getTitle());
|
item.setType(type);
|
item.setImgs(getExerciseTitleImgs(params.getTitle_imgsIds()));
|
if(groupId.contains("#")){// groupid结尾多#
|
groupId = groupId.substring(0, groupId.indexOf('#'));
|
}
|
// 练习不发系统通知
|
//sendSysNotice(0, groupId);
|
return exerciseService.insertExerciseItem(groupId, item, lstOptions,params.getAnalysis());
|
}else{
|
ExerciseItem item = this.commonDAO.read(ExerciseItem.class, params.getExerciseId());
|
item.setAnswer(answer);
|
item.setTitle(params.getTitle());
|
item.setType(type);
|
// 练习不发系统通知
|
//sendSysNotice(1, groupId);
|
return exerciseService.updateExerciseItem(item, lstOptions,params.getAnalysis());
|
}
|
|
}
|
|
|
/**
|
* 得到正确答案
|
* @param checkA
|
* @param checkB
|
* @param checkC
|
* @param checkD
|
* @param checkE
|
* @param checkF
|
* @return
|
*/
|
private String getCorrectAnswer(ExerciseAddItemParams params,short type){
|
StringBuffer answer = new StringBuffer(64);
|
|
if(ExerciseItem.TYPE_TRUE_OR_FALSE==type){//判断
|
return params.getCheckA()?"True":params.getCheckB()?"False":null;
|
}
|
|
if(params.getCheckA()){
|
answer.append('A');
|
}
|
if(params.getCheckB()){
|
answer.append(',').append('B');
|
}
|
|
// 组装余下正确答案
|
packagingCorrectAnswer(params, answer);
|
|
String answers = answer.toString();
|
|
if(answers.indexOf(',') == 0){
|
answers = answers.substring(1, answers.length());
|
}
|
|
return answers;
|
}
|
|
/**
|
* 组装正确答案
|
* @param checkC
|
* @param checkD
|
* @param checkE
|
* @param checkF
|
* @param answer
|
*/
|
private void packagingCorrectAnswer(ExerciseAddItemParams params, StringBuffer answer) {
|
if(params.getCheckC()){
|
answer.append(',').append('C');
|
}
|
if(params.getCheckD()){
|
answer.append(',').append('D');
|
}
|
if(params.getCheckE()){
|
answer.append(',').append('E');
|
}
|
if(params.getCheckF()){
|
answer.append(',').append('F');
|
}
|
if(params.getCheckG()){
|
answer.append(',').append('G');
|
}
|
if(params.getCheckH()){
|
answer.append(',').append('H');
|
}
|
packagingCorrectAnswerFirst(params, answer);
|
}
|
|
/**
|
* 组装正确答案
|
* @param checkC
|
* @param checkD
|
* @param checkE
|
* @param checkF
|
* @param answer
|
*/
|
private void packagingCorrectAnswerFirst(ExerciseAddItemParams params, StringBuffer answer) {
|
if(params.getCheckI()){
|
answer.append(',').append('I');
|
}
|
if(params.getCheckJ()){
|
answer.append(',').append('J');
|
}
|
if(params.getCheckK()){
|
answer.append(',').append('K');
|
}
|
if(params.getCheckL()){
|
answer.append(',').append('L');
|
}
|
if(params.getCheckM()){
|
answer.append(',').append('M');
|
}
|
if(params.getCheckN()){
|
answer.append(',').append('N');
|
}
|
if(params.getCheckO()){
|
answer.append(',').append('O');
|
}
|
}
|
|
/**
|
* 得到练习题目图片list
|
* @param title_imgsIds
|
* @return
|
*/
|
private List<ExerciseObjectImg> getExerciseTitleImgs(String title_imgsIds){
|
if(StringUtils.isBlank(title_imgsIds)){//新增图片
|
return null;
|
}
|
String[] strImgsId = title_imgsIds.split(",");
|
List<ExerciseObjectImg> imgs = new ArrayList<ExerciseObjectImg>(strImgsId.length);
|
ExerciseObjectImg objImg = null;
|
for(String imgId:strImgsId){
|
objImg = new ExerciseObjectImg();
|
objImg.setImgId(imgId);
|
imgs.add(objImg);
|
}
|
return imgs;
|
}
|
|
/**
|
* 创建习题选项
|
* @param option
|
* @param check
|
* @param lstOptions
|
*/
|
private void createItemOption(String optionOrder,String option_t, boolean check, String optionId,
|
String imgsId, List<ExerciseItemOption> lstOptions) {
|
String option = option_t;
|
|
if("True".equals(optionOrder) || "False".equals(optionOrder)){
|
option = optionOrder;
|
}
|
|
ExerciseItemOption a = new ExerciseItemOption();
|
if(StringUtils.isNotBlank(optionId)){// 更新
|
a.setOptionId(optionId);
|
}else{
|
if(StringUtils.isEmpty(option)){
|
return;
|
}
|
}
|
|
if(StringUtils.isNotBlank(imgsId)){//新增图片
|
String[] strImgsId = imgsId.split(",");
|
List<ExerciseObjectImg> imgs = new ArrayList<ExerciseObjectImg>(strImgsId.length);
|
ExerciseObjectImg objImg = null;
|
for(String imgId:strImgsId){
|
objImg = new ExerciseObjectImg();
|
objImg.setImgId(imgId);
|
imgs.add(objImg);
|
}
|
a.setImgs(imgs);
|
}
|
a.setChecked(check);
|
a.setContent(option);
|
a.setOptionOrder(optionOrder);
|
lstOptions.add(a);
|
}
|
|
|
private String getOptionOrder(short type,char order){
|
|
if(ExerciseItem.TYPE_TRUE_OR_FALSE==type){
|
return order=='A'?"True":order=='B'?"False":null;
|
}else{
|
return String.valueOf(order);
|
}
|
|
}
|
|
/**
|
* 更新习题
|
*
|
* @return
|
*/
|
@RequestMapping(value = "item/update", method = RequestMethod.POST)
|
@ResponseBody
|
public Result updateItem(ExerciseItem item) {
|
return null;
|
}
|
|
/**
|
* （后台管理）
|
* 删除习题
|
* 更新20150617：更新习题组最后修改时间
|
*
|
* @return
|
*/
|
@RequestMapping(value = "item/delete", method = RequestMethod.POST)
|
@ResponseBody
|
public Result delItem(String exerciseIds,String reIds,String groupId) {
|
return exerciseService.deleteExerciseItems(exerciseIds.split(","),reIds.split(","),groupId);
|
}
|
|
/**
|
* 根据classID获取所有课程
|
*
|
* @return
|
*/
|
@RequestMapping(value = "listLesson", method = RequestMethod.POST)
|
public @ResponseBody List<SchClassSubject> getLessionList() {
|
|
String hql = "from SchClassSubject where classId = ? and deleteFlag is false ";
|
|
List<SchClassSubject> result = commonDAO.find(hql, CollectionUtils.newList(ClientUtils.getClassId()), SchClassSubject.class);
|
|
return result;
|
}
|
|
/**
|
* 获取组名称
|
*
|
* @return
|
*/
|
@RequestMapping(value = "getGroupName", method = RequestMethod.POST)
|
public @ResponseBody List<Map<String,Object>> getGroupName(String groupId) {
|
|
ExerciseGroup group = commonDAO.read(ExerciseGroup.class, groupId);
|
List<Map<String,Object>> lstMap = new ArrayList<Map<String,Object>>(1);
|
Map<String,Object> map = null;
|
|
if(group.getType() == ExerciseGroup.TYPE_CHAPTER_ITEM || group.getType() == ExerciseGroup.TYPE_EXERCISE_TOPIC || group.getType() == ExerciseGroup.TYPE_EXERCISE_EXAM){ // 章节练习 、 专项练习
|
map = new HashMap<String, Object>(7);
|
map.put("groupId", group.getGroupId());
|
map.put("name", group.getName());
|
map.put("type", group.getType());
|
map.put("subjectId", group.getSubjectId());
|
map.put("chapterId", group.getAttribute2());
|
lstMap.add(map);
|
return lstMap;
|
}
|
String hql = "select e,eg from ExerciseGroup e,ExerciseGroupExtend eg "
|
+ "where e.deleteFlag is false and eg.deleteFlag is false "
|
+ "and e.groupId = eg.groupId and e.groupId = ? ";
|
List<Object[]> result = this.commonDAO.findwithRawResult(hql, CollectionUtils.newList(groupId));
|
|
for (Object[] obj : result) {
|
group = (ExerciseGroup) obj[0];
|
ExerciseGroupExtend groupExtend = (ExerciseGroupExtend) obj[1];
|
map = new HashMap<String, Object>(7);
|
map.put("groupId", group.getGroupId());
|
map.put("name", group.getName());
|
map.put("type", group.getType());
|
map.put("subjectId", group.getSubjectId());
|
|
map.put("exerciseTime", groupExtend.getExerciseTime());
|
map.put("repeatFlag", groupExtend.getRepeatFlag());
|
lstMap.add(map);
|
|
}
|
return lstMap;
|
}
|
|
/**
|
* 编辑练习保存
|
*
|
* @return
|
*/
|
@RequestMapping(value = "editGroup", method = RequestMethod.POST)
|
public @ResponseBody Result saveEditGroup(String groupId,String groupName) {
|
|
return exerciseService.doSaveEditGroup(groupId, groupName);
|
}
|
|
/**
|
* 根据lessionId获取所有章节,排除掉当前班级
|
*
|
* @return
|
*/
|
@RequestMapping(value = "listChapter", method = RequestMethod.POST)
|
public @ResponseBody List<ExerciseChapter> getChapterList(
|
@RequestParam(value = "classSubjectId") String classSubjectId, short type) {
|
|
String hql = "from ExerciseChapter where classSubjectId = ? and deleteFlag is false ";
|
List<Object> lstArgs = CollectionUtils.newList(classSubjectId);
|
if(ExerciseGroup.TYPE_EXERCISE_SEQUENCE == type){
|
hql = " from ExerciseChapter where classSubjectId = ? and deleteFlag is false and chapterId not in "
|
+ " ( select attribute2 from ExerciseGroup where deleteFlag is false and classId = ? and attribute1 = ? ) ";
|
lstArgs = CollectionUtils.newList(classSubjectId,ClientUtils.getClassId(),classSubjectId);
|
}
|
|
List<ExerciseChapter> result = commonDAO.find(hql, lstArgs , ExerciseChapter.class);
|
|
return result;
|
}
|
|
/**
|
* 根据classID获取顺序练习
|
*
|
* @return
|
*/
|
@RequestMapping(value = "listOrderExercise", method = RequestMethod.POST)
|
public @ResponseBody List<ClsClass> getOrderExerciseCount() {
|
|
String hql = "from ExerciseGroup where classId = ? and type = ? and deleteFlag is false";
|
|
int result = commonDAO.findCount(hql, CollectionUtils.newList(ClientUtils.getClassId(),ExerciseGroup.TYPE_EXERCISE_SEQUENCE));
|
List<ClsClass> lstResult = new ArrayList<ClsClass>();
|
//存在顺序练习，将班级信息传回
|
if( result > 0){
|
hql = "from ClsClass where classId = ? ";
|
lstResult = commonDAO.find(hql, CollectionUtils.newList(ClientUtils.getClassId()), ClsClass.class);
|
}
|
|
return lstResult;
|
}
|
|
/**
|
* 根据classID获取顺序练习
|
*
|
* @return
|
*/
|
@RequestMapping(value = "checkChapterRepetition", method = RequestMethod.POST)
|
public @ResponseBody String checkChapterRepetition(
|
@RequestParam(value = "classSubjectId") String classSubjectId,
|
@RequestParam(value = "chapterId") String chapterId) {
|
|
String hql = "from ExerciseGroup where classId = ? and type = ? and attribute1 = ? and attribute2 = ? and deleteFlag is false ";
|
int result = commonDAO.findCount(hql, CollectionUtils.newList(ClientUtils.getClassId(),ExerciseGroup.TYPE_CHAPTER_ITEM,classSubjectId,chapterId));
|
|
return result > 0 ? "1" : "0";
|
}
|
|
/**
|
* 新增练习
|
*
|
* @return
|
*/
|
@RequestMapping(value = "addExercise", method = RequestMethod.POST)
|
public @ResponseBody
|
Result addExercise(String groupId,String name,short type,String subjectId,String chapterId,String attribute1,boolean repeatFlag) {
|
return exerciseService.insertExerciseGroup(groupId,name,type,subjectId,chapterId,attribute1,repeatFlag);
|
}
|
|
/**
|
* 机构新增练习
|
*
|
* @return
|
*/
|
@RequestMapping(value = "addOrgExercise", method = RequestMethod.POST)
|
public @ResponseBody
|
Result addOrgExercise(ExerciseGroup group, boolean repeatFlag) {
|
return exerciseService.insertOrgExercise(group,repeatFlag);
|
}
|
|
/**
|
* 机构指定练习
|
*
|
* @return
|
*/
|
@RequestMapping(value = "OrgExercise", method = RequestMethod.POST)
|
public @ResponseBody
|
Result addOrgExercise(String groupId [],String orgId[],String classIds[]) {
|
return exerciseService.insertAppointExercise(groupId,orgId,classIds);
|
}
|
|
/**
|
* ORG 获取机构科目列表
|
*
|
* @return
|
*/
|
@RequestMapping(value = "/orgCourse", method = RequestMethod.GET)
|
public @ResponseBody
|
List<OrgCollegeCourse> orgCollegeCourse() {
|
|
String hql = " from OrgCollegeCourse where topOrgId = ? and deleteFlag is false";
|
|
Organization org = commonDAO.read(Organization.class, ClientUtils.getOrgId());
|
|
List<OrgCollegeCourse> result = this.commonDAO.find(hql, CollectionUtils.newList(org.getTopOrganizationId()), OrgCollegeCourse.class);
|
|
return result;
|
|
}
|
|
/**
|
* 新增图片路径到数据库
|
* @param fullPaths
|
* @param imgObjId
|
* @param imgObjType
|
* @return
|
*/
|
@RequestMapping(value = "addExerObjImg",method = RequestMethod.POST)
|
public @ResponseBody List<Map<String,Object>> doAddExerciseObjImg(
|
@RequestParam("fullPaths") String fullPaths,
|
@RequestParam("imgObjId") String imgObjId,
|
@RequestParam("imgObjType") int imgObjType){
|
|
if(StringUtils.isBlank(fullPaths)){
|
return null;
|
}
|
String[] imgPaths = fullPaths.split(";");
|
|
// 更新路径到数据库
|
List<Map<String,Object>> lstResult = exerciseService.doAddExerciseObjImg(imgPaths, imgObjId, imgObjType);
|
|
return lstResult;
|
}
|
|
/** 新增图片路径到数据库 */
|
@RequestMapping(value = "delExerObjImg",method = RequestMethod.POST)
|
public @ResponseBody Result dodelExerciseObjImg(
|
@RequestParam("imgId") String imgId){
|
|
Result result = exerciseService.dodelExerciseObjImg(imgId);
|
|
return result;
|
}
|
|
/** 查询图片路径 */
|
@RequestMapping(value = "queryExerObjImg",method = RequestMethod.POST)
|
public @ResponseBody List<Map<String,Object>> doQueryExerciseObjImg(
|
@RequestParam("imgObjId") String imgObjId,
|
@RequestParam("imgObjType") int imgObjType){
|
if(StringUtils.isBlank(imgObjId)){
|
return null;
|
}
|
String hql = "from ExerciseObjectImg where deleteFlag is false and exerciseObjectId=? and objectType=? order by imgOrder";
|
// 查询此练习是否已经存在记录
|
List<ExerciseObjectImg> lstObjImg = commonDAO.find(hql,
|
CollectionUtils.newList(imgObjId,imgObjType), ExerciseObjectImg.class);
|
|
if(lstObjImg.isEmpty()){
|
return null;
|
}
|
List<Map<String,Object>> lstResult = new ArrayList<Map<String,Object>>(lstObjImg.size());
|
Map<String,Object> resultMap = null;
|
for(ExerciseObjectImg obj:lstObjImg){
|
resultMap = new HashMap<String,Object>(2);
|
resultMap.put("imgId", obj.getImgId());
|
resultMap.put("imgPath", obj.getImgPath());
|
lstResult.add(resultMap);
|
}
|
|
return lstResult;
|
}
|
|
/**
|
* （后台管理系统:导入习题模块）
|
* 导入习题-习题导入深度解析
|
*
|
* @param groupId 习题组ID
|
* @param uuid uuid
|
* @param fileName 文件名称
|
* @return
|
*/
|
@RequestMapping(value = "/item/deepAnalysisDoc", method = RequestMethod.POST)
|
@ResponseBody
|
public Result deepAnalysisDoc(String groupId,String fullPath) {
|
|
return exerciseService.doDeepAnalysisDoc(groupId,fullPath);
|
|
}
|
|
|
/**
|
* （后台管理系统:导入习题模块）
|
* 导入习题-第一次将word解析结果返回给前台，并不保存到数据库
|
*
|
* @param groupId 习题组ID
|
* @param uuid uuid
|
* @param fileName 文件名称
|
* @return
|
*/
|
@RequestMapping(value = "/item/import/parser/{groupId}", method = RequestMethod.POST)
|
@ResponseBody
|
public ExerciseParseResult importItemsNew(@PathVariable String groupId,String fullPath,String module) {
|
|
return exerciseService.doParseItems(groupId, fullPath , module);
|
|
}
|
|
/**
|
* （后台管理系统:导入习题模块）
|
* 校验内容，返回解析结果
|
*
|
* @param content 文本内容
|
* @return
|
*/
|
@RequestMapping(value = "/item/import/validateExercise", method = RequestMethod.POST)
|
@ResponseBody
|
public ExerciseParseResult validateExercise(String content) {
|
|
return exerciseService.validateExercise(content);
|
}
|
|
/**
|
* 获取所有班级，当前班级除外,增加过滤没有习题的班级
|
* @return
|
*/
|
@RequestMapping(value = "loadClasses", method = RequestMethod.GET)
|
public @ResponseBody List<ClsClass> loadClasses() {
|
|
String hql = "select distinct cls from ClsClass cls,OrgCharger charge, ExerciseGroup g " +
|
" where cls.classChargerId = charge.orgChargerId " +
|
" and cls.classId = g.classId " +
|
" and g.deleteFlag is false " +
|
" and g.type != ? " +
|
" and g.type != ? " +
|
" and g.type != ? " +
|
" and g.type != ? " +
|
" and charge.userId = ? " +
|
" and cls.classId <> ? " +
|
" and charge.orgId = ? " +
|
" and cls.deleteFlag is false";
|
|
return commonDAO.find(hql, CollectionUtils.newList(
|
ExerciseGroup.TYPE_EXERCISE_RANDOM,ExerciseGroup.TYPE_EXERCISE_SEQUENCE,
|
ExerciseGroup.TYPE_INTERACT,ExerciseGroup.TYPE_EXERCISE_TEACH_EVALUATE,
|
ClientUtils.getUserId(),ClientUtils.getClassId(),ClientUtils.getOrgId()), ClsClass.class);
|
}
|
|
/**
|
* 复制习题
|
* @param fromClassId
|
* @return
|
*/
|
@RequestMapping(value = "copyExercise", method = RequestMethod.POST)
|
public @ResponseBody Result copyExercise(String groupId, String subjectId, String subjectName, String chapterId) {
|
|
return exerciseService.executeCopyExercise(groupId, subjectId, subjectName, chapterId);
|
|
}
|
|
/**
|
* 学员得分详情列表
|
* @param groupId
|
* @return
|
*/
|
@RequestMapping(value = "resultList/{groupId}", method = RequestMethod.GET)
|
public @ResponseBody List<Map<String, Object>> resultList(@PathVariable String groupId) {
|
|
List<Map<String, Object>> lstMap = exerciseService.resultList(groupId);
|
|
return lstMap;
|
|
}
|
|
/**
|
* 初始化平均成绩和最高成绩
|
* @param groupId
|
* @return
|
*/
|
@RequestMapping(value = "initScore/{groupId}", method = RequestMethod.GET)
|
public @ResponseBody Map<String, Object> initScore(@PathVariable String groupId) {
|
|
Map<String, Object> map = exerciseService.initScore(groupId);
|
|
return map;
|
}
|
|
/**
|
* 每道题得分详情
|
* @param groupId
|
* @return
|
*/
|
@RequestMapping(value = "itemDetailList/{groupId}", method = RequestMethod.GET)
|
public @ResponseBody List<ExerciseItemStatistics> scoreDetail(@PathVariable String groupId) {
|
|
List<ExerciseItemStatistics> itemStatisLst = exerciseService.itemDetailList(groupId);
|
|
return itemStatisLst;
|
}
|
|
/**
|
* 加载题目选项详情 - 班级、机构
|
* @param groupId
|
* @return
|
*/
|
@RequestMapping(value = "loadOptionsList", method = RequestMethod.GET)
|
public @ResponseBody List<Map<String,Object>> loadOptionsList( String exerciseItemId) {
|
|
List<Map<String,Object>> map = exerciseService.loadOptionsList(exerciseItemId);
|
|
return map;
|
}
|
|
/**
|
* 刷新更新统计
|
* @param groupId
|
* @return
|
*/
|
@RequestMapping(value = "refreshStatistical/{groupId}", method = RequestMethod.GET)
|
public @ResponseBody Result refreshStatistical(@PathVariable String groupId) {
|
|
Result result = exerciseVerService.updateRefreshStatistical(groupId,ClientUtils.getOrgId() ,ClientUtils.getClassId(),Constants.BOOLEAN_FLAG_FALSE);
|
|
return result;
|
}
|
|
/**
|
* 导出练习每道题得分详情
|
*
|
* @return
|
* @throws IOException
|
*/
|
@RequestMapping(value = "itemStatis/data/{groupId}", method = RequestMethod.GET)
|
public String exportItemStatis(@PathVariable String groupId,HttpServletResponse response) throws IOException {
|
ExerciseGroup exeGroup= this.commonDAO.read(ExerciseGroup.class, groupId);
|
|
//获取每道题得分详情列表
|
List<ExerciseItemStatistics> itemStatisLst = exerciseService.itemDetailList(groupId);
|
|
ExcelExportUtils<ExerciseItemStatistics> ex = new ExcelExportUtils<ExerciseItemStatistics>();
|
ExcelExportParam<ExerciseItemStatistics> obj = new ExcelExportParam<ExerciseItemStatistics>();
|
obj.setColData(itemStatisLst);
|
String[] headers = { "序号","题号","题目", "类型", "正确答案","班级正确率","全站正确率"};
|
|
obj.setHeaders(headers);
|
obj.setLstColumn(new ArrayList<String>(Arrays.asList("itemNo","exerciseItemTitel","itemTypeName","correctAnswer","classAccuracyShow","orgAccuracyShow")));
|
obj.setPattern("yyyy-MM-dd HH:mm");
|
|
response.reset();
|
response.setContentType("application/vnd.ms-excel;charset=utf-8");
|
response.setHeader("Content-Disposition", "attachment;filename="+ new String((ClientUtils.getClassName()+ "_" + exeGroup.getName() + "_详情.xls").getBytes(), "iso-8859-1"));
|
response.setCharacterEncoding("utf-8");
|
OutputStream ouputStream = response.getOutputStream();
|
obj.setOut(ouputStream);
|
ex.exportExcelByColomn(obj);
|
ouputStream.flush();
|
ouputStream.close();
|
|
return null;
|
}
|
|
/**
|
* 导出练习学员得分详情
|
*
|
* @return
|
* @throws IOException
|
*/
|
@RequestMapping(value = "userScoreStatis/data/{groupId}", method = RequestMethod.GET)
|
public String exportUserScore(@PathVariable String groupId,HttpServletResponse response) throws IOException {
|
// 获取组名称
|
ExerciseGroup exeGroup= this.commonDAO.read(ExerciseGroup.class, groupId);
|
|
// 获取之前组装的排名List<Map<String, Object>>列表
|
List<Map<String, Object>> userScoreMap = exerciseService.resultList(groupId);
|
List<ExportUserScore> userLst = new ArrayList<ExportUserScore>(userScoreMap.size());
|
ExportUserScore user = null;
|
|
if(userScoreMap != null){
|
// 将获取的Map列表转换为List列表
|
for(Map<String, Object> userScore:userScoreMap){
|
user = new ExportUserScore();
|
user.setName(String.valueOf(userScore.get("name")));
|
user.setMobilePhone(String.valueOf(userScore.get("mobilePhone")));
|
user.setScore(new BigDecimal(String.valueOf( userScore.get("accuracy"))));
|
user.setSubmitTime((Date)userScore.get("time"));
|
user.setSalesCode(String.valueOf(userScore.get("salesCode")));
|
user.setCreateTime((Date)userScore.get("createTime"));
|
userLst.add(user);
|
}
|
|
ExcelExportUtils<ExportUserScore> ex = new ExcelExportUtils<ExportUserScore>();
|
ExcelExportParam<ExportUserScore> obj = new ExcelExportParam<ExportUserScore>();
|
obj.setColData(userLst);
|
String[] headers = { "排名","学员姓名","报名码","报名时间","手机号码", "提交时间", "成绩"};
|
|
obj.setHeaders(headers);
|
obj.setLstColumn(new ArrayList<String>(Arrays.asList("name","salesCode","createTime","mobilePhone","submitTime","score")));
|
obj.setPattern("yyyy-MM-dd HH:mm");
|
|
response.reset();
|
response.setContentType("application/vnd.ms-excel;charset=utf-8");
|
response.setHeader("Content-Disposition", "attachment;filename="+ new String((ClientUtils.getClassName() + "_" + exeGroup.getName() + "_成绩.xls").getBytes(), "iso-8859-1"));
|
response.setCharacterEncoding("utf-8");
|
OutputStream ouputStream = response.getOutputStream();
|
obj.setOut(ouputStream);
|
ex.exportExcelByColomn(obj);
|
ouputStream.flush();
|
ouputStream.close();
|
}
|
|
return null;
|
}
|
|
|
|
/**
|
* 习题组排序
|
*
|
* @param key
|
* @return
|
*/
|
@RequestMapping(value = "/order", method=RequestMethod.POST)
|
public @ResponseBody Result order(@RequestParam("ids[]") List<String> ids, @RequestParam("index[]") List<Integer> index){
|
exerciseService.doOrder(ids, index);
|
return new Result(true) ;
|
}
|
|
/**
|
* 习题排序
|
*
|
* @param key
|
* @return
|
*/
|
@RequestMapping(value = "/item/order", method=RequestMethod.POST)
|
public @ResponseBody Result itemOrder(@RequestParam("ids[]") List<String> ids, @RequestParam("index[]") List<Integer> index, @RequestParam("groupId") String groupId){
|
exerciseService.doitemOrder(ids, index,groupId);
|
return new Result(true) ;
|
}
|
|
|
|
/******************************************py导入******************************************************************/
|
/**
|
* （后台管理系统:导入习题模块）
|
* 导入习题-第一次将word解析结果返回给前台，并不保存到数据库
|
*
|
* @param groupId 习题组ID
|
* @param uuid uuid
|
* @param fileName 文件名称
|
* @return
|
*/
|
@RequestMapping(value = "/item/importpy/parse/{groupId}", method = RequestMethod.POST)
|
public @ResponseBody Map<String,Object> importItemsPy(@PathVariable String groupId,String fullPath,String module) {
|
|
return exercisePyService.parserPyExercise(groupId, fullPath, module);
|
|
}
|
|
/**
|
* （后台管理系统:导入习题模块）
|
* 校验内容，返回解析结果
|
*
|
* @param content 文本内容
|
* @return
|
*/
|
@RequestMapping(value = "/item/importpy/validate", method = RequestMethod.POST)
|
public @ResponseBody Map<String, Object> validatePyExercise(String content) {
|
|
return exercisePyService.validatePyExercise(content);
|
}
|
|
/**
|
* （后台管理系统:导入习题模块）
|
* 导入内容，返回解析结果
|
*
|
* @param content 文本内容
|
* @return
|
*/
|
@SuppressWarnings("unchecked")
|
@RequestMapping(value = "/item/importpy/import", method = RequestMethod.POST)
|
public @ResponseBody Result importPyExercise(@RequestParam(value = "data") String data,@RequestParam(value = "groupId") String groupId) {
|
|
ObjectMapper mapper = new ObjectMapper();
|
JavaType javaType = mapper.getTypeFactory().constructParametricType(List.class, ExerciseItemData.class);
|
|
try {
|
|
List<ExerciseItemData> lst = (List<ExerciseItemData>)mapper.readValue(data, javaType);
|
return exercisePyService.doImportPyExercise(lst,groupId);
|
|
} catch (Exception e) {
|
log.error("提交数据有误" + e );
|
}
|
|
return new Result(false,"解析json失败");
|
}
|
|
|
|
|
/**----------------- 问卷调查----start-----------------------------------*/
|
/**
|
* 评估模块添加问答
|
*
|
* @param jsonExerciseItemDTO
|
* @return
|
*/
|
@RequestMapping(value = "item/addOrUpdate4Evaluate", method = RequestMethod.POST, produces="application/json;charset=UTF-8")
|
@ResponseBody
|
public ResultJson addOrUpdate4Evaluate(@RequestBody String jsonExerciseItemDTO) {
|
JSONObject jsonObject = (JSONObject) JSON.parse(jsonExerciseItemDTO);
|
String groupId = jsonObject.getString(GROUP_ID);
|
String exerciseId = jsonObject.getString("exerciseId");
|
String title = jsonObject.getString("title");
|
boolean mustAnswer = jsonObject.getBooleanValue("mustAnswer");
|
short type = jsonObject.getShort("type");
|
String analysis = jsonObject.getString("analysis");
|
JSONArray titleImgs = jsonObject.getJSONArray("imags");// 题目的图片路径
|
|
//获取选项
|
List<ExerciseItemOption> lstOptions = JSONArray.parseArray(jsonObject.getString("lstOptions"), ExerciseItemOption.class);
|
ExerciseItem item = null;
|
|
if(StringUtils.isEmpty(exerciseId)){// 新增
|
item = new ExerciseItem();
|
item.setTitle(title);
|
item.setType(type);
|
item.setMustAnswer(mustAnswer);
|
exerciseService.insertExerciseItem4Evaluate(groupId, item, lstOptions,analysis,titleImgs);
|
}else{// 编辑
|
item = this.commonDAO.read(ExerciseItem.class, exerciseId);
|
item.setTitle(title);
|
item.setType(type);
|
item.setMustAnswer(mustAnswer);
|
return exerciseService.updateExerciseItem4Evaluate(item, lstOptions,analysis);
|
}
|
|
return new ResultJson(true,"success",
|
CollectionUtils.newObjectMap("exerciseId",item.getExerciseId(),
|
"lstOptions",lstOptions));
|
}
|
|
|
/**
|
* 获取问卷习题列表
|
*
|
* @return
|
*/
|
@RequestMapping(value = "item/data4Evaluate/{groupId}", method = RequestMethod.GET)
|
@ResponseBody
|
public ResultJson listItems4Evaluate(@PathVariable String groupId) {
|
|
return new ResultJson(true,"success",
|
exerciseService.readExerciseItems4Evaluate(groupId));
|
}
|
|
/**
|
* 查看学员答卷情况
|
*
|
* @param recordId 答题记录id
|
* @param schEvaluateId
|
* @return
|
*/
|
@RequestMapping(value = "evaluate/userExerciseDetail", method = RequestMethod.GET)
|
public @ResponseBody ResultJson queryUserEvaExerciseDetail(String recordId,String evaluateId) {
|
|
return exerciseService.queryUserEvaExerciseDetail(recordId, evaluateId);
|
}
|
|
/** 查询图片路径 */
|
@RequestMapping(value = "evaluate/queryExerObjImg",method = RequestMethod.GET)
|
public @ResponseBody ResultJson queryEvaExerciseObjImg(
|
@RequestParam("imgObjId") String imgObjId,
|
@RequestParam("imgObjType") int imgObjType){
|
|
if(StringUtils.isBlank(imgObjId)){
|
return new ResultJson(false,"参数为空");
|
}
|
|
List<Map<String,Object>> lstResult = exerciseService.queryEvaExerciseObjImg(imgObjId, imgObjType);
|
|
return new ResultJson(true,"success",lstResult);
|
}
|
|
/**
|
* 新增图片路径到数据库
|
* @param fullPaths
|
* @param imgObjId
|
* @param imgObjType
|
* @return
|
*/
|
@RequestMapping(value = "evaluate/addExerObjImg",method = RequestMethod.POST)
|
public @ResponseBody ResultJson doAddEvaExerciseObjImg(
|
@RequestParam("fullPaths") String fullPaths,
|
@RequestParam("imgObjId") String imgObjId,
|
@RequestParam("imgObjType") int imgObjType){
|
|
if(StringUtils.isBlank(fullPaths)){
|
return null;
|
}
|
String[] imgPaths = fullPaths.split(";");
|
|
// 更新路径到数据库
|
List<Map<String,Object>> lstResult = exerciseService.doAddEvaExerciseObjImg(imgPaths, imgObjId, imgObjType);
|
|
return new ResultJson(true,"success",lstResult);
|
}
|
|
/** 删除图片路径到数据库 */
|
@RequestMapping(value = "evaluate/delExerObjImg",method = RequestMethod.POST)
|
public @ResponseBody ResultJson dodelEvaExerciseObjImg(
|
@RequestParam("imgId") String imgId){
|
|
ResultJson result = exerciseService.dodelEvaExerciseObjImg(imgId);
|
|
return result;
|
}
|
/**------------------ 问卷调查----end------------------------------------*/
|
|
|
/**------------------------------ web 后端----end--------------------------------------------------------------------*/
|
|
}
|
