From 068fc7f2e81178e55fa191a13709af64b1a163f6 Mon Sep 17 00:00:00 2001
From: EricsHu <hrr145632>
Date: 星期一, 05 十二月 2022 14:27:43 +0800
Subject: [PATCH] 处理编码
---
src/main/java/com/qxueyou/scc/exercise/service/impl/ExerciseService.java | 778 +++++++++++++++++++++++++++++-----------------------------
1 files changed, 389 insertions(+), 389 deletions(-)
diff --git a/src/main/java/com/qxueyou/scc/exercise/service/impl/ExerciseService.java b/src/main/java/com/qxueyou/scc/exercise/service/impl/ExerciseService.java
index 22de33b..5de500c 100644
--- a/src/main/java/com/qxueyou/scc/exercise/service/impl/ExerciseService.java
+++ b/src/main/java/com/qxueyou/scc/exercise/service/impl/ExerciseService.java
@@ -87,7 +87,7 @@
import com.qxueyou.scc.user.model.UserRegistration;
/**
- * 练习 实现service 练习后台
+ * 缁冧範 瀹炵幇service 缁冧範鍚庡彴
*
* @author zhiyong
*
@@ -122,7 +122,7 @@
}
/**
- * 依赖注入
+ * 渚濊禆娉ㄥ叆
*
* @param exerExtendDAO
*/
@@ -143,8 +143,8 @@
int iCount = 0;
if (type == 3) {
- // 查询当前class存在的存在的顺序、随机练习或者 章节练习 个数
- // 可能结果：0、 新增三种；1，新增两种（顺序随机），2，新增一种（章节），3的话，不增加
+ // 鏌ヨ褰撳墠class瀛樺湪鐨勫瓨鍦ㄧ殑椤哄簭銆侀殢鏈虹粌涔犳垨鑰� 绔犺妭缁冧範 涓暟
+ // 鍙兘缁撴灉锛�0銆� 鏂板涓夌锛�1锛屾柊澧炰袱绉嶏紙椤哄簭闅忔満锛夛紝2锛屾柊澧炰竴绉嶏紙绔犺妭锛夛紝3鐨勮瘽锛屼笉澧炲姞
String hsql = "from ExerciseGroup where classId = ? and case when type = ? then 1 when type = ? then 1 when type = ? and "
+ " attribute1 = ? and attribute2 = ? then 1 else 0 end = 1 and deleteFlag is false";
iCount = findCount(hsql, CollectionUtils.newList(ClientUtils.getClassId(), ExerciseGroup.TYPE_EXERCISE_RANDOM, ExerciseGroup.TYPE_EXERCISE_SEQUENCE, ExerciseGroup.TYPE_CHAPTER_ITEM, lessonId, chapterId));
@@ -152,31 +152,31 @@
Result objResult = saveOrUpdateAll(initExerciseGroupList(name, type, lessonId, chapterId, iCount));
- // 保存
+ // 淇濆瓨
return objResult;
}
/**
- * 新增练习组
+ * 鏂板缁冧範缁�
*
* @param name
- * 练习组名称
+ * 缁冧範缁勫悕绉�
* @param type
- * 练习组类型
+ * 缁冧範缁勭被鍨�
* @param lessonId
- * 课程id
+ * 璇剧▼id
* @param chapterId
- * 章节id
- * @param 模拟考试
- * 时间设置
+ * 绔犺妭id
+ * @param 妯℃嫙鑰冭瘯
+ * 鏃堕棿璁剧疆
* @return
*/
public Result insertExerciseGroup(String groupId,String name, short type, String lessonId, String chapterId, String attribute1, boolean repeatFlag) {
- if(StringUtils.isNotBlank(groupId)){ // 更新
+ if(StringUtils.isNotBlank(groupId)){ // 鏇存柊
return updateExerciseGroup(groupId, name, type, lessonId, chapterId, attribute1, repeatFlag);
- }else{ // 新增
+ }else{ // 鏂板
return saveExerciseGroup(name, type, lessonId, chapterId, attribute1, repeatFlag);
}
@@ -185,16 +185,16 @@
public Result updateExerciseGroup(String groupId,String name, short type, String subjectId, String chapterId, String attribute1, boolean repeatFlag) {
ExerciseGroup group = read(ExerciseGroup.class, groupId);
- if(type == ExerciseGroup.TYPE_CHAPTER_ITEM){ // 章节练习
+ if(type == ExerciseGroup.TYPE_CHAPTER_ITEM){ // 绔犺妭缁冧範
group.setAttribute2(chapterId);
}
- if (type == ExerciseGroup.TYPE_MOCK_EXAM) {// 模拟考试
- // 添加练习组时间 、是否重做
+ if (type == ExerciseGroup.TYPE_MOCK_EXAM) {// 妯℃嫙鑰冭瘯
+ // 娣诲姞缁冧範缁勬椂闂� 銆佹槸鍚﹂噸鍋�
addExerciseGroupExtendTime(groupId, attribute1, repeatFlag);
}
- if (type == ExerciseGroup.TYPE_HOMEWORK) {// 家庭作业
- // 添加是否重做
+ if (type == ExerciseGroup.TYPE_HOMEWORK) {// 瀹跺涵浣滀笟
+ // 娣诲姞鏄惁閲嶅仛
addExerciseGroupExtendTime(groupId, null, repeatFlag);
}
@@ -208,8 +208,8 @@
public Result saveExerciseGroup(String name, short type, String lessonId, String chapterId, String attribute1, boolean repeatFlag) {
int iCount = 0;
if (type == ExerciseGroup.TYPE_EXERCISE_SEQUENCE) {
- // 查询当前class存在的存在的顺序、随机练习或者 章节练习 个数
- // 可能结果：0、 新增三种；1，新增两种（顺序随机），2，新增一种（章节），3的话，不增加
+ // 鏌ヨ褰撳墠class瀛樺湪鐨勫瓨鍦ㄧ殑椤哄簭銆侀殢鏈虹粌涔犳垨鑰� 绔犺妭缁冧範 涓暟
+ // 鍙兘缁撴灉锛�0銆� 鏂板涓夌锛�1锛屾柊澧炰袱绉嶏紙椤哄簭闅忔満锛夛紝2锛屾柊澧炰竴绉嶏紙绔犺妭锛夛紝3鐨勮瘽锛屼笉澧炲姞
String hsql = "from ExerciseGroup where classId = ? and case when type = ? then 1 when type = ? then 1 when type = ? and "
+ " attribute1 = ? and attribute2 = ? then 1 else 0 end = 1 and deleteFlag is false";
iCount = findCount(hsql, CollectionUtils.newList(ClientUtils.getClassId(), ExerciseGroup.TYPE_EXERCISE_RANDOM, ExerciseGroup.TYPE_EXERCISE_SEQUENCE, ExerciseGroup.TYPE_CHAPTER_ITEM, lessonId, chapterId));
@@ -217,7 +217,7 @@
List<ExerciseGroup> lstExeGroup = initExerciseGroupList(name, type, lessonId, chapterId, iCount);
- // 兼容1.0版本 模拟考试时间设置
+ // 鍏煎1.0鐗堟湰 妯℃嫙鑰冭瘯鏃堕棿璁剧疆
for (ExerciseGroup group : lstExeGroup) {
group.setOrderNum(BigInteger.valueOf(SchCourseware.COURSEWARE_MAX_ORDER));
@@ -231,40 +231,40 @@
//Result objResult = saveOrUpdateAll(lstExeGroup);
- if (type == ExerciseGroup.TYPE_MOCK_EXAM) {// 模拟考试
- // 添加练习组时间 、是否重做
+ if (type == ExerciseGroup.TYPE_MOCK_EXAM) {// 妯℃嫙鑰冭瘯
+ // 娣诲姞缁冧範缁勬椂闂� 銆佹槸鍚﹂噸鍋�
addExerciseGroupExtendTime(lstExeGroup.get(0).getGroupId(), attribute1, repeatFlag);
}
- if (type == ExerciseGroup.TYPE_HOMEWORK) {// 家庭作业
- // 添加是否重做
+ if (type == ExerciseGroup.TYPE_HOMEWORK) {// 瀹跺涵浣滀笟
+ // 娣诲姞鏄惁閲嶅仛
addExerciseGroupExtendTime(lstExeGroup.get(0).getGroupId(), null, repeatFlag);
}
- // 保存
+ // 淇濆瓨
return new Result(true);
}
/**
- * 新增题库
+ * 鏂板棰樺簱
*
* @param name
- * 练习组名称
+ * 缁冧範缁勫悕绉�
* @param type
- * 练习组类型
+ * 缁冧範缁勭被鍨�
* @param lessonId
- * 课程id
+ * 璇剧▼id
* @param chapterId
- * 章节id
- * @param 模拟考试
- * 时间设置
+ * 绔犺妭id
+ * @param 妯℃嫙鑰冭瘯
+ * 鏃堕棿璁剧疆
* @return
*/
public Result insertOrgExercise(ExerciseGroup group, boolean repeatFlag) {
- if(StringUtils.isNotBlank(group.getGroupId())){ // 更新
+ if(StringUtils.isNotBlank(group.getGroupId())){ // 鏇存柊
return updateOrgExerciseGroup(group, repeatFlag);
- }else{ // 新增
+ }else{ // 鏂板
return saveOrgExerciseGroup(group, repeatFlag);
}
@@ -274,12 +274,12 @@
ExerciseGroup oldGroup = read(ExerciseGroup.class, group.getGroupId());
- if (oldGroup.getType() == ExerciseGroup.TYPE_MOCK_EXAM) {// 模拟考试
- // 添加练习组时间 、是否重做
+ if (oldGroup.getType() == ExerciseGroup.TYPE_MOCK_EXAM) {// 妯℃嫙鑰冭瘯
+ // 娣诲姞缁冧範缁勬椂闂� 銆佹槸鍚﹂噸鍋�
addExerciseGroupExtendTime(group.getGroupId(), group.getAttribute1(), repeatFlag);
}
- if (oldGroup.getType() == ExerciseGroup.TYPE_HOMEWORK) {// 家庭作业
- // 添加是否重做
+ if (oldGroup.getType() == ExerciseGroup.TYPE_HOMEWORK) {// 瀹跺涵浣滀笟
+ // 娣诲姞鏄惁閲嶅仛
addExerciseGroupExtendTime(group.getGroupId(), null, repeatFlag);
}
@@ -302,8 +302,8 @@
if (StringUtils.isNotBlank(group.getAttribute1())) {
addExerciseGroupExtendTime(group.getGroupId(), group.getAttribute1(), repeatFlag);
}
- if (group.getType() == ExerciseGroup.TYPE_HOMEWORK) {// 家庭作业
- // 添加是否重做
+ if (group.getType() == ExerciseGroup.TYPE_HOMEWORK) {// 瀹跺涵浣滀笟
+ // 娣诲姞鏄惁閲嶅仛
addExerciseGroupExtendTime(group.getGroupId(), null, repeatFlag);
}
@@ -313,7 +313,7 @@
}
/**
- * 拷贝练习
+ * 鎷疯礉缁冧範
*
* @param id
* @param subjectId
@@ -348,23 +348,23 @@
this.saveExerciseGroup(newGroup);
- //班级拷贝不需要新增关联表
+ //鐝骇鎷疯礉涓嶉渶瑕佹柊澧炲叧鑱旇〃
if(StringUtils.isEmpty(ClientUtils.getClassId())){
newGroup.setOriginExerciseId(newGroup.getGroupId());
this.saveExerciseGroup(newGroup);
this.insertReCourse(collegeCourseId, newGroup.getGroupId());
}
- // 扩展表： extend
+ // 鎵╁睍琛細 extend
this.doSaveCopyExtend(oldExercise,newGroup);
- this.doCopyExerciseItem(newGroup.getGroupId(), oldExercise.getGroupId(), null, 1);//拷贝
+ this.doCopyExerciseItem(newGroup.getGroupId(), oldExercise.getGroupId(), null, 1);//鎷疯礉
return new Result(true);
}
/**
- * 拷贝练习题
+ * 鎷疯礉缁冧範棰�
*
* @param items
* @param newGroupId
@@ -385,14 +385,14 @@
List<ExerciseGroupItemRe> reNew = new ArrayList<>();
List<ExerciseObjectImg> exerciseObjectImgNew = new ArrayList<>();
- // 得到当前组题目的最大题号
+ // 寰楀埌褰撳墠缁勯鐩殑鏈�澶ч鍙�
int maxGroupItemOrder = queryExerciseGroupItemNo(newGroupId);
for(ExerciseItem objExerciseItem : items){
ExerciseGroupItemRe oldExerciseGroupItemRe = this.findUnique("from ExerciseGroupItemRe where deleteFlag is false and exerciseGroupId = ? and exerciseItemId = ?",
CollectionUtils.newList(oldGroupId, objExerciseItem.getExerciseId()), ExerciseGroupItemRe.class);
- //临时对象
+ //涓存椂瀵硅薄
ExerciseItem tem = new ExerciseItem();
tem = (ExerciseItem) BeanUtils.cloneBean(objExerciseItem);
List<ExerciseObjectImg> exerciseObjectImg = this.find("from ExerciseObjectImg m where m.deleteFlag is false and m.exerciseObjectId = ?",
@@ -408,7 +408,7 @@
ExerciseItem objExerciseItemNew = new ExerciseItem();
BeanUtils.copyProperties(objExerciseItemNew, tem);
objExerciseItemNew.setExerciseId(null);
- //拷贝的练习不同步
+ //鎷疯礉鐨勭粌涔犱笉鍚屾
objExerciseItemNew.setOrgiExerciseId(type == 1?null:StringUtils.isEmpty(objExerciseItem.getOrgiExerciseId())?objExerciseItem.getExerciseId():objExerciseItem.getOrgiExerciseId());
TraceUtils.setCreateTrace(objExerciseItemNew);
@@ -482,19 +482,19 @@
this.saveOrUpdateAll(analysisesNew);
this.saveOrUpdateAll(exerciseObjectImgNew);
- //更新统计
+ //鏇存柊缁熻
this.updateGroupUpdateTimeByList(this.find("from ExerciseGroup where groupId = ?", CollectionUtils.newList(newGroupId), ExerciseGroup.class));
}
}
/**
- * 插入练习和科目关联
+ * 鎻掑叆缁冧範鍜岀鐩叧鑱�
*
* @param collegeCourseId
* @param handoutId
*/
private void insertReCourse(String collegeCourseId, String groupId){
- // 序号
+ // 搴忓彿
String hql = "select MAX(c.orderNum) from ExerciseReCourse c where c.deleteFlag is false and c.collegeCourseId = ? and orgId = ? ";
Integer iMax = this.findUnique(hql, CollectionUtils.newList(collegeCourseId, ClientUtils.getOrgId()), Integer.class);
@@ -517,21 +517,21 @@
public Result insertAppointExercise(String groupIds[], String orgIds[], String classIds[]) {
if (null == groupIds || groupIds.length == 0) {
- return new Result(false, "参数错误");
+ return new Result(false, "鍙傛暟閿欒");
}
- // 一次性查询groupId对应的collegeCourseId
+ // 涓�娆℃�ф煡璇roupId瀵瑰簲鐨刢ollegeCourseId
String hql = " from ExerciseReCourse where groupId in (:groupIds) and deleteFlag is false";
Map<String, Object> argsMap = new HashMap<String, Object>();
argsMap.put("groupIds", groupIds);
List<ExerciseReCourse> courseList = findByComplexHql(hql, argsMap, ExerciseReCourse.class);
- // 放入map中 KEY:groupId VALUE:collegeCourseId
+ // 鏀惧叆map涓� KEY:groupId VALUE:collegeCourseId
Map<String, String> groupReCourse = new HashMap<String, String>();
for (ExerciseReCourse exerciseReCourse : courseList) {
groupReCourse.put(exerciseReCourse.getGroupId(), exerciseReCourse.getCollegeCourseId());
}
- // 一次性查询classId对应的orgId
+ // 涓�娆℃�ф煡璇lassId瀵瑰簲鐨刼rgId
Map<String, String> classMap = new HashMap<String, String>();
if (classIds.length > 0) {
hql = " from ClsClass where classId in (:classIds) and deleteFlag is false";
@@ -539,14 +539,14 @@
argsMap.put("classIds", classIds);
List<ClsClass> classList = findByComplexHql(hql, argsMap, ClsClass.class);
- // 放入map中 KEY:classId VALUE:orgId
+ // 鏀惧叆map涓� KEY:classId VALUE:orgId
for (ClsClass orgClass : classList) {
classMap.put(orgClass.getClassId(), orgClass.getOrgId());
}
}
- // 一次性查询groupId对应的orderNum
+ // 涓�娆℃�ф煡璇roupId瀵瑰簲鐨刼rderNum
Map<String, Integer> orderMap = new HashMap<String, Integer>();
hql = " from ExerciseReCourse where groupId in (:groupIds) and deleteFlag is false and orgId = :currOrgId";
@@ -555,16 +555,16 @@
argsMap.put("currOrgId", ClientUtils.getOrgId());
List<ExerciseReCourse> courseLst = findByComplexHql(hql, argsMap, ExerciseReCourse.class);
- // 放入map中 KEY:classId VALUE:orgId
+ // 鏀惧叆map涓� KEY:classId VALUE:orgId
for (ExerciseReCourse c : courseLst) {
orderMap.put(c.getGroupId(), c.getOrderNum());
}
for (String groupId : groupIds) {
- if (orgIds.length > 0) { // 指定给机构
+ if (orgIds.length > 0) { // 鎸囧畾缁欐満鏋�
insertOrgGroup(groupId, orgIds, groupReCourse.get(groupId),orderMap);
}
- if (classIds.length > 0) { // 指定给班级
+ if (classIds.length > 0) { // 鎸囧畾缁欑彮绾�
ExerciseGroup group = read(ExerciseGroup.class, groupId);
insertClassGroup(groupId, classIds, group, groupReCourse.get(groupId), classMap,orderMap);
}
@@ -573,7 +573,7 @@
}
/**
- * 指定给机构
+ * 鎸囧畾缁欐満鏋�
*
* @param groupId
* @param orgIds
@@ -581,7 +581,7 @@
* @return
*/
public void insertOrgGroup(String groupId, String orgIds[], String collegeCourseId,Map<String, Integer> orderMap) {
- // 查询出所有不符合条件的数据
+ // 鏌ヨ鍑烘墍鏈変笉绗﹀悎鏉′欢鐨勬暟鎹�
String hql = "select orgId from ExerciseReCourse where groupId = :groupId and deleteFlag is false and orgId in (:orgIds)";
Map<String, Object> args = new HashMap<String, Object>();
args.put("groupId", groupId);
@@ -591,7 +591,7 @@
for (String orgId : orgIds) {
orgList.add(orgId);
}
- // 剔除掉不符合条件的orgId
+ // 鍓旈櫎鎺変笉绗﹀悎鏉′欢鐨刼rgId
orgList.removeAll(strings);
if(orgList.isEmpty()){
return;
@@ -613,7 +613,7 @@
}
/**
- * 指定给班级
+ * 鎸囧畾缁欑彮绾�
* @param groupId
* @param classIds
* @param group
@@ -621,17 +621,17 @@
* @param classMap
*/
public void insertClassGroup(String groupId, String classIds[], ExerciseGroup group, String collegeCourseId, Map<String, String> classMap,Map<String, Integer> orderMap) {
- //章节id
+ //绔犺妭id
Map<String,SubjectChapter> origChapterMap = new HashMap<String, SubjectChapter>();
Map<String, String> subjectMap = new HashMap<String, String>();
String hql = "from ExerciseGroupExtend where deleteFlag is false and groupId=? ";
- // 查询练习组扩展表
+ // 鏌ヨ缁冧範缁勬墿灞曡〃
ExerciseGroupExtend extend = this.findUnique(hql, CollectionUtils.newList(groupId), ExerciseGroupExtend.class);
//hql = " from ExerciseGroupItemRe where exerciseGroupId = ? and deleteFlag is false ";
//List<ExerciseGroupItemRe> lstItem = find(hql, CollectionUtils.newList(groupId), ExerciseGroupItemRe.class);
- // 查询出所有不符合条件的数据
+ // 鏌ヨ鍑烘墍鏈変笉绗﹀悎鏉′欢鐨勬暟鎹�
hql = "select classId from ExerciseGroup where classId in (:classIds) and originExerciseId = :groupId and deleteFlag is false";
Map<String, Object> args = new HashMap<String, Object>();
args.put("classIds", classIds);
@@ -641,13 +641,13 @@
for (String classId : classIds) {
classList.add(classId);
}
- // 剔除不符合的classId
+ // 鍓旈櫎涓嶇鍚堢殑classId
classList.removeAll(strings);
if(classList.isEmpty()){
return;
}
if(StringUtils.isNotEmpty(group.getSubjectId())){
- // 一次性查询班级ID对应的classSubjectId
+ // 涓�娆℃�ф煡璇㈢彮绾D瀵瑰簲鐨刢lassSubjectId
hql = " from SchClassSubject where classId in(:classIds) and origSubjectId = :subjectId and deleteFlag is false";
args = new HashMap<String, Object>();
args.put("classIds", classList.toArray());
@@ -685,8 +685,8 @@
if (StringUtils.isNotBlank(extend.getExerciseTime())) {
addExerciseGroupExtendTime(newGroup.getGroupId(), extend.getExerciseTime(), extend.getRepeatFlag());
}
- if (newGroup.getType() == ExerciseGroup.TYPE_HOMEWORK) {// 家庭作业
- // 添加是否重做
+ if (newGroup.getType() == ExerciseGroup.TYPE_HOMEWORK) {// 瀹跺涵浣滀笟
+ // 娣诲姞鏄惁閲嶅仛
addExerciseGroupExtendTime(newGroup.getGroupId(), null, extend.getRepeatFlag());
}
}
@@ -695,13 +695,13 @@
this.doCopyExerciseItem(newGroup.getGroupId(), groupId, null, 2);
}catch (IllegalAccessException e) {
- log.error("下发练习出错", e);
+ log.error("涓嬪彂缁冧範鍑洪敊", e);
} catch (InvocationTargetException e) {
- log.error("下发练习出错", e);
+ log.error("涓嬪彂缁冧範鍑洪敊", e);
} catch (InstantiationException e) {
- log.error("下发练习出错", e);
+ log.error("涓嬪彂缁冧範鍑洪敊", e);
} catch (NoSuchMethodException e) {
- log.error("下发练习出错", e);
+ log.error("涓嬪彂缁冧範鍑洪敊", e);
}
}
}
@@ -709,7 +709,7 @@
/**
- * 添加练习时间
+ * 娣诲姞缁冧範鏃堕棿
*
* @param groupId
* @param exerciseTime
@@ -719,7 +719,7 @@
String hql = "from ExerciseGroupExtend where deleteFlag is false and groupId=? ";
- // 查询练习组扩展表
+ // 鏌ヨ缁冧範缁勬墿灞曡〃
ExerciseGroupExtend extend = this.findUnique(hql, CollectionUtils.newList(groupId), ExerciseGroupExtend.class);
if (null == extend) {
@@ -739,7 +739,7 @@
}
/**
- * 新增练习扩展表
+ * 鏂板缁冧範鎵╁睍琛�
*
* @param extend
* @return
@@ -754,7 +754,7 @@
}
/**
- * 更新练习扩展表
+ * 鏇存柊缁冧範鎵╁睍琛�
*
* @param extend
* @return
@@ -783,7 +783,7 @@
/*
* (non-Javadoc)
*
- * @see com.iqtogether.qxueyou.exercise.service.IExerciseService#readExerciseItems(java.lang.String) 20150901：增加排序，习题数据和前台app顺序默认一致，题号保持一致。随机练习处理
+ * @see com.iqtogether.qxueyou.exercise.service.IExerciseService#readExerciseItems(java.lang.String) 20150901锛氬鍔犳帓搴忥紝涔犻鏁版嵁鍜屽墠鍙癮pp椤哄簭榛樿涓�鑷达紝棰樺彿淇濇寔涓�鑷淬�傞殢鏈虹粌涔犲鐞�
*/
@Override
public List<ExerciseItem> readExerciseItemsWithNo(String groupId) {
@@ -793,10 +793,10 @@
return null;
}
- // 默认章节练习
+ // 榛樿绔犺妭缁冧範
String hql = "select item,re.docOrder,re.relationId " + "from ExerciseItem item,ExerciseGroupItemRe re " + "where re.exerciseGroupId=? " + "and re.exerciseItemId=item.exerciseId " + "and item.deleteFlag is false " + "and re.deleteFlag is false " + "order by re.itemOrder ";
- // 随机练习,顺序练习
+ // 闅忔満缁冧範,椤哄簭缁冧範
if (ExerciseGroup.TYPE_EXERCISE_RANDOM == group.getType() || ExerciseGroup.TYPE_EXERCISE_SEQUENCE == group.getType()) {
hql = "select item,re.docOrder,re.relationId " + "from ExerciseItem item,ExerciseGroupItemRe re " + "where re.exerciseGroupId=? and " + "re.exerciseItemId=item.exerciseId " + "and item.deleteFlag is false " + "and re.deleteFlag is false " + "order by item.chapterId, re.itemOrder ";
}
@@ -826,15 +826,15 @@
log.error(e, e);
}
- // 此序号和app一致
+ // 姝ゅ簭鍙峰拰app涓�鑷�
item.setItemNo(iNum + 1);
- // 此序号和导入的doc文档一致，如果是导入的习题
+ // 姝ゅ簭鍙峰拰瀵煎叆鐨刣oc鏂囨。涓�鑷达紝濡傛灉鏄鍏ョ殑涔犻
if (null != objs.get(iNum)[1]) {
item.setDocNo((int) objs.get(iNum)[1]);
}
- // 关联表ID
+ // 鍏宠仈琛↖D
if (null != objs.get(iNum)[2]) {
item.setReId((String) objs.get(iNum)[2]);
}
@@ -848,12 +848,12 @@
}
/**
- * 查看问卷详情
+ * 鏌ョ湅闂嵎璇︽儏
*
* @param groupId
- * 问题组id
+ * 闂缁刬d
* @param evaluateTemId
- * 模板id
+ * 妯℃澘id
* @return
*/
@Override
@@ -861,7 +861,7 @@
ExerciseGroup group = this.read(ExerciseGroup.class, groupId);
if (null == group) {
- new ResultJson(false, "习题组不存在");
+ new ResultJson(false, "涔犻缁勪笉瀛樺湪");
}
QExerciseItem qItem = QExerciseItem.exerciseItem;
@@ -881,7 +881,7 @@
return lstItems;
}
- // 0.组装参数
+ // 0.缁勮鍙傛暟
Map<String, Object> argsMap = new HashMap<String, Object>();
Object[] args = new Object[lstItems.size()];
for(int i=0; i<lstItems.size(); i++){
@@ -889,7 +889,7 @@
}
argsMap.put("exerciseIds", args);
- // 1.查询练习题目全站分析
+ // 1.鏌ヨ缁冧範棰樼洰鍏ㄧ珯鍒嗘瀽
String hql_analisis = "from ExerciseItemAnalisi where exerciseItemId in (:exerciseIds) and deleteFlag is false ";
List<ExerciseItemAnalisi> lstAnalisis = this.findByComplexHql(hql_analisis, argsMap, ExerciseItemAnalisi.class);
Map<String, ExerciseItemAnalisi> analisiMap = new HashMap<String, ExerciseItemAnalisi>(lstAnalisis.size());
@@ -897,12 +897,12 @@
analisiMap.put(analisis.getExerciseItemId(), analisis);
}
- // 2.查询练习题目答案选项
+ // 2.鏌ヨ缁冧範棰樼洰绛旀閫夐」
Map<String, List<ExerciseItemOption>> optionsMap = new HashMap<String, List<ExerciseItemOption>>(lstItems.size());
Map<String, String> answerMap = new HashMap<String, String>();
String hql_options = "from ExerciseItemOption where exerciseItemId in (:exerciseIds) and deleteFlag is false order by exerciseItemId, optionOrder ";
List<ExerciseItemOption> lstAllOptions = this.findByComplexHql(hql_options, argsMap, ExerciseItemOption.class);
- // 2.1.组装参数 用于查询练习选项图片
+ // 2.1.缁勮鍙傛暟 鐢ㄤ簬鏌ヨ缁冧範閫夐」鍥剧墖
Map<String, Object> argsImgMap = new HashMap<String, Object>();
Object[] argImgs = new Object[lstAllOptions.size()];
for(int i=0; i<lstAllOptions.size(); i++){
@@ -910,38 +910,38 @@
}
argsImgMap.put("optionIds", argImgs);
- // 2-3-1查询题目是否关联图片
+ // 2-3-1鏌ヨ棰樼洰鏄惁鍏宠仈鍥剧墖
String hql_itemImgs = "from ExerciseObjectImg where exerciseObjectId in (:exerciseIds) and deleteFlag is false and objectType=1 order by exerciseObjectId,imgOrder ";
List<ExerciseObjectImg> lstItemImgs = this.findByComplexHql(hql_itemImgs, argsMap, ExerciseObjectImg.class);
Map<String, List<ExerciseObjectImg>> imgItemMap = ExerciseUtils.packageExerciseItemImg(lstItemImgs);
Map<String, List<ExerciseObjectImg>> imgOptionMap = null;
if(argImgs.length > 0) {
- // 2-3-2查询题目选项是否关联图片
+ // 2-3-2鏌ヨ棰樼洰閫夐」鏄惁鍏宠仈鍥剧墖
String hql_optionImgs = "from ExerciseObjectImg where exerciseObjectId in (:optionIds) and deleteFlag is false and objectType=2";
List<ExerciseObjectImg> lstOptionImgs = this.findByComplexHql(hql_optionImgs, argsImgMap, ExerciseObjectImg.class);
imgOptionMap = ExerciseUtils.packageExerciseItemImg(lstOptionImgs);
}
- // 重新组装练习
+ // 閲嶆柊缁勮缁冧範
ExerciseUtils.packageExerciseItem(optionsMap, answerMap, lstAllOptions, imgOptionMap);
- // 4.重新组装返回结果
+ // 4.閲嶆柊缁勮杩斿洖缁撴灉
String exerciseId = null;
for(ExerciseItem item:lstItems){
- // 4.0 分析结果
+ // 4.0 鍒嗘瀽缁撴灉
exerciseId = item.getExerciseId();
- // 得到练习组id
+ // 寰楀埌缁冧範缁刬d
if(StringUtils.isNotBlank(groupId)){
item.setExerciseGroupId(groupId);
}
- // 4.3 题目选项
+ // 4.3 棰樼洰閫夐」
item.setOptions(optionsMap.get(exerciseId));
- // 4.5题目中是否有图片
+ // 4.5棰樼洰涓槸鍚︽湁鍥剧墖
if(imgItemMap.get(exerciseId) != null){
item.setImgs(imgItemMap.get(exerciseId));
}
@@ -963,27 +963,27 @@
public Result insertExerciseItem(String groupId, ExerciseItem item, List<ExerciseItemOption> lstOptions, String analysis) {
TraceUtils.setCreateTrace(lstOptions);
- // 1. 保存习题
+ // 1. 淇濆瓨涔犻
ExerciseGroup group = this.read(ExerciseGroup.class, groupId);
handlerExerciseItem(group, item);
save(item);
- // 2. 保存习题和习题组关系
- // 获取一个习题需要跟新的关系条数
+ // 2. 淇濆瓨涔犻鍜屼範棰樼粍鍏崇郴
+ // 鑾峰彇涓�涓範棰橀渶瑕佽窡鏂扮殑鍏崇郴鏉℃暟
List<ExerciseGroup> result = initExerciseGroup(groupId);
- // 得到当前组题目的最大题号
+ // 寰楀埌褰撳墠缁勯鐩殑鏈�澶ч鍙�
int maxGroupItemOrder = queryExerciseGroupItemNo(groupId);
List<ExerciseGroupItemRe> groupRes = initExerciseGroupItemRe(result, item.getExerciseId(), getGroupReMaxOrder(groupId), ++maxGroupItemOrder );
- // 得到最大的ORDER
+ // 寰楀埌鏈�澶х殑ORDER
saveOrUpdateAll(groupRes);
- // 20150618：配合前台app，所有修改同时修改group表最后修改时间
+ // 20150618锛氶厤鍚堝墠鍙癮pp锛屾墍鏈変慨鏀瑰悓鏃朵慨鏀筭roup琛ㄦ渶鍚庝慨鏀规椂闂�
updateGroupUpdateTimeByList(result);
- // 3. 保存习题解析
+ // 3. 淇濆瓨涔犻瑙ｆ瀽
ExerciseItemAnalisi analysisVO = new ExerciseItemAnalisi();
analysisVO.setAnalysis(analysis);
analysisVO.setAccuracy(BigDecimal.ZERO);
@@ -993,19 +993,19 @@
saveAnalysis(item);
- // 4. 保存习题选项
+ // 4. 淇濆瓨涔犻閫夐」
for (ExerciseItemOption option : lstOptions) {
option.setExerciseItemId(item.getExerciseId());
save(option);
- // 新增习题选项图片
+ // 鏂板涔犻閫夐」鍥剧墖
updateExerOptionObjImgId(option);
}
item.setOptions(lstOptions);
- // 新增习题图片
+ // 鏂板涔犻鍥剧墖
updateExerciseObjImgId(item);
- //保存题目分数
+ //淇濆瓨棰樼洰鍒嗘暟
List<ExerciseItemScore> lstExerciseItemScore = item.getScores();
if(lstExerciseItemScore!=null && lstExerciseItemScore.size()>0){
for (ExerciseItemScore score : lstExerciseItemScore) {
@@ -1017,7 +1017,7 @@
}
// if(StringUtils.isEmpty(group.getClassId())){
-// // 同步习题
+// // 鍚屾涔犻
// String hql = " from ExerciseGroup where originExerciseId = ? and deleteFlag is false and groupId != ?";
// List<ExerciseGroup> lstGroup = find(hql, CollectionUtils.newList(group.getOriginExerciseId(), groupId), ExerciseGroup.class);
// List<ExerciseItem> items = find("from ExerciseItem where exerciseId = ?", CollectionUtils.newList(item.getExerciseId()), ExerciseItem.class);
@@ -1029,7 +1029,7 @@
// this.doCopyExerciseItem(exerciseGroup.getGroupId(), groupId, items, 2);
// } catch (IllegalAccessException | InstantiationException | InvocationTargetException
// | NoSuchMethodException e) {
-// log.error("新增练习同步到班级错误", e);
+// log.error("鏂板缁冧範鍚屾鍒扮彮绾ч敊璇�", e);
// }
// }
// }
@@ -1045,11 +1045,11 @@
@Override
public ResultJson insertExerciseItem4Evaluate(String groupId, ExerciseItem item,
List<ExerciseItemOption> lstOptions,String analysis,JSONArray titleImgs) {
- // 1. 保存习题
+ // 1. 淇濆瓨涔犻
TraceUtils.setCreateTrace(item);
this.save(item);
- // 2、保存习题关联组
+ // 2銆佷繚瀛樹範棰樺叧鑱旂粍
QExerciseGroupItemRe qRe =QExerciseGroupItemRe.exerciseGroupItemRe;
Integer maxGroupItemOrder =
this.getQueryFactory().select(qRe.itemOrder.max())
@@ -1067,7 +1067,7 @@
re.setDeleteFlag(false);
this.save(re);
- // 题目组题目个数+1
+ // 棰樼洰缁勯鐩釜鏁�+1
QExerciseGroup g = QExerciseGroup.exerciseGroup;
this.getQueryFactory()
.update(g)
@@ -1076,7 +1076,7 @@
.execute();
- // 3. 保存习题选项
+ // 3. 淇濆瓨涔犻閫夐」
for (int i = 0; i < lstOptions.size(); i++) {
ExerciseItemOption option = lstOptions.get(i);
option.setExerciseItemId(item.getExerciseId());
@@ -1085,7 +1085,7 @@
TraceUtils.setCreateTrace(option);
this.save(option);
- // 更新选项图片
+ // 鏇存柊閫夐」鍥剧墖
updateEvaExerOptionObjImgId(option);
ExerciseItemScore objExerciseItemScore = new ExerciseItemScore();
@@ -1097,10 +1097,10 @@
this.save(objExerciseItemScore);
}
- // 更新题目图片
+ // 鏇存柊棰樼洰鍥剧墖
this.updateEvaExerciseObjImgId(titleImgs,item.getExerciseId());
- // 4. 保存习题解析
+ // 4. 淇濆瓨涔犻瑙ｆ瀽
ExerciseItemAnalisi analysisVO = new ExerciseItemAnalisi();
analysisVO.setAnalysis(analysis);
analysisVO.setAccuracy(BigDecimal.ZERO);
@@ -1115,7 +1115,7 @@
}
/**
- * 更新习题选项图片对象结果
+ * 鏇存柊涔犻閫夐」鍥剧墖瀵硅薄缁撴灉
*
* @param optionId
* @param imgIds
@@ -1139,7 +1139,7 @@
}
/**
- * 更新习题选项图片对象结果
+ * 鏇存柊涔犻閫夐」鍥剧墖瀵硅薄缁撴灉
*
* @param optionId
* @param imgIds
@@ -1163,13 +1163,13 @@
}
/**
- * 处理exerciseItem
+ * 澶勭悊exerciseItem
*
* @param groupId
* @param item
*/
private void handlerExerciseItem(ExerciseGroup group, ExerciseItem item) {
- // 如果是章节练习，将章节写到exerciseItem
+ // 濡傛灉鏄珷鑺傜粌涔狅紝灏嗙珷鑺傚啓鍒癳xerciseItem
if (ExerciseGroup.TYPE_CHAPTER_ITEM == group.getType()) {
item.setChapterId(group.getAttribute2());
}
@@ -1186,7 +1186,7 @@
}
/**
- * 刪除练习关联表数据
+ * 鍒櫎缁冧範鍏宠仈琛ㄦ暟鎹�
*
* @param reIds
* @return
@@ -1201,7 +1201,7 @@
}
/**
- * 删除练习题：只删除关系 (统一班级下，顺序随机 同步删除)
+ * 鍒犻櫎缁冧範棰橈細鍙垹闄ゅ叧绯� (缁熶竴鐝骇涓嬶紝椤哄簭闅忔満 鍚屾鍒犻櫎)
*
* @param exerciceIds
* @param reIds
@@ -1212,30 +1212,30 @@
public Result deleteExerciseItems(String[] exerciceIds, String[] reIds, String groupId) {
ExerciseGroup group = this.read(ExerciseGroup.class, groupId);
- // 1.更新组练习数量值 总量减去本次删除个数
+ // 1.鏇存柊缁勭粌涔犳暟閲忓�� 鎬婚噺鍑忓幓鏈鍒犻櫎涓暟
group.setAllCount(group.getAllCount().subtract(new BigInteger(String.valueOf(exerciceIds.length))));
TraceUtils.setUpdateTrace(group);
this.save(group);
- // 2.删除练习组关联表数据
+ // 2.鍒犻櫎缁冧範缁勫叧鑱旇〃鏁版嵁
deleteExerciseGroupRe(reIds);
- // 3.重新排序此组的字段
+ // 3.閲嶆柊鎺掑簭姝ょ粍鐨勫瓧娈�
updateExerciseItemNewNo(groupId);
- //清除缓存
+ //娓呴櫎缂撳瓨
redisTemplate.delete(groupId);
return new Result(true);
}
/**
- * 重新排序
+ * 閲嶆柊鎺掑簭
*
* @param groupId
* @return
*/
private Result updateExerciseItemNewNo(String groupId) {
- // 升序排序
+ // 鍗囧簭鎺掑簭
String hql = "from ExerciseGroupItemRe re " + "where re.exerciseGroupId=? " + "and re.deleteFlag is false " + "order by re.itemOrder asc ";
List<ExerciseGroupItemRe> lstRe = this.find(hql, CollectionUtils.newList(groupId), ExerciseGroupItemRe.class);
@@ -1244,7 +1244,7 @@
return null;
}
- // 重新排序
+ // 閲嶆柊鎺掑簭
for (int i = 0; i < lstRe.size(); i++) {
lstRe.get(i).setItemOrder(i + 1);
}
@@ -1255,7 +1255,7 @@
}
/**
- * 根据groupId 和 itemId 读取 ExerciseGroupItemRe
+ * 鏍规嵁groupId 鍜� itemId 璇诲彇 ExerciseGroupItemRe
*
* @param groupId
* @param itemId
@@ -1270,7 +1270,7 @@
*/
/**
- * 查询最近的记录
+ * 鏌ヨ鏈�杩戠殑璁板綍
*
* @param hql
* @param page
@@ -1291,20 +1291,20 @@
items = parseFile(file);
} catch (Exception e) {
log.error(e, e);
- return new Result(false, "读取文档失败");
+ return new Result(false, "璇诲彇鏂囨。澶辫触");
}
insertItems(groupId, items);
- // 4.20150618：配合前台app，所有修改同时修改group表最后修改时间
+ // 4.20150618锛氶厤鍚堝墠鍙癮pp锛屾墍鏈変慨鏀瑰悓鏃朵慨鏀筭roup琛ㄦ渶鍚庝慨鏀规椂闂�
List<ExerciseGroup> result = initExerciseGroup(groupId);
updateGroupUpdateTimeByList(result);
FileUtils.deleteQuietly(file.getParentFile());
- return new Result(true, "已导入" + items.size() + "道习题");
+ return new Result(true, "宸插鍏�" + items.size() + "閬撲範棰�");
}
/**
- * 插入习题
+ * 鎻掑叆涔犻
*
* @param items
*/
@@ -1312,12 +1312,12 @@
int i = 0;
- // 获取一个习题需要跟新的关系条数
+ // 鑾峰彇涓�涓範棰橀渶瑕佽窡鏂扮殑鍏崇郴鏉℃暟
List<ExerciseGroup> result = initExerciseGroup(groupId);
ExerciseGroup group = this.read(ExerciseGroup.class, groupId);
- // 得到当前组题目的最大题号
+ // 寰楀埌褰撳墠缁勯鐩殑鏈�澶ч鍙�
int maxGroupItemOrder = queryExerciseGroupItemNo(groupId);
/*String hql = " from ExerciseGroup where originExerciseId = ? and deleteFlag is false and groupId != ?";
@@ -1327,16 +1327,16 @@
TraceUtils.setCreateTrace(item);
item.setDeleteFlag(false);
- // 1. 习题
+ // 1. 涔犻
handlerExerciseItem(group, item);
save(item);
- // 2. 保存习题组-习题关系(练习和非练习)
+ // 2. 淇濆瓨涔犻缁�-涔犻鍏崇郴(缁冧範鍜岄潪缁冧範)
List<ExerciseGroupItemRe> groupRes = initExerciseGroupItemRe(result, item.getExerciseId(), item.getItemNo() == null ? i++ : item.getItemNo(), ++maxGroupItemOrder );
saveOrUpdateAll(groupRes);
if(StringUtils.isEmpty(group.getClassId())){
- // 同步习题
+ // 鍚屾涔犻
String hql = " from ExerciseGroup where originExerciseId = ? and deleteFlag is false and groupId != ?";
List<ExerciseGroup> lstGroup = find(hql, CollectionUtils.newList(group.getOriginExerciseId(), groupId), ExerciseGroup.class);
List<ExerciseItem> lstItems = find("from ExerciseItem where exerciseId = ?", CollectionUtils.newList(item.getExerciseId()), ExerciseItem.class);
@@ -1348,16 +1348,16 @@
this.doCopyExerciseItem(exerciseGroup.getGroupId(), groupId, lstItems, 2);
} catch (IllegalAccessException | InstantiationException | InvocationTargetException
| NoSuchMethodException e) {
- log.error("新增练习同步到班级错误", e);
+ log.error("鏂板缁冧範鍚屾鍒扮彮绾ч敊璇�", e);
}
}
}
- // 3. 保存习题解析
+ // 3. 淇濆瓨涔犻瑙ｆ瀽
if (item.getAnalisis() != null) {
saveAnalysis(item);
}
- // 4. 保存习题选项
+ // 4. 淇濆瓨涔犻閫夐」
for (ExerciseItemOption option : item.getOptions()) {
TraceUtils.setCreateTrace(option);
option.setDeleteFlag(false);
@@ -1369,7 +1369,7 @@
}
/**
- * 保存习题解析
+ * 淇濆瓨涔犻瑙ｆ瀽
*
* @param item
*/
@@ -1387,12 +1387,12 @@
}
/**
- * 解析word
+ * 瑙ｆ瀽word
*
* @param groupId
- * 习题组id
+ * 涔犻缁刬d
* @param file
- * word文件绝对路径
+ * word鏂囦欢缁濆璺緞
* @return
* @throws RuntimeException
*/
@@ -1400,7 +1400,7 @@
Handler handler = new Handler();
- // from office to txt,docx:自带序号无法解析出来,doc可以
+ // from office to txt,docx:鑷甫搴忓彿鏃犳硶瑙ｆ瀽鍑烘潵,doc鍙互
String txtFilePath = transformDocToTxt(file);
@@ -1415,7 +1415,7 @@
handler.parse(currLine);
}
} catch (Exception e) {
- throw new Exception("读取文档失败", e);
+ throw new Exception("璇诲彇鏂囨。澶辫触", e);
} finally {
IOUtils.closeQuietly(br);
IOUtils.closeQuietly(reader);
@@ -1426,10 +1426,10 @@
}
/**
- * 从office转换到txt：2007转换：自带序号格式会丢失；2003会解析出来
+ * 浠巓ffice杞崲鍒皌xt锛�2007杞崲锛氳嚜甯﹀簭鍙锋牸寮忎細涓㈠け锛�2003浼氳В鏋愬嚭鏉�
*
* @param file
- * office文档
+ * office鏂囨。
* @return
*/
private String transformDocToTxt(File file) {
@@ -1443,23 +1443,23 @@
if ("doc".equals(fileExtention)) {
WordExtractor extractor = new WordExtractor(fis);
- // 获取Word文件中的文本+自带序号
+ // 鑾峰彇Word鏂囦欢涓殑鏂囨湰+鑷甫搴忓彿
strText = extractor.getText();
extractor.close();
} else if ("docx".equals(fileExtention)) {
OPCPackage opcPackage = POIXMLDocument.openPackage(file.getAbsolutePath());
POIXMLTextExtractor extractor = new XWPFWordExtractor(opcPackage);
- // 只能获取Word文件中的文本，不能取到office序号
+ // 鍙兘鑾峰彇Word鏂囦欢涓殑鏂囨湰锛屼笉鑳藉彇鍒皁ffice搴忓彿
strText = extractor.getText();
extractor.close();
} else {
- throw new RuntimeException("文件格式错误, 请上传word文档（.doc及.docx）格式", null);
+ throw new RuntimeException("鏂囦欢鏍煎紡閿欒, 璇蜂笂浼爓ord鏂囨。锛�.doc鍙�.docx锛夋牸寮�", null);
}
- // 将得到的文本全角转半角
+ // 灏嗗緱鍒扮殑鏂囨湰鍏ㄨ杞崐瑙�
strText = formatFullToHalf(strText);
- // 解决空格保存为txt的时候，乱码为？
+ // 瑙ｅ喅绌烘牸淇濆瓨涓簍xt鐨勬椂鍊欙紝涔辩爜涓猴紵
byte bytes[] = { (byte) 0xC2, (byte) 0xA0 };
String UTFSpace = new String(bytes, "UTF-8");
strText = strText.replaceAll(UTFSpace, " ");
@@ -1471,9 +1471,9 @@
return txtFile.getAbsolutePath();
} catch (FileNotFoundException e) {
- throw new RuntimeException("office文档未找到", e);
+ throw new RuntimeException("office鏂囨。鏈壘鍒�", e);
} catch (IOException e) {
- throw new RuntimeException("office文档读取失败", e);
+ throw new RuntimeException("office鏂囨。璇诲彇澶辫触", e);
} catch (Exception e) {
throw new RuntimeException(e.getMessage(), e);
} finally {
@@ -1483,7 +1483,7 @@
}
/**
- * 全角转半角
+ * 鍏ㄨ杞崐瑙�
*
* @param oriText
* @return
@@ -1494,23 +1494,23 @@
}
char[] charArray = oriText.toCharArray();
- // 对全角字符转换的char数组遍历
+ // 瀵瑰叏瑙掑瓧绗﹁浆鎹㈢殑char鏁扮粍閬嶅巻
for (int i = 0; i < charArray.length; ++i) {
int charIntValue = (int) charArray[i];
- // 如果符合转换关系,将对应下标之间减掉偏移量65248;如果是空格的话,直接做转换
+ // 濡傛灉绗﹀悎杞崲鍏崇郴,灏嗗搴斾笅鏍囦箣闂村噺鎺夊亸绉婚噺65248;濡傛灉鏄┖鏍肩殑璇�,鐩存帴鍋氳浆鎹�
if (charIntValue >= 65281 && charIntValue <= 65374) {
charArray[i] = (char) (charIntValue - 65248);
} else if (charIntValue == 12288) {
charArray[i] = (char) 32;
} else if (charIntValue == 58033) {
- // 空格
+ // 绌烘牸
charArray[i] = (char) 32;
} else if (charIntValue == 65380) {
- // 顿号
+ // 椤垮彿
charArray[i] = (char) 12289;
} else if (charIntValue == 65377) {
- // 句号
+ // 鍙ュ彿
charArray[i] = (char) 12290;
}
}
@@ -1519,7 +1519,7 @@
}
/**
- * 解析文件后缀
+ * 瑙ｆ瀽鏂囦欢鍚庣紑
*
* @param filename
* @return
@@ -1536,9 +1536,9 @@
*/
@Override
public Result updateExerciseItem(ExerciseItem item, List<ExerciseItemOption> lstOptions, String analysis) {
- //先删除所有的option，然后恢复已有的option
+ //鍏堝垹闄ゆ墍鏈夌殑option锛岀劧鍚庢仮澶嶅凡鏈夌殑option
this.bulkUpdate("update ExerciseItemOption set deleteFlag = true where exerciseItemId=?", new String[]{item.getExerciseId()});
- // 保存Option
+ // 淇濆瓨Option
String answer = "";
if(lstOptions!=null){
for (ExerciseItemOption option : lstOptions) {
@@ -1562,20 +1562,20 @@
}
- // 保存item
+ // 淇濆瓨item
if(StringUtils.isNotBlank(answer)){
item.setAnswer(answer.substring(0,answer.length()-1));
}
TraceUtils.setCreateTrace(item);
save(item);
- // 保存解析
+ // 淇濆瓨瑙ｆ瀽
updateItemAnalysis(item, analysis);
- // 配合前台app，所有修改同时修改group表最后修改时间
+ // 閰嶅悎鍓嶅彴app锛屾墍鏈変慨鏀瑰悓鏃朵慨鏀筭roup琛ㄦ渶鍚庝慨鏀规椂闂�
// updateGroupUpdateTimeByList(initUpdateExerciseGroup(item.getExerciseId()));
- //保存题目分数
+ //淇濆瓨棰樼洰鍒嗘暟
List<ExerciseItemScore> lstExerciseItemScore = item.getScores();
if(lstExerciseItemScore!=null && lstExerciseItemScore.size()>0){
for (ExerciseItemScore score : lstExerciseItemScore) {
@@ -1588,7 +1588,7 @@
}
/*
- * 评价模块修改题目
+ * 璇勪环妯″潡淇敼棰樼洰
*/
@Override
public ResultJson updateExerciseItem4Evaluate(ExerciseItem item,
@@ -1597,7 +1597,7 @@
TraceUtils.setUpdateTrace(item);
-/* // 先移除全部习题
+/* // 鍏堢Щ闄ゅ叏閮ㄤ範棰�
QExerciseItemOption qOption = QExerciseItemOption.exerciseItemOption;
this.getQueryFactory()
.update(qOption)
@@ -1605,7 +1605,7 @@
.where(qOption.exerciseItemId.eq(item.getExerciseId()))
.execute();
- // 移除全部分数
+ // 绉婚櫎鍏ㄩ儴鍒嗘暟
QExerciseItemScore qScore = QExerciseItemScore.exerciseItemScore;
this.getQueryFactory()
.update(qScore)
@@ -1613,14 +1613,14 @@
.where(qScore.exerciseItemId.eq(item.getExerciseId()))
.execute();*/
- // 先移除全部习题
+ // 鍏堢Щ闄ゅ叏閮ㄤ範棰�
String hql = "update ExerciseItemOption set DELETE_FLAG = 1 where EXERCISE_ITEM_ID = ?";
super.bulkUpdateInLoop(hql, new String[] { item.getExerciseId() });
- // 移除全部分数
+ // 绉婚櫎鍏ㄩ儴鍒嗘暟
String hql2 = "update ExerciseItemScore set DELETE_FLAG = 1 where EXERCISE_ITEM_ID = ?";
super.bulkUpdateInLoop(hql2, new String[] { item.getExerciseId() });
- // 1.保存item
+ // 1.淇濆瓨item
this.save(item);
if(lstOptions != null && lstOptions.size() > 0) {
TraceUtils.setCreateTrace(lstOptions);
@@ -1644,7 +1644,7 @@
}
}
- // 4. 更新习题解析
+ // 4. 鏇存柊涔犻瑙ｆ瀽
QExerciseItemAnalisi analysisVO = QExerciseItemAnalisi.exerciseItemAnalisi;
this.getQueryFactory()
.update(analysisVO)
@@ -1657,7 +1657,7 @@
}
/**
- * 更新解析
+ * 鏇存柊瑙ｆ瀽
*
* @param item
* @param analysis
@@ -1687,17 +1687,17 @@
}
/**
- * 组装ExerciseGroup的list,传入一个groupid，得到同时需要修改的一个或者多个group对象
+ * 缁勮ExerciseGroup鐨刲ist,浼犲叆涓�涓猤roupid锛屽緱鍒板悓鏃堕渶瑕佷慨鏀圭殑涓�涓垨鑰呭涓猤roup瀵硅薄
*
* @param groupId
- * 主键
+ * 涓婚敭
* @return
*/
@Override
public List<ExerciseGroup> initExerciseGroup(String groupId) {
- // 0.获取groupID对应的type，如果是习题（顺机序、随和章节，需要按不同情况同时更新）
- // 1.如果是章节练习，需要同步修改顺序随机练习
- // 2.如果是顺序，需同步修改随机；如果是随机练习亦然
+ // 0.鑾峰彇groupID瀵瑰簲鐨則ype锛屽鏋滄槸涔犻锛堥『鏈哄簭銆侀殢鍜岀珷鑺傦紝闇�瑕佹寜涓嶅悓鎯呭喌鍚屾椂鏇存柊锛�
+ // 1.濡傛灉鏄珷鑺傜粌涔狅紝闇�瑕佸悓姝ヤ慨鏀归『搴忛殢鏈虹粌涔�
+ // 2.濡傛灉鏄『搴忥紝闇�鍚屾淇敼闅忔満锛涘鏋滄槸闅忔満缁冧範浜︾劧
ExerciseGroup group = read(ExerciseGroup.class, groupId);
List<ExerciseGroup> result = new ArrayList<ExerciseGroup>();
short sType = 0;
@@ -1716,14 +1716,14 @@
}
/**
- * 组装ExerciseGroup的list,传入一个groupid，得到同时需要修改的一个或者多个group对象
+ * 缁勮ExerciseGroup鐨刲ist,浼犲叆涓�涓猤roupid锛屽緱鍒板悓鏃堕渶瑕佷慨鏀圭殑涓�涓垨鑰呭涓猤roup瀵硅薄
*
* @param groupId
- * 主键
+ * 涓婚敭
* @return
*/
public List<ExerciseGroup> initUpdateExerciseGroup(String exerciseId) {
- // 修改关联的exerciseId，deleteflag is false（暂时全部处理）
+ // 淇敼鍏宠仈鐨別xerciseId锛宒eleteflag is false锛堟殏鏃跺叏閮ㄥ鐞嗭級
List<ExerciseGroup> lstGroup = new ArrayList<ExerciseGroup>();
String hql = "select e.exerciseGroupId from ExerciseGroupItemRe e where deleteFlag is false and e.exerciseItemId = ? ";
@@ -1745,25 +1745,25 @@
}
/**
- * 批量删除ExerciseGroup，删除逻辑：如果是练习，顺序和随机练习时同步删除的(此处代码)
+ * 鎵归噺鍒犻櫎ExerciseGroup锛屽垹闄ら�昏緫锛氬鏋滄槸缁冧範锛岄『搴忓拰闅忔満缁冧範鏃跺悓姝ュ垹闄ょ殑(姝ゅ浠ｇ爜)
*
* @param groupId
- * 主键，多个id时以","分隔
+ * 涓婚敭锛屽涓猧d鏃朵互","鍒嗛殧
* @return
*/
public Result deleteExerciseGroup(String groupId) {
- // 逻辑删除，只需要修改exercise_group、exercise_item的删除标识即可
+ // 閫昏緫鍒犻櫎锛屽彧闇�瑕佷慨鏀筫xercise_group銆乪xercise_item鐨勫垹闄ゆ爣璇嗗嵆鍙�
if (StringUtils.isNotBlank(groupId)) {
- // 需要删除的练习组
+ // 闇�瑕佸垹闄ょ殑缁冧範缁�
Object[] arrGroupId = groupId.split(",");
- // 存储顺序练习或者随机练习
+ // 瀛樺偍椤哄簭缁冧範鎴栬�呴殢鏈虹粌涔�
List<ExerciseGroup> lstResults = initDeleteExerciseGroup(arrGroupId);
- // 需要删除的练习类型下的练习题
+ // 闇�瑕佸垹闄ょ殑缁冧範绫诲瀷涓嬬殑缁冧範棰�
//List<ExerciseItem> lstItem = initDeleteExerciseItem(lstResults);
- // 删除习题组,修改习题组最后修改时间
+ // 鍒犻櫎涔犻缁�,淇敼涔犻缁勬渶鍚庝慨鏀规椂闂�
if (lstResults != null) {
for (ExerciseGroup group : lstResults) {
group.setDeleteFlag(true);
@@ -1774,37 +1774,37 @@
}
}
- /*// 删除习题
+ /*// 鍒犻櫎涔犻
if (lstItem != null) {
for (ExerciseItem item : lstItem) {
item.setDeleteFlag(true);
}
saveOrUpdateAll(lstItem);
}*/
- // 20150618：配合前台app，所有修改同时修改group表最后修改时间
+ // 20150618锛氶厤鍚堝墠鍙癮pp锛屾墍鏈変慨鏀瑰悓鏃朵慨鏀筭roup琛ㄦ渶鍚庝慨鏀规椂闂�
//updateGroupUpdateTimeByList(lstResults);
}
return new Result(true);
}
/**
- * 组装练习组
+ * 缁勮缁冧範缁�
*
* @param name
- * 练习名称
+ * 缁冧範鍚嶇О
* @param type
- * 练习组类型
+ * 缁冧範缁勭被鍨�
* @param lessonId
- * 课程
+ * 璇剧▼
* @param chapterId
- * 章节
+ * 绔犺妭
* @return
*/
private List<ExerciseGroup> initExerciseGroupList(String name, short type, String lessonId, String chapterId, int iCount) {
List<ExerciseGroup> lstExerciseGroup = new ArrayList<ExerciseGroup>();
List<Short> lstType = new ArrayList<Short>();
- // iCount:0、 新增三种(选择了章节)，增加两种：没有选择章节；1，新增两种（顺序随机），2，新增一种（章节），3的话，不增加
+ // iCount:0銆� 鏂板涓夌(閫夋嫨浜嗙珷鑺�)锛屽鍔犱袱绉嶏細娌℃湁閫夋嫨绔犺妭锛�1锛屾柊澧炰袱绉嶏紙椤哄簭闅忔満锛夛紝2锛屾柊澧炰竴绉嶏紙绔犺妭锛夛紝3鐨勮瘽锛屼笉澧炲姞
if (type == ExerciseGroup.TYPE_EXERCISE_SEQUENCE) {
if (iCount == 0) {
lstType.add(type);
@@ -1817,7 +1817,7 @@
lstType.add(ExerciseGroup.TYPE_EXERCISE_RANDOM);
} else if (iCount == 2) {
lstType.add(ExerciseGroup.TYPE_CHAPTER_ITEM);
- } else if (iCount == 3 && StringUtils.isNotBlank(chapterId)) {// 等于3，章节练习，顺序练习，随机练习都有，增加章节练习
+ } else if (iCount == 3 && StringUtils.isNotBlank(chapterId)) {// 绛変簬3锛岀珷鑺傜粌涔狅紝椤哄簭缁冧範锛岄殢鏈虹粌涔犻兘鏈夛紝澧炲姞绔犺妭缁冧範
lstType.add(ExerciseGroup.TYPE_CHAPTER_ITEM);
}
} else {
@@ -1831,20 +1831,20 @@
}
/**
- * 组装练习
+ * 缁勮缁冧範
*
* @param name
- * 练习名称
+ * 缁冧範鍚嶇О
* @param type
- * 练习类型
+ * 缁冧範绫诲瀷
* @param lessonId
- * 课程
+ * 璇剧▼
* @param chapterId
- * 章节
+ * 绔犺妭
* @return
*/
private ExerciseGroup initExerciseGroup(String name, short type, String lessonId, String chapterId) {
- // 构建实体
+ // 鏋勫缓瀹炰綋
ExerciseGroup objExerciseGroup = new ExerciseGroup();
TraceUtils.setCreateTrace(objExerciseGroup);
@@ -1853,9 +1853,9 @@
objExerciseGroup.setSubjectId(lessonId);
objExerciseGroup.setChapterId(chapterId);
if (ExerciseGroup.TYPE_EXERCISE_RANDOM == type) {
- objExerciseGroup.setName("随机练习");
+ objExerciseGroup.setName("闅忔満缁冧範");
} else if (ExerciseGroup.TYPE_EXERCISE_SEQUENCE == type) {
- objExerciseGroup.setName("顺序练习");
+ objExerciseGroup.setName("椤哄簭缁冧範");
} else {
objExerciseGroup.setName(name);
}
@@ -1864,25 +1864,25 @@
objExerciseGroup.setClassId(ClientUtils.getClassId());
objExerciseGroup.setOrgId(ClientUtils.getOrgId());
objExerciseGroup.setCollegeCourseId(ClientUtils.getCourseId());
- // 章节练习需要存储
+ // 绔犺妭缁冧範闇�瑕佸瓨鍌�
if (type == ExerciseGroup.TYPE_CHAPTER_ITEM) {
- // 章节练习存放lessonId
+ // 绔犺妭缁冧範瀛樻斁lessonId
//objExerciseGroup.setAttribute1(lessonId);
- // 章节练习存放chapterID
+ // 绔犺妭缁冧範瀛樻斁chapterID
objExerciseGroup.setAttribute2(chapterId);
}
return objExerciseGroup;
}
/**
- * 组装关联信息
+ * 缁勮鍏宠仈淇℃伅
*
* @param lstGroup
- * 练习组
+ * 缁冧範缁�
* @param itemId
- * 练习题id
+ * 缁冧範棰榠d
* @param itemOrder
- * 练习题序号
+ * 缁冧範棰樺簭鍙�
* @return
*/
private List<ExerciseGroupItemRe> initExerciseGroupItemRe(List<ExerciseGroup> lstGroup, String itemId, int docOrder,int maxGroupItemOrder) {
@@ -1904,7 +1904,7 @@
}
/**
- * 查询当前组的最大题号
+ * 鏌ヨ褰撳墠缁勭殑鏈�澶ч鍙�
*
* @param groupId
* @return
@@ -1923,14 +1923,14 @@
}
/**
- * 组装需要删除的练习组
+ * 缁勮闇�瑕佸垹闄ょ殑缁冧範缁�
*
* @param lstResult
- * 存储非顺序 练习非随机练习
+ * 瀛樺偍闈為『搴� 缁冧範闈為殢鏈虹粌涔�
* @param lstResults
- * 存储顺序练习或者随机练习
+ * 瀛樺偍椤哄簭缁冧範鎴栬�呴殢鏈虹粌涔�
* @param arrGroupId
- * groupid的数组
+ * groupid鐨勬暟缁�
*/
private List<ExerciseGroup> initDeleteExerciseGroup(Object[] arrGroupId) {
List<ExerciseGroup> lstResults = new ArrayList<ExerciseGroup>();
@@ -1941,7 +1941,7 @@
}
hsql = hsql.concat("? ) ");
List<ExerciseGroup> result = find(hsql, CollectionUtils.newList(arrGroupId), ExerciseGroup.class);
- // 一个班级只有一个顺序练习和一个随机练习
+ // 涓�涓彮绾у彧鏈変竴涓『搴忕粌涔犲拰涓�涓殢鏈虹粌涔�
int iNumber = 0;
for (ExerciseGroup group : result) {
if (group.getType() == ExerciseGroup.TYPE_EXERCISE_SEQUENCE || group.getType() == ExerciseGroup.TYPE_EXERCISE_RANDOM) {
@@ -1951,7 +1951,7 @@
lstResult.add(group);
}
}
- // 一个班级只选择了顺序或者只选择了随机，两个类型都需要删除
+ // 涓�涓彮绾у彧閫夋嫨浜嗛『搴忔垨鑰呭彧閫夋嫨浜嗛殢鏈猴紝涓や釜绫诲瀷閮介渶瑕佸垹闄�
if (iNumber == 1) {
hsql = "from ExerciseGroup where type in (?,?) and classId = ? and deleteFlag is false ";
lstResults = find(hsql, CollectionUtils.newList(ExerciseGroup.TYPE_EXERCISE_SEQUENCE, ExerciseGroup.TYPE_EXERCISE_RANDOM, lstResults.get(0).getClassId()), ExerciseGroup.class);
@@ -1962,10 +1962,10 @@
}
/**
- * 获取需要删除的练习题(删除习题组时调用)
+ * 鑾峰彇闇�瑕佸垹闄ょ殑缁冧範棰�(鍒犻櫎涔犻缁勬椂璋冪敤)
*
* @param lstResults
- * 需要删除的练习组
+ * 闇�瑕佸垹闄ょ殑缁冧範缁�
*//*
private List<ExerciseItem> initDeleteExerciseItem(List<ExerciseGroup> lstResults) {
String hsql = "from ExerciseItem where exerciseId in ( select exerciseItemId from ExerciseGroupItemRe " + " where deleteFlag is false and exerciseGroupId in ( ";
@@ -1977,14 +1977,14 @@
arrGroupId.add(lstResults.get(i).getGroupId());
}
- // 需要删除的练习题（为练习类型时）
+ // 闇�瑕佸垹闄ょ殑缁冧範棰橈紙涓虹粌涔犵被鍨嬫椂锛�
hsql = hsql.concat("? ) group by exerciseItemId having count(1) = 3 )");
- // 这个SQL特别慢
+ // 杩欎釜SQL鐗瑰埆鎱�
List<ExerciseItem> lstItem = find(hsql, arrGroupId, ExerciseItem.class);
List<ExerciseItem> lstItems = new ArrayList<ExerciseItem>();
- // 剔除顺序，随机、章节练习
+ // 鍓旈櫎椤哄簭锛岄殢鏈恒�佺珷鑺傜粌涔�
List<Object> lstParams = new ArrayList<Object>();
for (ExerciseGroup group : lstResults) {
if (group.getType() != ExerciseGroup.TYPE_EXERCISE_SEQUENCE && group.getType() != ExerciseGroup.TYPE_CHAPTER_ITEM && group.getType() != ExerciseGroup.TYPE_EXERCISE_RANDOM) {
@@ -1999,7 +1999,7 @@
hsql =hsql.concat( "? ) )");
lstItems = find(hsql, lstParams, ExerciseItem.class);
}
- // 需要删除的习题
+ // 闇�瑕佸垹闄ょ殑涔犻
if (lstItem != null) {
lstItem.addAll(lstItems);
}
@@ -2007,7 +2007,7 @@
}*/
/**
- * ：后台 插入评估模板时调用
+ * 锛氬悗鍙� 鎻掑叆璇勪及妯℃澘鏃惰皟鐢�
*
* @param name
* @param type
@@ -2023,12 +2023,12 @@
obj.setOrgId(ClientUtils.getOrgId());
save(obj);
- // 保存
+ // 淇濆瓨
return obj;
}
/**
- * 查询练习列表，还需查询联系下面习题个数
+ * 鏌ヨ缁冧範鍒楄〃锛岃繕闇�鏌ヨ鑱旂郴涓嬮潰涔犻涓暟
*
* @param hql
* @param args
@@ -2039,7 +2039,7 @@
}
/**
- * 所有练习修改操作需要同时修改group的updateTime
+ * 鎵�鏈夌粌涔犱慨鏀规搷浣滈渶瑕佸悓鏃朵慨鏀筭roup鐨剈pdateTime
*
* @param lstGroup
*/
@@ -2057,12 +2057,12 @@
}
/**
- * 后台：批量删除ExerciseGroup
+ * 鍚庡彴锛氭壒閲忓垹闄xerciseGroup
*
* @param groupId
- * 主键，多个id时以","分隔
+ * 涓婚敭锛屽涓猧d鏃朵互","鍒嗛殧
* @param type
- * 多个type时以","分隔
+ * 澶氫釜type鏃朵互","鍒嗛殧
* @return
*/
public Result deleteExerciseGroup(String groupId, String type, String deleteType,Integer delAll, String orgIds[], String classIds[]) {
@@ -2075,13 +2075,13 @@
return new Result(false);
}
if ("org".equals(deleteType)) {
- //管理员删除练习
+ //绠＄悊鍛樺垹闄ょ粌涔�
deleteOrgGroup(groupIds,delAll,orgIds,classIds);
return new Result(true);
}
- // 删除逻辑：练习和其他分开处理(SQL执行简单)
- // 删除练习：随机和顺序是一致的；如果只删除随机或者顺序，只删除章节，则只删除习题组；如果只删除章节：同样只删除组
- // 删除时：顺序或者随机+章节：删除组+章节对应的习题
+ // 鍒犻櫎閫昏緫锛氱粌涔犲拰鍏朵粬鍒嗗紑澶勭悊(SQL鎵ц绠�鍗�)
+ // 鍒犻櫎缁冧範锛氶殢鏈哄拰椤哄簭鏄竴鑷寸殑锛涘鏋滃彧鍒犻櫎闅忔満鎴栬�呴『搴忥紝鍙垹闄ょ珷鑺傦紝鍒欏彧鍒犻櫎涔犻缁勶紱濡傛灉鍙垹闄ょ珷鑺傦細鍚屾牱鍙垹闄ょ粍
+ // 鍒犻櫎鏃讹細椤哄簭鎴栬�呴殢鏈�+绔犺妭锛氬垹闄ょ粍+绔犺妭瀵瑰簲鐨勪範棰�
boolean randomFlag = false;
boolean chapterFlag = false;
@@ -2093,7 +2093,7 @@
chapterFlag = true;
}
- // 拆除子方法
+ // 鎷嗛櫎瀛愭柟娉�
Result result = deleteChildExerciseGroup(groupIds, types, randomFlag, chapterFlag);
if(!result.isSuccess()){
@@ -2105,7 +2105,7 @@
}
/**
- * 拆除子方法
+ * 鎷嗛櫎瀛愭柟娉�
* @param groupIds
* @param types
* @param randomFlag
@@ -2114,15 +2114,15 @@
*/
private Result deleteChildExerciseGroup(String[] groupIds, String[] types,
boolean randomFlag, boolean chapterFlag) {
- // 1. 无练习
+ // 1. 鏃犵粌涔�
if (!randomFlag && !chapterFlag) {
return deleteExercise(groupIds, groupIds);
}
- // 2. 有随机有章节
+ // 2. 鏈夐殢鏈烘湁绔犺妭
if (randomFlag && chapterFlag) {
return deleteExerciseAll(groupIds);
}
- // 3.1. 随机、章节只有一种,删除组:第一种情况：保证顺序随机一致；第二种：删除章节
+ // 3.1. 闅忔満銆佺珷鑺傚彧鏈変竴绉�,鍒犻櫎缁�:绗竴绉嶆儏鍐碉細淇濊瘉椤哄簭闅忔満涓�鑷达紱绗簩绉嶏細鍒犻櫎绔犺妭
if (randomFlag) {
return deleteExerciseSequence(groupIds, types);
}
@@ -2132,7 +2132,7 @@
private void deleteOrgGroup(String groupIds[],Integer delAll, String orgIds[], String classIds[]){
for (String string : groupIds) {
if ((orgIds != null && orgIds.length != 0) || (classIds != null && classIds.length != 0)) {
- //删除要回撤的练习
+ //鍒犻櫎瑕佸洖鎾ょ殑缁冧範
deleteAppoint(string,orgIds,classIds);
}else{
String hql = " from ExerciseReCourse where groupId = ? and deleteFlag is false and orgId = ?";
@@ -2151,7 +2151,7 @@
this.saveExerciseGroup(group);
}*/
if(delAll==1){
- //删除下级
+ //鍒犻櫎涓嬬骇
deleteSub(string,ClientUtils.getOrgId());
}
}
@@ -2162,7 +2162,7 @@
@SuppressWarnings("unchecked")
private void deleteSub(String groupId,String currOrgId){
- // 机构层级视频是没有重新new ，查询出机构下级ID再删关联表
+ // 鏈烘瀯灞傜骇瑙嗛鏄病鏈夐噸鏂皀ew 锛屾煡璇㈠嚭鏈烘瀯涓嬬骇ID鍐嶅垹鍏宠仈琛�
String sql = " select oa.organization_id from organization as oa,organization ob " +
" where " +
" ob.ORGANIZATION_ID = ? " +
@@ -2184,7 +2184,7 @@
this.save(groupCourse);
}
- // 班主任层面视频指定过后都是new 出来的，通过originVideoId 可以查出所有指定过去的视频
+ // 鐝富浠诲眰闈㈣棰戞寚瀹氳繃鍚庨兘鏄痭ew 鍑烘潵鐨勶紝閫氳繃originVideoId 鍙互鏌ュ嚭鎵�鏈夋寚瀹氳繃鍘荤殑瑙嗛
hql = "select classId from ClsClass where orgId in (:orgIds) and deleteFlag is false";
map = new HashMap<String, Object>();
map.put("orgIds", orgIds.toArray());
@@ -2205,7 +2205,7 @@
private Result deleteAppoint(String groupId,String orgIds[],String classIds[]){
Map<String, Object> args = new HashMap<String, Object>();
- // 删除需要回撤的机构视频
+ // 鍒犻櫎闇�瑕佸洖鎾ょ殑鏈烘瀯瑙嗛
if (orgIds.length != 0) {
String hql = " from ExerciseReCourse where groupId = :groupId and deleteFlag is false and orgId in (:orgIds) and orgId != :currOrgId";
@@ -2223,7 +2223,7 @@
}
}
- // 删除需要回撤的班主任视频
+ // 鍒犻櫎闇�瑕佸洖鎾ょ殑鐝富浠昏棰�
if (classIds.length != 0) {
args = new HashMap<String, Object>();
args.put("groupId", groupId);
@@ -2242,7 +2242,7 @@
}
/**
- * 有顺序和章节练习时的删除逻辑
+ * 鏈夐『搴忓拰绔犺妭缁冧範鏃剁殑鍒犻櫎閫昏緫
*
* @param groupIds
* @param types
@@ -2251,14 +2251,14 @@
private Result deleteExerciseAll(String[] groupIds) {
String hql = "select groupId from ExerciseGroup where deleteFlag is false and classId = ? and type in (?,?) ";
List<String> exeGroupId = find(hql, CollectionUtils.newList(ClientUtils.getClassId(), ExerciseGroup.TYPE_EXERCISE_RANDOM, ExerciseGroup.TYPE_EXERCISE_SEQUENCE), String.class);
- // 组
+ // 缁�
exeGroupId.addAll(Arrays.asList(groupIds));
return deleteExercise((String[]) exeGroupId.toArray(new String[exeGroupId.size()]), groupIds);
}
/**
- * 只有順序或者随机时删除逻辑
+ * 鍙湁闋嗗簭鎴栬�呴殢鏈烘椂鍒犻櫎閫昏緫
*
* @param groupIds
* @param types
@@ -2267,10 +2267,10 @@
private Result deleteExerciseSequence(String[] groupIds, String[] types) {
String hql = "select groupId from ExerciseGroup where deleteFlag is false and classId = ? and type in (?,?) ";
List<String> exeGroupId = find(hql, CollectionUtils.newList(ClientUtils.getClassId(), ExerciseGroup.TYPE_EXERCISE_RANDOM, ExerciseGroup.TYPE_EXERCISE_SEQUENCE), String.class);
- // 1.组
+ // 1.缁�
exeGroupId.addAll(Arrays.asList(groupIds));
- // 2.删除题,不处理练习
+ // 2.鍒犻櫎棰�,涓嶅鐞嗙粌涔�
for (int i = 0; i < types.length; i++) {
if (types[i] == String.valueOf(ExerciseGroup.TYPE_EXERCISE_RANDOM) || types[i] == String.valueOf(ExerciseGroup.TYPE_EXERCISE_SEQUENCE)) {
groupIds[i] = "";
@@ -2280,15 +2280,15 @@
}
/**
- * 只有章节练习是的删除逻辑
+ * 鍙湁绔犺妭缁冧範鏄殑鍒犻櫎閫昏緫
*
* @param groupIds
* @param types
* @return
*/
private Result deleteExerciseChapter(String[] groupIds, String[] types) {
- // 1.组 groupIds
- // 2.删除题,不处理练习
+ // 1.缁� groupIds
+ // 2.鍒犻櫎棰�,涓嶅鐞嗙粌涔�
String[] groupItemIds = new String[groupIds.length];
for (int i = 0; i < types.length; i++) {
if (types[i] == String.valueOf(ExerciseGroup.TYPE_CHAPTER_ITEM)) {
@@ -2301,21 +2301,21 @@
}
/**
- * 后台：执行删除习题组操作
+ * 鍚庡彴锛氭墽琛屽垹闄や範棰樼粍鎿嶄綔
*
* @param groupIds
- * 删除组的组id
+ * 鍒犻櫎缁勭殑缁刬d
* @param groupItemIds
- * 需要删除题的组id
+ * 闇�瑕佸垹闄ら鐨勭粍id
* @return
*/
private Result deleteExercise(String[] groupIds, String[] groupItemIds) {
- // 1.删除组
+ // 1.鍒犻櫎缁�
bulkUpdateInLoop("update ExerciseGroup set deleteFlag = true where groupId = ? ", groupIds);
- // 1.删除课件
+ // 1.鍒犻櫎璇句欢
bulkUpdateInLoop("update SchCourseware set deleteFlag = true where id = ? ", groupIds);
- // 2.删除题
+ // 2.鍒犻櫎棰�
bulkUpdateInLoop("update ExerciseGroupItemRe set deleteFlag = true "
+ " where exerciseGroupId = ? and deleteFlag = false ", groupItemIds);
@@ -2323,7 +2323,7 @@
}
/**
- * 发送练习系统通知
+ * 鍙戦�佺粌涔犵郴缁熼�氱煡
*
* @param notice
* @return
@@ -2346,7 +2346,7 @@
*/
/**
- * 添加练习图片
+ * 娣诲姞缁冧範鍥剧墖
*
* @param imgPath
* @param imgObjId
@@ -2356,7 +2356,7 @@
public List<Map<String, Object>> doAddExerciseObjImg(String[] imgPath, String imgObjId, int imgObjType) {
String hql = "from ExerciseObjectImg where deleteFlag is false and exerciseObjectId=? and objectType=? order by imgOrder desc";
- // 查询此练习是否已经存在记录
+ // 鏌ヨ姝ょ粌涔犳槸鍚﹀凡缁忓瓨鍦ㄨ褰�
List<ExerciseObjectImg> lstObjImg = this.find(hql, CollectionUtils.newList(imgObjId, imgObjType), ExerciseObjectImg.class);
int imgOrder = 1;
@@ -2394,7 +2394,7 @@
}
/**
- * 删除图片
+ * 鍒犻櫎鍥剧墖
*/
public Result dodelExerciseObjImg(String imgId) {
@@ -2407,10 +2407,10 @@
}
/**
- * 导入习题：深度解析word文档
+ * 瀵煎叆涔犻锛氭繁搴﹁В鏋恮ord鏂囨。
*
* @param groupId
- * 习题组Id
+ * 涔犻缁処d
* @param file
* @param uuid
* @return
@@ -2422,12 +2422,12 @@
}
/**
- * 新增深度解析记录
+ * 鏂板娣卞害瑙ｆ瀽璁板綍
*
* @param destPath
- * 文件路径
+ * 鏂囦欢璺緞
* @param groupId
- * 习题组ID
+ * 涔犻缁処D
* @return
*/
private Result insertDeepAnalysis(String destPath, String groupId) {
@@ -2461,16 +2461,16 @@
}
/**
- * 导入习题,将解析结果返回到前台
+ * 瀵煎叆涔犻,灏嗚В鏋愮粨鏋滆繑鍥炲埌鍓嶅彴
*
* @param groupId
- * 习题组ID
+ * 涔犻缁処D
* @param file
* @return
*/
public ExerciseParseResult doParseItems(String groupId, String fullPath , String module ) {
- //取得当前上传文件类型
+ //鍙栧緱褰撳墠涓婁紶鏂囦欢绫诲瀷
String filePart[] = fullPath.split("\\.");
String fileType = filePart[filePart.length -1];
String uuid = UUIDUtils.generateUUID();
@@ -2483,13 +2483,13 @@
objResult = parseWordFile(file);
} catch (Exception e) {
log.error(e, e);
- if ("文件格式错误, 请上传word文档（.doc及.docx）格式".equals(e.getMessage())) {
+ if ("鏂囦欢鏍煎紡閿欒, 璇蜂笂浼爓ord鏂囨。锛�.doc鍙�.docx锛夋牸寮�".equals(e.getMessage())) {
return new ExerciseParseResult(false, e.getMessage());
}
- return new ExerciseParseResult(false, "读取文档失败");
+ return new ExerciseParseResult(false, "璇诲彇鏂囨。澶辫触");
}
- //更新上传文件使用轨迹
+ //鏇存柊涓婁紶鏂囦欢浣跨敤杞ㄨ抗
fileUploadService.updateUploadTrace(fullPath, module, SysFileUploadTrace.FILE_USE, groupId);
objResult.setItemCount(objResult.getLstItems().size());
@@ -2504,12 +2504,12 @@
}
/**
- * 解析word
+ * 瑙ｆ瀽word
*
* @param groupId
- * 习题组id
+ * 涔犻缁刬d
* @param file
- * word文件绝对路径
+ * word鏂囦欢缁濆璺緞
* @return
* @throws RuntimeException
*/
@@ -2521,7 +2521,7 @@
Handler handler = new Handler();
- // from office to txt,docx:自带序号无法解析出来,doc可以
+ // from office to txt,docx:鑷甫搴忓彿鏃犳硶瑙ｆ瀽鍑烘潵,doc鍙互
String txtFilePath = transformDocToTxt(file);
FileReader reader = null;
@@ -2548,7 +2548,7 @@
}
} catch (Exception e) {
- throw new Exception("读取文档失败", e);
+ throw new Exception("璇诲彇鏂囨。澶辫触", e);
} finally {
IOUtils.closeQuietly(br);
IOUtils.closeQuietly(reader);
@@ -2563,10 +2563,10 @@
}
/**
- * 导入习题 校验习题，将解析结果返回到前台
+ * 瀵煎叆涔犻 鏍￠獙涔犻锛屽皢瑙ｆ瀽缁撴灉杩斿洖鍒板墠鍙�
*
* @param content
- * 习题文本内容
+ * 涔犻鏂囨湰鍐呭
* @return
*/
public ExerciseParseResult validateExercise(String content) {
@@ -2579,10 +2579,10 @@
}
/**
- * 导入习题：将传回的文本内容解析出来
+ * 瀵煎叆涔犻锛氬皢浼犲洖鐨勬枃鏈唴瀹硅В鏋愬嚭鏉�
*
* @param content
- * 习题文本内容
+ * 涔犻鏂囨湰鍐呭
* @return
*/
private ExerciseParseResult parsePlainText(String content) {
@@ -2622,12 +2622,12 @@
}
/**
- * 导入习题模块 ：导入习题，将解析结果返回到前台
+ * 瀵煎叆涔犻妯″潡 锛氬鍏ヤ範棰橈紝灏嗚В鏋愮粨鏋滆繑鍥炲埌鍓嶅彴
*
* @param content
- * 文本内容
+ * 鏂囨湰鍐呭
* @param groupId
- * 习题组ID
+ * 涔犻缁処D
* @return
*/
// public ExerciseParseResult doImportExercise(String content, String groupId) {
@@ -2642,11 +2642,11 @@
//
// insertItems(groupId, lstItems);
//
-// // 修改习题组最后修改时间
+// // 淇敼涔犻缁勬渶鍚庝慨鏀规椂闂�
// List<ExerciseGroup> result = initExerciseGroup(groupId);
// updateGroupUpdateTimeByList(result);
//
-// // 减少返回数据
+// // 鍑忓皯杩斿洖鏁版嵁
// parseResult.setLstItems(null);
// ONSMsg msg = new ONSMsg(onsProducer.getTopic());
// msg.put("msgType", "SYS_EXER_SAVE");
@@ -2662,24 +2662,24 @@
// }
/**
- * 拷贝练习题
+ * 鎷疯礉缁冧範棰�
*
* @param newGroupId
* @param oldGroupId
*/
public void doCopyExerciseItem(String newGroupId, String oldGroupId) {
- //改用存储过程
+ //鏀圭敤瀛樺偍杩囩▼
Session session = getCommonDAO().getSessionFactory().getCurrentSession();
SQLQuery query = session.createSQLQuery("{call copy_exercise_item(?,?)}");
query.setString(0, newGroupId);
query.setString(1, oldGroupId);
- //执行
+ //鎵ц
query.executeUpdate();
}
/**
- * 复制历史练习
+ * 澶嶅埗鍘嗗彶缁冧範
*
* @param fromClassId
* @return
@@ -2702,7 +2702,7 @@
}
/**
- * 复制习题
+ * 澶嶅埗涔犻
*
* @param sourceGroup
* @param sequenceGroup
@@ -2715,13 +2715,13 @@
ExerciseGroup targetGroup = new ExerciseGroup();
- // 主表：组
+ // 涓昏〃锛氱粍
doSaveCopyGroup(sourceGroup, targetGroup, subjectId, subjectName, chapterId);
- // 关联表： 组 习题
+ // 鍏宠仈琛細 缁� 涔犻
doSaveCopyRe(sourceGroup, targetGroup);
- // 扩展表： extend
+ // 鎵╁睍琛細 extend
doSaveCopyExtend(sourceGroup,targetGroup);
return new Result(true);
@@ -2760,7 +2760,7 @@
}
/**
- * 复制习题时，保存习题组
+ * 澶嶅埗涔犻鏃讹紝淇濆瓨涔犻缁�
*
* @param sourceGroup
* @param targetGroup
@@ -2788,7 +2788,7 @@
}
/**
- * 复制练习时 保存习题关联
+ * 澶嶅埗缁冧範鏃� 淇濆瓨涔犻鍏宠仈
*
* @param sourceGroup
* @param targetGroup
@@ -2818,7 +2818,7 @@
}
/**
- * 学员得分详情列表
+ * 瀛﹀憳寰楀垎璇︽儏鍒楄〃
*
* @param groupId
* @return
@@ -2858,7 +2858,7 @@
recordMap.put(String.valueOf(obj[2]) , obj);
}
- // 组装为Map
+ // 缁勮涓篗ap
List<Map<String, Object>> lstMap = new ArrayList<Map<String, Object>>(userRegLst.size());
Map<String, Object> map = null;
@@ -2899,7 +2899,7 @@
}
/**
- * 初始化平均成绩和最高成绩
+ * 鍒濆鍖栧钩鍧囨垚缁╁拰鏈�楂樻垚缁�
*
* @param groupId
* @return
@@ -2934,12 +2934,12 @@
BigDecimal score = BigDecimal.ZERO;
- // 计算已做学员总分数
+ // 璁＄畻宸插仛瀛﹀憳鎬诲垎鏁�
for (BigDecimal obj : reLst) {
score = score.add(obj);
}
- // 计算班级平均成绩
+ // 璁＄畻鐝骇骞冲潎鎴愮哗
Double scoreNew = Double.valueOf(String.valueOf(score)) / userRegLst.size();
DecimalFormat df = new DecimalFormat("0.00");
@@ -2950,7 +2950,7 @@
}
/**
- * 题目得分详情
+ * 棰樼洰寰楀垎璇︽儏
*
* @param groupId
* @return
@@ -2965,28 +2965,28 @@
return new ArrayList<ExerciseItemStatistics>();
}
- // 获取组
+ // 鑾峰彇缁�
ExerciseGroup group = read(ExerciseGroup.class, groupId);
if (null == group) {
return new ArrayList<ExerciseItemStatistics>();
}
- // 默认章节练习
+ // 榛樿绔犺妭缁冧範
String hql = "select item from ExerciseItem item,ExerciseGroupItemRe re " + "where re.exerciseGroupId=? " + "and re.exerciseItemId=item.exerciseId " + "and item.deleteFlag is false " + "and re.deleteFlag is false " + "order by re.itemOrder ";
- // 随机练习,顺序练习
+ // 闅忔満缁冧範,椤哄簭缁冧範
if (ExerciseGroup.TYPE_EXERCISE_RANDOM == group.getType() || ExerciseGroup.TYPE_EXERCISE_SEQUENCE == group.getType()) {
hql = "select item from ExerciseItem item,ExerciseGroupItemRe re " + "where re.exerciseGroupId=? and " + "re.exerciseItemId=item.exerciseId " + "and item.deleteFlag is false " + "and re.deleteFlag is false " + "order by item.chapterId, re.itemOrder ";
}
- // 查询当前组的所有题目
+ // 鏌ヨ褰撳墠缁勭殑鎵�鏈夐鐩�
List<ExerciseItem> itemAllLst = this.exerDAO.find(hql, CollectionUtils.newList(groupId), ExerciseItem.class);
if (itemAllLst.isEmpty()) {
return new ArrayList<ExerciseItemStatistics>();
}
- // 同步编号
+ // 鍚屾缂栧彿
List<ExerciseItemStatistics> exeItemStatisLst = new ArrayList<ExerciseItemStatistics>(itemStatisLst.size());
ExerciseItemStatistics obj = null;
for (int j = 0; j < itemAllLst.size(); j++) {
@@ -2999,7 +2999,7 @@
obj.setClassAccuracyShow(obj.getClassAccuracy() + "%");
obj.setOrgAccuracyShow(obj.getOrgAccuracy() + "%");
- // 给类型赋值
+ // 缁欑被鍨嬭祴鍊�
setExerItemTypeNewName(obj);
exeItemStatisLst.add(obj);
@@ -3012,20 +3012,20 @@
}
private void setExerItemTypeNewName(ExerciseItemStatistics obj) {
- // 判断类型文字显示
+ // 鍒ゆ柇绫诲瀷鏂囧瓧鏄剧ず
if (obj.getExerciseItemType() == ExerciseItem.TYPE_SINGLE_SELECT) {
- obj.setItemTypeName("单选题");
+ obj.setItemTypeName("鍗曢�夐");
} else if (obj.getExerciseItemType() == ExerciseItem.TYPE_MULTI_SELECT) {
- obj.setItemTypeName("多选题");
+ obj.setItemTypeName("澶氶�夐");
} else if (obj.getExerciseItemType() == ExerciseItem.TYPE_TRUE_OR_FALSE) {
- obj.setItemTypeName("判断题");
+ obj.setItemTypeName("鍒ゆ柇棰�");
} else if (obj.getExerciseItemType() == ExerciseItem.TYPE_ESSAY_QUESTION) {
- obj.setItemTypeName("问答题");
+ obj.setItemTypeName("闂瓟棰�");
}
}
/**
- * 加载题目选项详情 - 班级、机构
+ * 鍔犺浇棰樼洰閫夐」璇︽儏 - 鐝骇銆佹満鏋�
*
* @param groupId
* @return
@@ -3055,23 +3055,23 @@
map.put("exerciseItemTitel", item.getTitle());
map.put("correctAnswer", item.getAnswer());
- if (optionStatis.getOptionOrder().equals("True")) {// 为True - 正确
- map.put("optionOrder", "正确");
- } else if (optionStatis.getOptionOrder().equals("False")) {// 为False - 错误
- map.put("optionOrder", "错误");
+ if (optionStatis.getOptionOrder().equals("True")) {// 涓篢rue - 姝ｇ‘
+ map.put("optionOrder", "姝ｇ‘");
+ } else if (optionStatis.getOptionOrder().equals("False")) {// 涓篎alse - 閿欒
+ map.put("optionOrder", "閿欒");
} else {
map.put("optionOrder", optionStatis.getOptionOrder());
}
- // 判断题目的类型
+ // 鍒ゆ柇棰樼洰鐨勭被鍨�
if ((short) item.getType() == ExerciseItem.TYPE_SINGLE_SELECT) {
- map.put("exerciseItemType", "单选题");
+ map.put("exerciseItemType", "鍗曢�夐");
} else if ((short) item.getType() == ExerciseItem.TYPE_MULTI_SELECT) {
- map.put("exerciseItemType", "多选题");
+ map.put("exerciseItemType", "澶氶�夐");
} else if ((short) item.getType() == ExerciseItem.TYPE_TRUE_OR_FALSE) {
- map.put("exerciseItemType", "判断题");
+ map.put("exerciseItemType", "鍒ゆ柇棰�");
} else if ((short) item.getType() == ExerciseItem.TYPE_ESSAY_QUESTION) {
- map.put("exerciseItemType", "问答题");
+ map.put("exerciseItemType", "闂瓟棰�");
}
lstResult.add(map);
@@ -3080,7 +3080,7 @@
}
/**
- * 编辑练习保存
+ * 缂栬緫缁冧範淇濆瓨
*/
@Override
public Result doSaveEditGroup(String groupId,String groupName) {
@@ -3095,14 +3095,14 @@
}
/**
- * 排序
+ * 鎺掑簭
*
- * @param ids 排序id
- * @param index 序号
+ * @param ids 鎺掑簭id
+ * @param index 搴忓彿
* @return
*/
public Result doOrder(List<String> ids, List<Integer> index){
- // 循环修改order
+ // 寰幆淇敼order
CommonDAO commonDAO = this.getCommonDAO();
for( int i=0;i< ids.size();i++){
String id = ids.get(i);
@@ -3113,14 +3113,14 @@
}
/**
- * 排序
+ * 鎺掑簭
*
- * @param ids 排序id
- * @param index 序号
+ * @param ids 鎺掑簭id
+ * @param index 搴忓彿
* @return
*/
public Result doitemOrder(List<String> ids, List<Integer> index,String groupId){
- // 循环修改order
+ // 寰幆淇敼order
CommonDAO commonDAO = this.getCommonDAO();
for( int i=0;i< ids.size();i++){
String id = ids.get(i);
@@ -3130,7 +3130,7 @@
}
/**
- * 保存练习接口
+ * 淇濆瓨缁冧範鎺ュ彛
*
* @param group
* @return
@@ -3143,7 +3143,7 @@
Map<String, Integer> order = courseWareService.getOrder(!isClass, group.getSubjectId(), group.getChapterId());
- //同步排序
+ //鍚屾鎺掑簭
int subjectOrder = order.get("subjectOrder");
int chapterOrder = order.get("chapterOrder");
int partOrder = order.get("partOrder");
@@ -3217,8 +3217,8 @@
}
/**
- * （后台管理系统）
- * 管理员同步习题到班级
+ * 锛堝悗鍙扮鐞嗙郴缁燂級
+ * 绠＄悊鍛樺悓姝ヤ範棰樺埌鐝骇
*
* @param exerciseItemId
* @return
@@ -3227,11 +3227,11 @@
*/
public Result doSynExercise(String[] exerciseItemIds) throws IllegalAccessException, InvocationTargetException{
if(exerciseItemIds == null || exerciseItemIds.length == 0){
- return new Result(false, "参数错误");
+ return new Result(false, "鍙傛暟閿欒");
}
List<Object> lstSaveObject = new ArrayList<>();
for(String exerciseItemId : exerciseItemIds){
- //待同步的练习
+ //寰呭悓姝ョ殑缁冧範
ExerciseItem sourceItem = this.read(ExerciseItem.class, exerciseItemId);
if(sourceItem == null){
continue;
@@ -3242,29 +3242,29 @@
List<ExerciseObjectImg> lstSourceImg = this.find("from ExerciseObjectImg where exerciseObjectId = ? and deleteFlag is false and objectType = ?",
CollectionUtils.newList(exerciseItemId, ExerciseObjectImg.OBJECT_TYPE_ITEM), ExerciseObjectImg.class);
- //下发的练习
+ //涓嬪彂鐨勭粌涔�
List<ExerciseItem> lstExerciseItem = this.find("from ExerciseItem where deleteFlag is false and orgiExerciseId = ?",
CollectionUtils.newList(exerciseItemId), ExerciseItem.class);
if(lstExerciseItem == null || lstExerciseItem.size() == 0){
continue;
}
- //同步题目
+ //鍚屾棰樼洰
for(ExerciseItem exerciseItem :lstExerciseItem){
exerciseItem.setTitle(sourceItem.getTitle());
exerciseItem.setAnswer(sourceItem.getAnswer());
TraceUtils.setUpdateTrace(exerciseItem);
- //同步更新练习组的时间
+ //鍚屾鏇存柊缁冧範缁勭殑鏃堕棿
this.bulkUpdate("update ExerciseGroup p set p.updateTime = sysdate() where EXISTS "+
" (select 1 from ExerciseGroupItemRe i where i.exerciseItemId = ? and i.deleteFlag is false and i.exerciseGroupId = p.groupId)", new Object[]{exerciseItem.getExerciseId()});
List<ExerciseItemAnalisi> lstExerciseItemAnalisi = exerciseItem.getAnalysises();
List<ExerciseObjectImg> lstExerciseObjectImg = this.find("from ExerciseObjectImg where exerciseObjectId = ? and deleteFlag is false and objectType = ?",
CollectionUtils.newList(exerciseItem.getExerciseId(), ExerciseObjectImg.OBJECT_TYPE_ITEM), ExerciseObjectImg.class);
- //同步选项
+ //鍚屾閫夐」
if(lstSourceOption != null && lstSourceOption.size() > 0){
ExerciseItemOption option;
- //删除选项的题目
+ //鍒犻櫎閫夐」鐨勯鐩�
this.bulkUpdate("update ExerciseItemOption p set p.deleteFlag = true where exerciseItemId = ?", new Object[]{exerciseItem.getExerciseId()});
for(ExerciseItemOption sourceOption : lstSourceOption){
ExerciseObjectImg objExerciseObjectImg;
@@ -3281,7 +3281,7 @@
TraceUtils.setCreateTrace(option);
- if(objSourceImg != null){//选项图片
+ if(objSourceImg != null){//閫夐」鍥剧墖
objExerciseObjectImg = new ExerciseObjectImg();
BeanUtils.copyProperties(objExerciseObjectImg, objSourceImg);
objExerciseObjectImg.setExerciseObjectId(option.getOptionId());
@@ -3320,7 +3320,7 @@
lstSaveObject.add(option);
}
}
- //同步解析
+ //鍚屾瑙ｆ瀽
if(lstSourceAnalisi != null && lstSourceAnalisi.size() > 0){
ExerciseItemAnalisi objExerciseItemAnalisi;
if(lstExerciseItemAnalisi == null || lstExerciseItemAnalisi.size() == 0){
@@ -3337,7 +3337,7 @@
}
lstSaveObject.add(objExerciseItemAnalisi);
}
- //同步题目图片
+ //鍚屾棰樼洰鍥剧墖
if(lstSourceImg != null && lstSourceImg.size() > 0){
ExerciseObjectImg objExerciseObjectImg;
if(lstExerciseObjectImg == null || lstExerciseObjectImg.size() == 0){
@@ -3363,7 +3363,7 @@
}
/**
- * 数据同步接口，同步下发到班级的数据
+ * 鏁版嵁鍚屾鎺ュ彛锛屽悓姝ヤ笅鍙戝埌鐝骇鐨勬暟鎹�
*
* @param orgId
* @param groupId
@@ -3383,11 +3383,11 @@
}else if(StringUtils.isNotBlank(groupId)){
lstGroup = this.find("from ExerciseGroup g where g.groupId = ?", CollectionUtils.newList(groupId), ExerciseGroup.class);
}else{
- return new Result(false, "参数错误");
+ return new Result(false, "鍙傛暟閿欒");
}
if(lstGroup == null || lstGroup.size() == 0){
- return new Result(false, "数据为空");
+ return new Result(false, "鏁版嵁涓虹┖");
}
for(ExerciseGroup group : lstGroup){
@@ -3414,14 +3414,14 @@
}
}
- return new Result(true, "成功");
+ return new Result(true, "鎴愬姛");
}
@SuppressWarnings("unchecked")
@Override
public Result saveExerciseItemBatch(String groupId,List<ExerciseItem> items) {
if (items == null || items.size() == 0) {
- return new Result(false, "没有要保存或更新的题目数据!");
+ return new Result(false, "娌℃湁瑕佷繚瀛樻垨鏇存柊鐨勯鐩暟鎹�!");
}
ExerciseGroup group = this.read(ExerciseGroup.class, groupId);
@@ -3442,19 +3442,19 @@
this.save(group);
redisTemplate.delete(groupId);
- return new Result(true, "成功",lstExerciseItemIds.toArray());
+ return new Result(true, "鎴愬姛",lstExerciseItemIds.toArray());
}
/**
- * 问卷评估 复制练习
+ * 闂嵎璇勪及 澶嶅埗缁冧範
* @param groupId
* @return
*/
@Override
public String doCopyExerciseByEvaluate(String groupId) {
- // 1、复制练习组
+ // 1銆佸鍒剁粌涔犵粍
ExerciseGroup group = this.read(ExerciseGroup.class, groupId);
ExerciseGroup newGroup = new ExerciseGroup();
try {
@@ -3462,31 +3462,31 @@
newGroup.setGroupId(null);
newGroup.setRecords(null);
} catch (Exception e) {
- log.error("问卷复制：复制练习BeanUtils.copyProperties()方法copy失败", e);
+ log.error("闂嵎澶嶅埗锛氬鍒剁粌涔燘eanUtils.copyProperties()鏂规硶copy澶辫触", e);
}
TraceUtils.setCreateTrace(newGroup);
this.save(newGroup);
- // 2、复制题目
+ // 2銆佸鍒堕鐩�
this.doCopyEvaExerciseItem(newGroup.getGroupId(), groupId);
return newGroup.getGroupId();
}
/**
- * 拷贝练习题
+ * 鎷疯礉缁冧範棰�
*
* @param newGroupId
* @param oldGroupId
*/
public void doCopyEvaExerciseItem(String newGroupId, String oldGroupId) {
- //改用存储过程
- //执行
+ //鏀圭敤瀛樺偍杩囩▼
+ //鎵ц
this.executeProduce("{call copy_exercise_item(?,?)}", new Object[]{newGroupId, oldGroupId});
}
/**
- * 查询问卷用户练习详情
+ * 鏌ヨ闂嵎鐢ㄦ埛缁冧範璇︽儏
* @param recordId
* @param evaluateId
* @return
@@ -3497,7 +3497,7 @@
QExerciseItem item = QExerciseItem.exerciseItem;
QExerciseGroupItemRe re = QExerciseGroupItemRe.exerciseGroupItemRe;
- // 查询题目list
+ // 鏌ヨ棰樼洰list
List<ExerciseItem> itemLst = this.getQueryFactory().select(item).from(item,re)
.where(item.exerciseId.eq(re.exerciseItemId)
.and(item.deleteFlag.eq(false))
@@ -3510,7 +3510,7 @@
SchEvaluate objSchEvaluate = this.read(SchEvaluate.class, evaluateId);
List<ExerciseObjectImg> lstExerciseObjectImg = null;
for (ExerciseItem objExerciseItem : itemLst) {
- if(objExerciseItem.getType() == ExerciseItem.TYPE_ATTACHMENT){//附件题读取题目的图片信息
+ if(objExerciseItem.getType() == ExerciseItem.TYPE_ATTACHMENT){//闄勪欢棰樿鍙栭鐩殑鍥剧墖淇℃伅
lstExerciseObjectImg = this.getQueryFactory().selectFrom(objImg)
.where(objImg.exerciseObjectId.in(
@@ -3523,7 +3523,7 @@
}
- //查询用户答题
+ //鏌ヨ鐢ㄦ埛绛旈
List<ExerciseItemAnswerU> lstExerciseItemAnswerU = this.getQueryFactory().selectFrom(answerU)
.where(answerU.deleteFlag.eq(false)
.and(answerU.exerciseRecordId.eq(objExerciseRecord.getRecordId()))
@@ -3533,14 +3533,14 @@
objExerciseItem.setExerciseItemAnswerU(lstExerciseItemAnswerU);
}
- //拼装前端所需要的数据
+ //鎷艰鍓嶇鎵�闇�瑕佺殑鏁版嵁
Map<String, Object> resultMap = ExerciseUtils.packageUserExerciseDetail(itemLst, objSchEvaluate, lstExerciseObjectImg);
return new ResultJson(true,"success",resultMap);
}
/**
- * 删除问卷图片
+ * 鍒犻櫎闂嵎鍥剧墖
*/
@Override
public ResultJson dodelEvaExerciseObjImg(String imgObjId) {
@@ -3550,15 +3550,15 @@
this.save(img);
- return new ResultJson(true,"操作成功");
+ return new ResultJson(true,"鎿嶄綔鎴愬姛");
}
/**
- * 新增问卷图片
+ * 鏂板闂嵎鍥剧墖
*/
@Override
public List<Map<String, Object>> doAddEvaExerciseObjImg(String[] imgPath, String imgObjId, int imgObjType) {
- // 查询此练习是否已经存在记录
+ // 鏌ヨ姝ょ粌涔犳槸鍚﹀凡缁忓瓨鍦ㄨ褰�
QExerciseObjectImg objImg = QExerciseObjectImg.exerciseObjectImg;
List<ExerciseObjectImg> lstObjImg = this.getQueryFactory()
.selectFrom(objImg)
@@ -3603,11 +3603,11 @@
}
/**
- * 查询问卷图片
+ * 鏌ヨ闂嵎鍥剧墖
*/
@Override
public List<Map<String, Object>> queryEvaExerciseObjImg(String imgObjId, int imgObjType) {
- // 查询此练习是否已经存在记录
+ // 鏌ヨ姝ょ粌涔犳槸鍚﹀凡缁忓瓨鍦ㄨ褰�
QExerciseObjectImg objImg = QExerciseObjectImg.exerciseObjectImg;
List<ExerciseObjectImg> lstObjImg = this.getQueryFactory()
.selectFrom(objImg)
@@ -3632,7 +3632,7 @@
}
/**
- * 更新习题选项图片对象结果
+ * 鏇存柊涔犻閫夐」鍥剧墖瀵硅薄缁撴灉
*
* @param optionId
* @param imgIds
@@ -3658,7 +3658,7 @@
}
/**
- * 更新习题选项图片对象结果
+ * 鏇存柊涔犻閫夐」鍥剧墖瀵硅薄缁撴灉
*
* @param optionId
* @param imgIds
--
Gitblit v1.8.0