package com.qxueyou.scc.exercise.service.impl;
|
|
import java.lang.reflect.InvocationTargetException;
|
import java.math.BigInteger;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.Comparator;
|
import java.util.HashMap;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Random;
|
import java.util.concurrent.TimeUnit;
|
|
import org.apache.commons.lang3.ArrayUtils;
|
import org.apache.commons.lang3.StringUtils;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.data.redis.core.BoundValueOperations;
|
import org.springframework.data.redis.core.RedisTemplate;
|
import org.springframework.stereotype.Service;
|
|
import com.qxueyou.scc.base.model.Pager;
|
import com.qxueyou.scc.base.model.Result;
|
import com.qxueyou.scc.base.service.impl.CommonAppService;
|
import com.qxueyou.scc.base.util.ClientUtils;
|
import com.qxueyou.scc.base.util.CollectionUtils;
|
import com.qxueyou.scc.base.util.TraceUtils;
|
import com.qxueyou.scc.exercise.model.ExerciseGroup;
|
import com.qxueyou.scc.exercise.model.ExerciseGroupItemRe;
|
import com.qxueyou.scc.exercise.model.ExerciseItem;
|
import com.qxueyou.scc.exercise.model.ExerciseItemAnalisi;
|
import com.qxueyou.scc.exercise.model.ExerciseItemOption;
|
import com.qxueyou.scc.exercise.model.ExerciseItemScore;
|
import com.qxueyou.scc.exercise.model.ExerciseItemSet;
|
import com.qxueyou.scc.exercise.service.IExerciseGroupService;
|
import com.qxueyou.scc.exercise.util.ExerciseUtils;
|
|
/**
|
* 通知管理服务层
|
*
|
* @author kevin
|
* @createTime 2017-11-1
|
*/
|
@Service
|
public class ExerciseGroupService extends CommonAppService implements IExerciseGroupService {
|
|
@SuppressWarnings("rawtypes")
|
@Autowired
|
private RedisTemplate redisTemplate;
|
|
private static final Logger log = LoggerFactory.getLogger(ExerciseGroupService.class);
|
|
@Override
|
public int queryExerciseGroupCount(Map<String, Object> param) {
|
// TODO Auto-generated method stub
|
return 0;
|
}
|
|
@Override
|
public List<ExerciseGroup> queryExerciseGroupList(Map<String, Object> param, Pager page) {
|
// TODO Auto-generated method stub
|
return null;
|
}
|
|
@Override
|
public String addExerciseGroup(ExerciseGroup exerciseGroup) {
|
TraceUtils.setCreateTrace(exerciseGroup);
|
this.insert(exerciseGroup);
|
return exerciseGroup.getGroupId();
|
}
|
|
@Override
|
public Result deleteExerciseGroup(String[] groupIds) {
|
Result result = new Result(true);
|
if (groupIds != null && groupIds.length > 0) {
|
String hql = "update ExerciseGroup set deleteFlag = true where groupId=?";
|
result = bulkUpdateInLoop(hql, groupIds);
|
}
|
return result;
|
}
|
|
@Override
|
public Result updateExerciseGroup(ExerciseGroup param) {
|
ExerciseGroup exerciseGroup = read(ExerciseGroup.class, param.getGroupId());
|
if (exerciseGroup != null) {
|
TraceUtils.setUpdateTrace(exerciseGroup);
|
exerciseGroup.setGroupRange(ExerciseGroup.GROUP_RANGE_PRIV);
|
exerciseGroup.setSubjectId(param.getSubjectId());
|
exerciseGroup.setName(param.getName());
|
exerciseGroup.setDifficultLevel(param.getDifficultLevel());
|
}
|
return save(exerciseGroup);
|
}
|
|
@Override
|
public Result doExerciseGroupRealease(String[] groupIds) {
|
Map<String, Object> pramMap = null;
|
if (groupIds != null && groupIds.length > 0) {
|
pramMap = new HashMap<String, Object>(1);
|
pramMap.put("examIds", groupIds);
|
String hql = "from ExerciseGroup where groupId in (:groupIds)";
|
List<ExerciseGroup> lstExerciseGroup = this.findByComplexHql(hql, pramMap, ExerciseGroup.class);
|
|
for (ExerciseGroup exerciseGroup : lstExerciseGroup) {
|
if (ExerciseGroup.STATUS_DRAFT != exerciseGroup.getStatus()) {
|
return new Result(false, "只有草稿状态的题库,才能发布。");
|
}
|
exerciseGroup.setStatus(ExerciseGroup.STATUS_PUBLISHED);
|
TraceUtils.setUpdateTrace(exerciseGroup);
|
save(exerciseGroup);
|
}
|
} else {
|
return new Result(false, "没有选择要发布的题库。");
|
}
|
return new Result(true);
|
}
|
|
@Override
|
public Result doExerciseGroupRevocation(String[] examIds) {
|
Map<String, Object> pramMap = null;
|
if (examIds != null && examIds.length > 0) {
|
pramMap = new HashMap<String, Object>(1);
|
pramMap.put("examIds", examIds);
|
String hql = "from ExerciseGroup where examId in (:examIds)";
|
List<ExerciseGroup> lstExerciseGroup = this.findByComplexHql(hql, pramMap, ExerciseGroup.class);
|
for (ExerciseGroup exerciseGroup : lstExerciseGroup) {
|
if (ExerciseGroup.STATUS_DRAFT != exerciseGroup.getStatus()) {
|
return new Result(false, "只有发布状态的题库,才能撤回。");
|
}
|
exerciseGroup.setStatus(ExerciseGroup.STATUS_DRAFT);
|
TraceUtils.setUpdateTrace(exerciseGroup);
|
save(exerciseGroup);
|
}
|
} else {
|
return new Result(false, "没有选择要撤回的题库。");
|
}
|
|
return new Result(true);
|
}
|
|
@Override
|
public ExerciseGroup queryExerciseGroupDetail(String groupId) {
|
ExerciseGroup exerciseGroup = this.read(ExerciseGroup.class, groupId);
|
if(exerciseGroup!=null){
|
exerciseGroup.setItems(this.queryExerciseItemList(exerciseGroup));
|
}
|
return exerciseGroup;
|
}
|
@Override
|
public ExerciseGroup queryExerciseGroupDetail(String groupId,String batchId) {
|
ExerciseGroup exerciseGroup = this.read(ExerciseGroup.class, groupId);
|
if(exerciseGroup!=null){
|
//根据批次ID查询考试ID
|
String hql="select r.examId from ExamBatchClassRe r where r.examBatchId=?";
|
String examId = this.findUnique(hql, CollectionUtils.newList(batchId), String.class);
|
exerciseGroup.setItems(this.queryExerciseItemList(exerciseGroup,examId));
|
}
|
return exerciseGroup;
|
}
|
//补考考试获取试卷设置
|
@Override
|
public ExerciseGroup queryReExerciseGroupDetail(String groupId,String examId) {
|
ExerciseGroup exerciseGroup = this.read(ExerciseGroup.class, groupId);
|
if(exerciseGroup!=null){
|
exerciseGroup.setItems(this.queryExerciseItemList(exerciseGroup,examId));
|
}
|
return exerciseGroup;
|
}
|
|
/**
|
* 查询练习题目list
|
*
|
* @param groupId
|
* @return
|
*/
|
@SuppressWarnings("unchecked")
|
private List<ExerciseItem> queryExerciseItemList(ExerciseGroup exerciseGroup) {
|
BoundValueOperations<String, List<ExerciseItem>> boundValueOperations = redisTemplate.boundValueOps(exerciseGroup.getGroupId());
|
List<ExerciseItem> lstItems = boundValueOperations.get();
|
|
if(lstItems==null){
|
// 1.查询练习题目信息
|
StringBuffer hqlBuffer = new StringBuffer(1000);
|
hqlBuffer.append("select item from ExerciseItem item, ExerciseGroupItemRe re, ExerciseGroup g");
|
hqlBuffer.append(" where item.exerciseId=re.exerciseItemId and re.exerciseGroupId=g.groupId");
|
hqlBuffer.append(" and g.groupId = ? and item.deleteFlag is false and g.deleteFlag is false");
|
//如果是题库按照题目类型排序，其他按照题目顺序排序
|
if(exerciseGroup.getType() == ExerciseGroup.TYPE_EXERCISE_GROUP_LIB){
|
hqlBuffer.append(" and re.deleteFlag is false order by item.type, re.itemOrder");
|
}else{
|
hqlBuffer.append(" and re.deleteFlag is false order by re.itemOrder");
|
}
|
|
lstItems = this.find(hqlBuffer.toString(), CollectionUtils.newList(exerciseGroup.getGroupId()), ExerciseItem.class);
|
|
// 为空
|
if (lstItems.isEmpty()) {
|
return lstItems;
|
}
|
|
// 组装选项，答案，解析等信息
|
lstItems = getCommonExerItemDetail(lstItems, exerciseGroup.getGroupId());
|
|
boundValueOperations.setIfAbsent(lstItems);
|
boundValueOperations.expire(30, TimeUnit.DAYS);
|
}
|
|
return lstItems;
|
}
|
private List<ExerciseItem> queryExerciseItemList(ExerciseGroup exerciseGroup,String examId) {
|
BoundValueOperations<String, List<ExerciseItem>> boundValueOperations = redisTemplate.boundValueOps(exerciseGroup.getGroupId());
|
List<ExerciseItem> lstItems = boundValueOperations.get();
|
|
if(true){
|
// 1.查询练习题目信息
|
StringBuffer hqlBuffer = new StringBuffer(1000);
|
hqlBuffer.append("select item from ExerciseItem item, ExerciseGroupItemRe re, ExerciseGroup g");
|
hqlBuffer.append(" where item.exerciseId=re.exerciseItemId and re.exerciseGroupId=g.groupId");
|
hqlBuffer.append(" and g.groupId = ? and item.deleteFlag is false and g.deleteFlag is false");
|
//如果是题库按照题目类型排序，其他按照题目顺序排序
|
if(exerciseGroup.getType() == ExerciseGroup.TYPE_EXERCISE_GROUP_LIB){
|
hqlBuffer.append(" and re.deleteFlag is false order by item.type, re.itemOrder");
|
}else{
|
hqlBuffer.append(" and re.deleteFlag is false order by re.itemOrder");
|
}
|
|
lstItems = this.find(hqlBuffer.toString(), CollectionUtils.newList(exerciseGroup.getGroupId()), ExerciseItem.class);
|
|
// 为空
|
if (lstItems.isEmpty()) {
|
return lstItems;
|
}
|
|
// 组装选项，答案，解析等信息
|
lstItems = getCommonExerItemDetail(lstItems, exerciseGroup.getGroupId(),examId);
|
|
boundValueOperations.setIfAbsent(lstItems);
|
boundValueOperations.expire(30, TimeUnit.DAYS);
|
}
|
|
return lstItems;
|
}
|
|
/**
|
* 重新组装练习题 加入分析结果
|
*
|
* @param lstItems
|
* @param exerciseGroupId
|
* @param currTitleNumber
|
* @return
|
*/
|
private List<ExerciseItem> getCommonExerItemDetail(List<ExerciseItem> lstItems, String exerciseGroupId) {
|
// 0.组装参数
|
Map<String, Object> argsMap = new HashMap<String, Object>();
|
Object[] args = new Object[lstItems.size()];
|
for (int i = 0; i < lstItems.size(); i++) {
|
args[i] = lstItems.get(i).getExerciseId();
|
}
|
argsMap.put("exerciseIds", args);
|
//查询题目得分
|
String hql_itemScores = "from ExerciseItemScore s where s.groupId=:groupId and s.exerciseItemId in (:exerciseIds) and s.deleteFlag is false order by exerciseItemId";
|
List<ExerciseItemScore> lstItemScores = this.findByComplexHql(hql_itemScores, CollectionUtils.newObjectMap("groupId",exerciseGroupId,"exerciseIds",args), ExerciseItemScore.class);
|
Map<String, List<ExerciseItemScore>> scoresMap= new HashMap<String,List<ExerciseItemScore>>(lstItemScores.size());
|
ExerciseUtils.packageExerciseItemScore(scoresMap, lstItemScores);
|
|
// 1.查询练习题目全站分析
|
String hql_analisis = "from ExerciseItemAnalisi where exerciseItemId in (:exerciseIds) and deleteFlag is false ";
|
List<ExerciseItemAnalisi> lstAnalisis = this.findByComplexHql(hql_analisis, argsMap, ExerciseItemAnalisi.class);
|
Map<String, List<ExerciseItemAnalisi>> analisiMap = new HashMap<String, List<ExerciseItemAnalisi>>(lstAnalisis.size());
|
for (ExerciseItemAnalisi analisis : lstAnalisis) {
|
if(analisiMap.containsKey(analisis.getExerciseItemId())){
|
analisiMap.get(analisis.getExerciseItemId()).add(analisis);
|
}else{
|
analisiMap.put(analisis.getExerciseItemId(),CollectionUtils.newList(ExerciseItemAnalisi.class, analisis));
|
}
|
}
|
|
// 2.查询练习题目答案选项
|
Map<String, List<ExerciseItemOption>> optionsMap = new HashMap<String, List<ExerciseItemOption>>(
|
lstItems.size());
|
Map<String, String> answerMap = new HashMap<String, String>();
|
String hql_options = "from ExerciseItemOption where exerciseItemId in (:exerciseIds) and deleteFlag is false order by exerciseItemId, optionOrder ";
|
List<ExerciseItemOption> lstAllOptions = this.findByComplexHql(hql_options, argsMap, ExerciseItemOption.class);
|
|
// 重新组装练习
|
ExerciseUtils.packageExerciseItem(optionsMap, answerMap, lstAllOptions, null);
|
|
String exerciseId = null;
|
for (ExerciseItem item : lstItems) {
|
|
// 4.0 分析结果
|
exerciseId = item.getExerciseId();
|
|
// 得到练习组id
|
if (StringUtils.isNotBlank(exerciseGroupId)) {
|
item.setExerciseGroupId(exerciseGroupId);
|
}
|
|
// 4.3 题目选项
|
item.setOptions(optionsMap.get(exerciseId));
|
|
item.setAnalisisResult(null);
|
item.setAnalysises(null);
|
item.setAnalysises(analisiMap.get(exerciseId));
|
|
//组装练习题目
|
item.setScores(scoresMap.get(exerciseId));
|
}
|
|
return lstItems;
|
}
|
/**
|
* 重新组装练习题 加入分析结果
|
*
|
* @param lstItems
|
* @param exerciseGroupId
|
* @param currTitleNumber
|
* @return
|
*/
|
private List<ExerciseItem> getCommonExerItemDetail(List<ExerciseItem> lstItems, String exerciseGroupId,String examId) {
|
// 0.组装参数
|
Map<String, Object> argsMap = new HashMap<String, Object>();
|
Object[] args = new Object[lstItems.size()];
|
for (int i = 0; i < lstItems.size(); i++) {
|
args[i] = lstItems.get(i).getExerciseId();
|
}
|
argsMap.put("exerciseIds", args);
|
|
//查询题目得分
|
String hql_itemScores = "from ExerciseItemScore s where s.groupId=:groupId and s.exerciseItemId in (:exerciseIds) and s.deleteFlag is false order by exerciseItemId";
|
List<ExerciseItemScore> lstItemScores = this.findByComplexHql(hql_itemScores, CollectionUtils.newObjectMap("groupId",exerciseGroupId,"exerciseIds",args), ExerciseItemScore.class);
|
Map<String, List<ExerciseItemScore>> scoresMap= new HashMap<String,List<ExerciseItemScore>>();
|
log.error("=================================================");
|
List<ExerciseItemSet> exerciseItemSets=null;
|
if (lstItemScores==null||lstItemScores.size()<=0){
|
//根据考试ID查询itemSet
|
String hql = "select r from ExerciseItemSet r where r.exerciseInfoId=?";
|
exerciseItemSets = this.find(hql, CollectionUtils.newList(examId), ExerciseItemSet.class);
|
}else {
|
ExerciseUtils.packageExerciseItemScore(scoresMap, lstItemScores);
|
}
|
|
// 1.查询练习题目全站分析
|
String hql_analisis = "from ExerciseItemAnalisi where exerciseItemId in (:exerciseIds) and deleteFlag is false ";
|
List<ExerciseItemAnalisi> lstAnalisis = this.findByComplexHql(hql_analisis, argsMap, ExerciseItemAnalisi.class);
|
Map<String, List<ExerciseItemAnalisi>> analisiMap = new HashMap<String, List<ExerciseItemAnalisi>>(lstAnalisis.size());
|
for (ExerciseItemAnalisi analisis : lstAnalisis) {
|
if(analisiMap.containsKey(analisis.getExerciseItemId())){
|
analisiMap.get(analisis.getExerciseItemId()).add(analisis);
|
}else{
|
analisiMap.put(analisis.getExerciseItemId(),CollectionUtils.newList(ExerciseItemAnalisi.class, analisis));
|
}
|
}
|
|
// 2.查询练习题目答案选项
|
Map<String, List<ExerciseItemOption>> optionsMap = new HashMap<String, List<ExerciseItemOption>>(
|
lstItems.size());
|
Map<String, String> answerMap = new HashMap<String, String>();
|
String hql_options = "from ExerciseItemOption where exerciseItemId in (:exerciseIds) and deleteFlag is false order by exerciseItemId, optionOrder ";
|
List<ExerciseItemOption> lstAllOptions = this.findByComplexHql(hql_options, argsMap, ExerciseItemOption.class);
|
|
// 重新组装练习
|
ExerciseUtils.packageExerciseItem(optionsMap, answerMap, lstAllOptions, null);
|
|
String exerciseId = null;
|
for (ExerciseItem item : lstItems) {
|
|
// 4.0 分析结果
|
exerciseId = item.getExerciseId();
|
|
// 得到练习组id
|
if (StringUtils.isNotBlank(exerciseGroupId)) {
|
item.setExerciseGroupId(exerciseGroupId);
|
}
|
|
// 4.3 题目选项
|
item.setOptions(optionsMap.get(exerciseId));
|
|
item.setAnalisisResult(null);
|
item.setAnalysises(null);
|
item.setAnalysises(analisiMap.get(exerciseId));
|
//组装练习题目
|
item.setScores(scoresMap.get(exerciseId));
|
//随机试题没有对应分数，需要根据考试Id从item_set里查询每种题目的分数设置
|
if (exerciseItemSets != null ) {
|
//遍历每个item
|
short type = item.getType();
|
//遍历itemset，每个item根据type获取对应类型的分数设置
|
for (ExerciseItemSet exerciseItemSet : exerciseItemSets) {
|
if (exerciseItemSet.getItemType() == type) {
|
/**
|
* attribute1: null
|
* attribute2: null
|
* exerciseItemAnswer: null
|
* exerciseItemId: "2c92ad6a710b09db0171b4477f620122"
|
* exerciseItemScoreId: "2c92ad6a72507b08017251baf6ce000d"
|
* groupId: "2c92ad6a72507b08017251ba5c6f0002"
|
* score: "4.00"
|
*/
|
List<ExerciseItemScore> exeSets = new ArrayList<>();
|
ExerciseItemScore exerciseItemScore = new ExerciseItemScore();
|
exerciseItemScore.setExerciseItemId(item.getExerciseId());
|
exerciseItemScore.setGroupId(exerciseGroupId);
|
exerciseItemScore.setScore(exerciseItemSet.getRightScore().toString());
|
exeSets.add(exerciseItemScore);
|
item.setScores(exeSets);
|
}
|
}
|
}
|
}
|
return lstItems;
|
}
|
|
@Override
|
public int doCopyExerciseGroupItem(ExerciseGroup sourceGroup, ExerciseGroup targetGroup,Short[] itemTypes, int startOrder)
|
throws IllegalAccessException, InvocationTargetException {
|
//参数判断
|
if(sourceGroup==null || targetGroup==null || ArrayUtils.isEmpty(itemTypes)){
|
return 0;
|
}
|
|
//查询题目组与题目关联关系,需要过滤掉在目标题目组中已拷贝过的题目
|
String hql = "select r1 from ExerciseGroupItemRe r1,ExerciseItem i where r1.exerciseItemId = i.exerciseId and i.type in(:itemTypes) and r1.deleteFlag is false and r1.exerciseGroupId = :sourceGroupId "
|
+ " and not exists (select 1 from ExerciseGroupItemRe r2 where r2.deleteFlag is false and r2.exerciseItemId = r1.exerciseItemId and r2.exerciseGroupId = :targetGroupId ) order by r1.itemOrder ASC ";
|
|
Map<String,Object> queryParamMap = new HashMap<String,Object>();
|
queryParamMap.put("sourceGroupId", sourceGroup.getGroupId());
|
queryParamMap.put("targetGroupId", targetGroup.getGroupId());
|
queryParamMap.put("itemTypes", itemTypes);
|
List<ExerciseGroupItemRe> lstSourceGroupRe = this.findByComplexHql(hql,queryParamMap,ExerciseGroupItemRe.class);
|
|
//查询题目组关联的得分信息,只关联获取没初化过的
|
String hql_itemScores = "select s1 from ExerciseItemScore s1,ExerciseItem i where s1.exerciseItemId = i.exerciseId and i.type in(:itemTypes) and s1.groupId=:sourceGroupId and s1.deleteFlag is false and not exists ("
|
+ " select 1 from ExerciseItemScore s2 where s2.deleteFlag is false and s2.exerciseItemId = s1.exerciseItemId and s2.groupId =:targetGroupId ) order by s1.exerciseItemId";
|
List<ExerciseItemScore> lstItemScores = this.findByComplexHql(hql_itemScores,queryParamMap, ExerciseItemScore.class);
|
Map<String, List<ExerciseItemScore>> scoresMap= new HashMap<String,List<ExerciseItemScore>>(lstItemScores.size());
|
ExerciseUtils.packageExerciseItemScore(scoresMap, lstItemScores);
|
|
List<ExerciseGroupItemRe> lstTargetItemRe = new ArrayList<ExerciseGroupItemRe>(lstSourceGroupRe.size());
|
List<ExerciseItemScore> lstTargetItemScore = new ArrayList<ExerciseItemScore>(lstSourceGroupRe.size());
|
|
int copyItemSize=0;
|
if(lstSourceGroupRe!=null && lstSourceGroupRe.size()>0){
|
//更新item的顺序号
|
this.bulkUpdate("update ExerciseGroupItemRe r set r.itemOrder=r.itemOrder+"+lstSourceGroupRe.size()
|
+" where r.exerciseGroupId=? and r.itemOrder>? and r.deleteFlag is false ", new Object[]{targetGroup.getGroupId(),startOrder});
|
|
//拷贝item
|
copyItemSize=lstSourceGroupRe.size();
|
int itemOrder = startOrder;
|
ExerciseItemScore objItemScore = null;
|
ExerciseGroupItemRe ojbItemRe=null;
|
for (ExerciseGroupItemRe it : lstSourceGroupRe) {
|
ojbItemRe = new ExerciseGroupItemRe();
|
BeanUtils.copyProperties(it, ojbItemRe);
|
ojbItemRe.setItemOrder(++itemOrder);
|
ojbItemRe.setRelationId(null);
|
ojbItemRe.setExerciseGroupId(targetGroup.getGroupId());
|
lstTargetItemRe.add(ojbItemRe);
|
|
//复制题目分数信息
|
List<ExerciseItemScore> scores = scoresMap.get(it.getExerciseItemId());
|
if(scores!=null && scores.size()>0){
|
for(int i=0;i<scores.size();i++){
|
objItemScore = new ExerciseItemScore();
|
BeanUtils.copyProperties(scores.get(i), objItemScore);
|
objItemScore.setExerciseItemScoreId(null);
|
objItemScore.setGroupId(targetGroup.getGroupId());
|
lstTargetItemScore.add(objItemScore);
|
}
|
}
|
}
|
this.saveOrUpdateAll(lstTargetItemRe);
|
this.saveOrUpdateAll(lstTargetItemScore);
|
}
|
return copyItemSize;
|
}
|
|
@Override
|
public int doCopyExerciseGroupItem(ExerciseGroup sourceGroup, ExerciseGroup targetGroup,String[] exerciseItemIds, int startOrder)
|
throws IllegalAccessException, InvocationTargetException {
|
//参数判断
|
if(sourceGroup==null || targetGroup==null || ArrayUtils.isEmpty(exerciseItemIds)){
|
return 0;
|
}
|
|
//查询题目组与题目关联关系,需要过滤掉在目标题目组中已拷贝过的题目
|
String hql = "select r1 from ExerciseGroupItemRe r1 where r1.exerciseItemId in(:exerciseItemIds) and r1.deleteFlag is false and r1.exerciseGroupId = :sourceGroupId "
|
+ " and not exists (select 1 from ExerciseGroupItemRe r2 where r2.deleteFlag is false and r2.exerciseItemId = r1.exerciseItemId and r2.exerciseGroupId = :targetGroupId ) order by r1.itemOrder ASC ";
|
|
Map<String,Object> queryParamMap = new HashMap<String,Object>();
|
queryParamMap.put("sourceGroupId", sourceGroup.getGroupId());
|
queryParamMap.put("targetGroupId", targetGroup.getGroupId());
|
queryParamMap.put("exerciseItemIds", exerciseItemIds);
|
List<ExerciseGroupItemRe> lstSourceGroupRe = this.findByComplexHql(hql,queryParamMap,ExerciseGroupItemRe.class);
|
|
//查询题目组关联的得分信息,只关联获取没初化过的
|
String hql_itemScores = "select s1 from ExerciseItemScore s1 where s1.exerciseItemId in (:exerciseItemIds) and s1.groupId=:sourceGroupId and s1.deleteFlag is false and not exists ("
|
+ " select 1 from ExerciseItemScore s2 where s2.deleteFlag is false and s2.exerciseItemId = s1.exerciseItemId and s2.groupId =:targetGroupId ) order by s1.exerciseItemId";
|
List<ExerciseItemScore> lstItemScores = this.findByComplexHql(hql_itemScores,queryParamMap, ExerciseItemScore.class);
|
Map<String, List<ExerciseItemScore>> scoresMap= new HashMap<String,List<ExerciseItemScore>>(lstItemScores.size());
|
ExerciseUtils.packageExerciseItemScore(scoresMap, lstItemScores);
|
|
List<ExerciseGroupItemRe> lstTargetItemRe = new ArrayList<ExerciseGroupItemRe>(lstSourceGroupRe.size());
|
List<ExerciseItemScore> lstTargetItemScore = new ArrayList<ExerciseItemScore>(lstSourceGroupRe.size());
|
|
int copyItemSize=0;
|
if(lstSourceGroupRe!=null && lstSourceGroupRe.size()>0){
|
//更新item的顺序号
|
this.bulkUpdate("update ExerciseGroupItemRe r set r.itemOrder=r.itemOrder+"+lstSourceGroupRe.size()
|
+" where r.exerciseGroupId=? and r.itemOrder>? and r.deleteFlag is false ", new Object[]{targetGroup.getGroupId(),startOrder});
|
|
//拷贝item
|
copyItemSize=lstSourceGroupRe.size();
|
int itemOrder = startOrder;
|
ExerciseItemScore objItemScore = null;
|
ExerciseGroupItemRe ojbItemRe=null;
|
for (ExerciseGroupItemRe it : lstSourceGroupRe) {
|
ojbItemRe = new ExerciseGroupItemRe();
|
BeanUtils.copyProperties(it, ojbItemRe);
|
ojbItemRe.setItemOrder(++itemOrder);
|
ojbItemRe.setRelationId(null);
|
ojbItemRe.setExerciseGroupId(targetGroup.getGroupId());
|
lstTargetItemRe.add(ojbItemRe);
|
|
//复制题目分数信息
|
List<ExerciseItemScore> scores = scoresMap.get(it.getExerciseItemId());
|
if(scores!=null && scores.size()>0){
|
for(int i=0;i<scores.size();i++){
|
objItemScore = new ExerciseItemScore();
|
BeanUtils.copyProperties(scores.get(i), objItemScore);
|
objItemScore.setExerciseItemScoreId(null);
|
objItemScore.setGroupId(targetGroup.getGroupId());
|
lstTargetItemScore.add(objItemScore);
|
}
|
}
|
}
|
this.saveOrUpdateAll(lstTargetItemRe);
|
this.saveOrUpdateAll(lstTargetItemScore);
|
}
|
return copyItemSize;
|
}
|
|
@SuppressWarnings("unchecked")
|
@Override
|
public Result doExchangeExamPaperGroupItemOrder(String groupId, String exerciseItemId1, String exerciseItemId2) {
|
String hql = "from ExerciseGroupItemRe where deleteFlag is false and exerciseGroupId = :groupId and exerciseItemId in (:exerciseItemIds)";
|
|
Map<String, Object> queryParams = new HashMap<String, Object>();
|
queryParams.put("groupId", groupId);
|
queryParams.put("exerciseItemIds", new String[] { exerciseItemId1, exerciseItemId2 });
|
List<ExerciseGroupItemRe> lstItemRe = this.findByComplexHql(hql, queryParams, ExerciseGroupItemRe.class);
|
// 交换顺序号
|
int tempOrder = lstItemRe.get(0).getItemOrder();
|
lstItemRe.get(0).setItemOrder(lstItemRe.get(1).getItemOrder());
|
lstItemRe.get(1).setItemOrder(tempOrder);
|
this.saveOrUpdateAll(lstItemRe);
|
this.redisTemplate.delete(groupId);
|
return new Result(true);
|
}
|
|
@Override
|
public Result doPublishExerciseLib(String[] groupIds) {
|
Map<String, Object> pramMap = null;
|
if (groupIds != null && groupIds.length > 0) {
|
pramMap = new HashMap<String, Object>(2);
|
pramMap.put("type", ExerciseGroup.TYPE_EXERCISE_GROUP_LIB);
|
pramMap.put("groupIds", groupIds);
|
|
String hql = "from ExerciseGroup where type=:type and groupId in (:groupIds)";
|
List<ExerciseGroup> lstExerciseLibs = this.findByComplexHql(hql, pramMap, ExerciseGroup.class);
|
|
for (ExerciseGroup exerciseGroup : lstExerciseLibs) {
|
if (ExerciseGroup.STATUS_DRAFT != exerciseGroup.getStatus()) {
|
return new Result(false, "只有草稿状态的题库,才能发布。");
|
}
|
//判断题库中是否有题，有题目的题库才能发布
|
if(exerciseGroup.getAllCount()==null || exerciseGroup.getAllCount().intValue()<=0){
|
return new Result(false, "只有已经配置题目的题库,才能发布。");
|
}
|
exerciseGroup.setStatus(ExerciseGroup.STATUS_PUBLISHED);
|
TraceUtils.setUpdateTrace(exerciseGroup);
|
save(exerciseGroup);
|
}
|
} else {
|
return new Result(false, "没有选择要发布的题库。");
|
}
|
return new Result(true);
|
}
|
|
@Override
|
public Result doRevokeExerciseLib(String[] groupIds) {
|
Map<String, Object> pramMap = null;
|
if (groupIds != null && groupIds.length > 0) {
|
pramMap = new HashMap<String, Object>(2);
|
pramMap.put("type", ExerciseGroup.TYPE_EXERCISE_GROUP_LIB);
|
pramMap.put("groupIds", groupIds);
|
String hql = "from ExerciseGroup where type=:type and groupId in (:groupIds)";
|
List<ExerciseGroup> lstExerciseLibs = this.findByComplexHql(hql, pramMap, ExerciseGroup.class);
|
|
for (ExerciseGroup exerciseGroup : lstExerciseLibs) {
|
if (ExerciseGroup.STATUS_PUBLISHED != exerciseGroup.getStatus()) {
|
return new Result(false, "只有发布状态的题库,才能撤回。");
|
}
|
exerciseGroup.setStatus(ExerciseGroup.STATUS_DRAFT);
|
TraceUtils.setUpdateTrace(exerciseGroup);
|
save(exerciseGroup);
|
}
|
} else {
|
return new Result(false, "没有选择要撤回的题库。");
|
}
|
return new Result(true);
|
}
|
|
@Override
|
@SuppressWarnings("unchecked")
|
public String doCreateRandomExerciseGroup(String newGroupName,short newGroupType,String [] sourceGroupIds,List<ExerciseItemSet> lstExerciseItemSet){
|
Result result = this.doCreateRandomExerciseItem(sourceGroupIds,lstExerciseItemSet );
|
|
if (!result.isSuccess()) {
|
return null;
|
}
|
|
List<Map<String, Object>> lstExerciseItem = (List<Map<String, Object>>) result.getData();
|
|
ExerciseGroup group = new ExerciseGroup();
|
group.setDeleteFlag(false);
|
group.setName(newGroupName);
|
group.setOrderNum(BigInteger.ZERO);
|
group.setType(newGroupType);
|
group.setOrgId(ClientUtils.getOrgId());
|
group.setStatus(ExerciseGroup.STATUS_PUBLISHED);
|
group.setAllCount(BigInteger.valueOf(lstExerciseItem.size()));
|
TraceUtils.setCreateTrace(group);
|
this.save(group);
|
|
int k = 1;
|
for (Map<String, Object> item : lstExerciseItem) {
|
ExerciseGroupItemRe itemRe = new ExerciseGroupItemRe();
|
itemRe.setDocOrder(item.get("docOrder") == null ? 0 : (Integer) item.get("docOrder"));
|
itemRe.setItemOrder(k);
|
itemRe.setExerciseGroupId(group.getGroupId());
|
itemRe.setExerciseItemId((String) item.get("exerciseId"));
|
itemRe.setDeleteFlag(false);
|
k++;
|
this.save(itemRe);
|
}
|
return group.getGroupId();
|
}
|
|
|
/**
|
* 创建考试题目
|
*
|
* @param groupIds
|
* @return
|
*/
|
private Result doCreateRandomExerciseItem(String[] groupIds, List<ExerciseItemSet> lstExerciseItemSet) {
|
if (groupIds.length == 0 || lstExerciseItemSet == null || lstExerciseItemSet.size() == 0) {
|
return new Result(false, "参数错误");
|
}
|
|
List<Map<String, Object>> lstExerciseItem = new ArrayList<Map<String, Object>>();
|
|
//按照题型(单选题(1)，多选题(2)，判断题(3)， 填空题(8)，简答题(4))排序lstExerciseItemSet
|
Collections.sort(lstExerciseItemSet, new Comparator<ExerciseItemSet>(){
|
@Override
|
public int compare(ExerciseItemSet o1, ExerciseItemSet o2) {
|
int type1 = o1.getItemType()==ExerciseItem.TYPE_ESSAY_QUESTION?Short.MAX_VALUE:o1.getItemType();
|
int type2 = o2.getItemType()==ExerciseItem.TYPE_ESSAY_QUESTION?Short.MAX_VALUE:o2.getItemType();
|
return type1-type2;
|
}
|
});
|
|
String[] paramGroupIds=null;
|
for (ExerciseItemSet itemSet : lstExerciseItemSet) {
|
if(StringUtils.isEmpty(itemSet.getSourceGroupId())){
|
paramGroupIds = groupIds;
|
}else{
|
paramGroupIds = new String[]{itemSet.getSourceGroupId()};
|
}
|
|
List<Map<String, Object>> lstItem = this.findListWithMapByHql(
|
"select i.exerciseId as exerciseId, r.docOrder as docOrder"
|
+ " from ExerciseGroupItemRe r, ExerciseItem i where i.deleteFlag is false and r.deleteFlag is false"
|
+ " and r.exerciseItemId = i.exerciseId and r.exerciseGroupId in (:exerciseGroupId) and type = :type",
|
CollectionUtils.newObjectMap("exerciseGroupId", paramGroupIds, "type", itemSet.getItemType()));
|
|
if (lstItem.size() < itemSet.getItemCount()) {
|
return new Result(false, "题目数据不够，请增加题库的题目或者减少试卷的题数");
|
}
|
|
lstExerciseItem.addAll(this.getRandomList(lstItem, itemSet.getItemCount()));
|
}
|
|
return new Result(true, "", lstExerciseItem);
|
}
|
|
/**
|
* 随机获取List中若干数据
|
*
|
* @param paramList
|
* @param count
|
* @return
|
*/
|
private List<Map<String, Object>> getRandomList(List<Map<String, Object>> paramList, int count) {
|
if (paramList.size() < count) {
|
return paramList;
|
}
|
Random random = new Random();
|
List<Integer> tempList = new ArrayList<Integer>();
|
List<Map<String, Object>> newList = new ArrayList<Map<String, Object>>();
|
int temp = 0;
|
for (int i = 0; i < count; i++) {
|
temp = random.nextInt(paramList.size());// 将产生的随机数作为被抽list的索引
|
if (!tempList.contains(temp)) {
|
tempList.add(temp);
|
newList.add(paramList.get(temp));
|
} else {
|
i--;
|
}
|
}
|
return newList;
|
}
|
|
/**
|
* 获取题库中各种题型的数量
|
* @param groupIds
|
* @return
|
*/
|
@Override
|
public List<ExerciseGroup> queryExerciseGroupItemsStatistic(String[] groupIds){
|
Map<String,ExerciseGroup> resultMap =null;
|
if(groupIds!=null && groupIds.length>0){
|
resultMap = new LinkedHashMap<String,ExerciseGroup>(groupIds.length);
|
String hql = " select g.groupId,g.name,i.type,count(i.type) from ExerciseGroup g,ExerciseGroupItemRe r,ExerciseItem i where g.groupId in (:groupIds) and "
|
+ " g.groupId=r.exerciseGroupId and r.exerciseItemId = i.exerciseId and r.deleteFlag is false group by r.exerciseGroupId,i.type";
|
Map<String,Object> param =new HashMap<String,Object>();
|
param.put("groupIds", groupIds);
|
List<Object[]> lstItemStatics = this.findByComplexHql(hql, param, Object[].class);
|
|
ExerciseGroup tempGroup = null;
|
String tempGroupId=null;
|
String tempGroupName=null;
|
short tempType= 0;
|
int tempCount=0;
|
for(int i=0;i<lstItemStatics.size();i++){
|
tempGroupId= (String) lstItemStatics.get(i)[0];
|
tempGroupName=(String) lstItemStatics.get(i)[1];
|
tempType = (Short) lstItemStatics.get(i)[2];
|
tempCount = ((Long) lstItemStatics.get(i)[3]).intValue();
|
|
if(resultMap.get(tempGroupId)==null){
|
tempGroup = new ExerciseGroup();
|
tempGroup.setGroupId(tempGroupId);
|
tempGroup.setName(tempGroupName);
|
resultMap.put(tempGroupId, tempGroup);
|
}else{
|
tempGroup = resultMap.get(tempGroupId);
|
}
|
|
if(tempType==ExerciseItem.TYPE_SINGLE_SELECT){
|
tempGroup.setSingleSelectCount(tempCount);
|
}else if(tempType==ExerciseItem.TYPE_MULTI_SELECT){
|
tempGroup.setMultiSelectCount(tempCount);
|
}else if(tempType==ExerciseItem.TYPE_TRUE_OR_FALSE){
|
tempGroup.setJudgeCount(tempCount);
|
}else if(tempType==ExerciseItem.TYPE_ESSAY_QUESTION){
|
tempGroup.setQuestionCount(tempCount);
|
}else if(tempType==ExerciseItem.TYPE_FILL_BLANKS){
|
tempGroup.setFillBlanksCount(tempCount);
|
}
|
}
|
}
|
return new ArrayList<ExerciseGroup>( resultMap.values());
|
}
|
|
|
@Override
|
public String [] queryGroupNamesByIds(String[] groupIds){
|
if(groupIds!=null && groupIds.length==0){
|
return null;
|
}
|
|
String [] groupNames = null;
|
|
List<Map<String,Object>> lstResult= this.findListWithMapByHql("select g.groupId as groupId ,g.name as groupName from ExerciseGroup g where g.groupId in (:groupIds) ",
|
CollectionUtils.newObjectMap("groupIds",groupIds));
|
|
if(lstResult!=null && lstResult.size()==groupIds.length){
|
Map<String,String> map= new HashMap<String,String>(lstResult.size());
|
groupNames =new String[groupIds.length];
|
|
for(Map<String,Object> item:lstResult){
|
map.put((String)item.get("groupId"), (String)item.get("groupName"));
|
}
|
|
for(int i=0;i<groupIds.length;i++){
|
groupNames[i]= map.get(groupIds[i]);
|
}
|
}
|
|
return groupNames;
|
}
|
|
|
|
|
|
|
|
}
|
