tianzeOrg
/
tianze-pro
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

导入课程，增加题目配置+题目快照

Browse Source
beetlsql3-dev
Mlxa0324 2 years ago
parent c5fc6c5f9f
commit fe3bec4214
47 changed files with 1080 additions and 259 deletions
Show Stats Download Patch File Download Diff File

60
admin-core/src/main/java/com/ibeetl/admin/core/service/CoreBaseService.java
Unescape Escape View File

@ -1,13 +1,9 @@
package com.ibeetl.admin.core.service;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.ReUtil;
import com.ibeetl.admin.core.util.PlatformException;
import com.ibeetl.admin.core.util.enums.DelFlagEnum;
import org.beetl.sql.core.SQLManager;
import org.beetl.sql.core.TailBean;
import org.beetl.sql.core.query.LambdaQuery;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
@ -206,62 +202,6 @@ public class CoreBaseService<T> extends CoreBaseAnnotationParser {
return ret == 1;
}
/**
* 根据条件删除，不一定是主键ID，必须有一个删除条件
* @param condition
* @return
*/
public boolean deleteByCondition(T condition) {
if (condition == null) { return false; }
/**
* 忽略的字段, 考虑到正则的关键字
*/
String[] ignores = new String[]{
"org_id", "user_id", "_add_time", "create_time", "_create_time", "update_time",
"_update_time"
};
/**
* 增加结尾符号
* | 代表或者的意思，$代表从后面开始向前匹配
* ArrayUtil.map(ignores, ReUtil::escape) 每个元素将正则的关键字转义，以防万一
* 生成的正则大概的样子：[org_id|user_id|_add_time|]$
*/
String regex = String.format("[%s]$", ArrayUtil.join(ArrayUtil.map(ignores, ReUtil::escape).toArray(), "|"));
log.debug("生成的正则：{}", regex);
// 构建LambdaQuery
Class<T> currentEntityClass = getCurrentEntityClassz();
LambdaQuery<T> tLambdaQuery = sqlManager.lambdaQuery(currentEntityClass);
// 实体类属性转Map
Map<String, Object> stringObjectMap = BeanUtil.beanToMap(condition, true, true);
// 移除空值或者忽略字段
for (String k : stringObjectMap.keySet()) {
/**
* 移除在忽略列表中的值
*/
if (ReUtil.isMatch(regex, k)) {
stringObjectMap.remove(k);
}
}
// 目前只支持 等于操作，将条件追加到Query中
stringObjectMap.forEach(tLambdaQuery::andEq);
log.debug("生成的SQL预览 {}", tLambdaQuery.getSql());
// 如果没有查询条件，则直接返回
if(tLambdaQuery.getParams().isEmpty()) {
return false;
}
// 执行删除
return tLambdaQuery.delete() > 0;
}
/**
* 根据id删除数据
*

7
web/src/main/java/com/ibeetl/jlw/dao/ResourcesQuestionSnapshotDao.java
Unescape Escape View File

@ -41,4 +41,11 @@ public interface ResourcesQuestionSnapshotDao extends BaseMapper<ResourcesQuesti
* @return
*/
Object questionTestResults(TeacherOpenCourseQuestionTestDetail testDetail);
/**
* 批量删除(通过题目配置ID)
* @param settingIds
*/
@Update
void deleteByTeacherOpenCourseQuestionSettingIds(String settingIds);
}

10
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseMergeResourcesQuestionDao.java
Unescape Escape View File

@ -36,14 +36,24 @@ public interface TeacherOpenCourseMergeResourcesQuestionDao extends BaseMapper<T
/**
* 根据题型和数量，随机取离线题库
* @param questionSettingDTO
* @return
*/
List<TeacherOpenCourseMergeResourcesQuestion> getRandomMergeResourcesQuestionList(TeacherOpenCourseQuestionSettingDTO questionSettingDTO);
/**
* 根据开课ID获取下面的题目类型和类型下的总题数
* @param questionSettingDTO
* @return
*/
List<TeacherOpenCourseMergeResourcesQuestion> getRandomMergeResourcesQuestionListBySystem(TeacherOpenCourseQuestionSettingDTO questionSettingDTO);
/**
* 根据开课ID获取下面的题目类型和类型下的总题数
* 从开课题库获取
* @param teacherOpenCourseId
* @return
*/
List<TeacherOpenCourseQuestionSettingVO> getGroupQuestionTypeCount(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId);
}

8
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseQuestionLogDao.java
Unescape Escape View File

@ -34,5 +34,13 @@ public interface TeacherOpenCourseQuestionLogDao extends BaseMapper<TeacherOpenC
* 根据题目配置ID逻辑删除
* @param settingIds
*/
@Update
void logicDeleteTeacherOpenCourseQuestionLogBySettingIds(String settingIds);
/**
* 根据题目配置ID 批量真删除
* @param settingIds
*/
@Update
void deleteByTeacherOpenCourseQuestionSettingIds(String settingIds);
}

7
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseQuestionLogWrongDao.java
Unescape Escape View File

@ -29,4 +29,11 @@ public interface TeacherOpenCourseQuestionLogWrongDao extends BaseMapper<Teacher
List<TeacherOpenCourseQuestionLogWrong> getByIds(String ids);
List<TeacherOpenCourseQuestionLogWrong> getValuesByQuery(TeacherOpenCourseQuestionLogWrongQuery teacherOpenCourseQuestionLogWrongQuery);
List<Map<String,Object>>getExcelValues(TeacherOpenCourseQuestionLogWrongQuery teacherOpenCourseQuestionLogWrongQuery);
/**
* 根据题目配置ID 批量真删除
* @param settingIds
*/
@Update
void deleteByTeacherOpenCourseQuestionSettingIds(String settingIds);
}

2
web/src/main/java/com/ibeetl/jlw/entity/CourseInfo.java
Unescape Escape View File

@ -2,6 +2,7 @@ package com.ibeetl.jlw.entity;
import cn.jlw.validate.ValidateConfig;
import com.ibeetl.admin.core.entity.BaseEntity;
import lombok.EqualsAndHashCode;
import org.beetl.sql.annotation.entity.AutoID;
import javax.validation.constraints.NotNull;
@ -12,6 +13,7 @@ import java.util.List;
* 课程管理 - 课程配置
* gen by Spring Boot2 Admin 2021-06-24
*/
@EqualsAndHashCode(callSuper=false)
public class CourseInfo extends BaseEntity{
//ID

16
web/src/main/java/com/ibeetl/jlw/entity/dto/TeacherOpenCourseQuestionSettingDTO.java
Unescape Escape View File

@ -1,19 +1,27 @@
package com.ibeetl.jlw.entity.dto;
import cn.jlw.validate.ValidateConfig;
import com.ibeetl.jlw.entity.TeacherOpenCourseMergeResourcesQuestion;
import com.ibeetl.jlw.enums.ResourcesQuestionTypeEnum;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import javax.validation.constraints.NotNull;
import java.math.BigDecimal;
/**
*题目配置入参
* 题目配置
* 抽题配置类
*
* @author mlx
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class TeacherOpenCourseQuestionSettingDTO {
/**
@ -51,10 +59,6 @@ public class TeacherOpenCourseQuestionSettingDTO {
*
* 注意：
* 如果该实体类是查询的返回值，这个字段会被填充该题目类型下的题目ID集合。
*
* 该字段保存到是 teacher_open_course_merge_resources_question 中的主键。
* 对应的是{@link TeacherOpenCourseMergeResourcesQuestion#getTeacherOpenCourseMergeResourcesQuestionId()}
* 简写为 resourcesQuestionIdPlural，不要理解错了
*/
private String resourcesQuestionIdPlural;

35
web/src/main/java/com/ibeetl/jlw/service/CourseInfoService.java
Unescape Escape View File

@ -4,6 +4,7 @@ package com.ibeetl.jlw.service;
import cn.hutool.core.util.ObjectUtil;
import cn.jlw.Interceptor.GetFile;
import cn.jlw.util.ToolUtils;
import com.beust.jcommander.internal.Maps;
import com.ibeetl.admin.core.entity.CoreUser;
import com.ibeetl.admin.core.service.CoreBaseService;
import com.ibeetl.admin.core.service.CorePlatformService;
@ -22,16 +23,14 @@ import org.beetl.sql.core.SqlId;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.core.query.LambdaQuery;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.validation.constraints.NotNull;
import java.io.*;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.concurrent.*;
import java.util.stream.Collectors;
@ -187,6 +186,7 @@ public class CourseInfoService extends CoreBaseService<CourseInfo>{
return courseInfoDao.getCourseInfoValues(courseInfoQuery);
}
@Cacheable(value = "courseInfoService.getById", key = "#courseInfoId", unless = "#courseInfoId == null")
public CourseInfo getById(Long courseInfoId){
CourseInfo courseInfo = courseInfoDao.getById(courseInfoId);
@ -385,6 +385,33 @@ public class CourseInfoService extends CoreBaseService<CourseInfo>{
return courseInfos;
}
/**
* 通过传入的题目列表，
* 通过章节分组
*
* @param courseInfos 系统课程章节列表
* @return
*/
public Map<CourseInfo, List<CourseInfo>> getCourseChapterInfoIdsWithChildren(Collection<CourseInfo> courseInfos) {
if (ObjectUtil.isEmpty(courseInfos)) {
return Maps.newHashMap();
}
Map<CourseInfo, List<CourseInfo>> result = new HashMap<>();
// 只取章节节点
Set<CourseInfo> set = courseInfos.stream()
.filter(item -> (item.getCourseInfoType() == 2 && item.getCourseInfoStatus() == 1)).collect(Collectors.toSet());
// 取出来所有的课程章、节的ID。大于等于2，就是章和他下面的子集
for (CourseInfo courseInfo : set) {
List<CourseInfo> courseResources = getCourseResources(courseInfo.getCourseInfoId());
// 加上章节本身
courseResources.add(courseInfo);
result.put(courseInfo, courseResources);
}
return result;
}
/**
* 根据课程（章节、小节）ID，获取该ID下的子集，返回一维集合
* 不包含他本身

13
web/src/main/java/com/ibeetl/jlw/service/ResourcesQuestionService.java
Unescape Escape View File

@ -646,4 +646,17 @@ public class ResourcesQuestionService extends CoreBaseService<ResourcesQuestion>
shuffleOrderOptions(resourcesQuestion, "questionAnswer","questionOption", true);
});
}
/**
* 通过课程章节ID来获取题目
*
* @param allCourseInfoIds
* @return
*/
public List<ResourcesQuestion> getByCourseInfoIds(String allCourseInfoIds) {
ResourcesQuestionQuery resourcesQuestionQuery = new ResourcesQuestionQuery();
resourcesQuestionQuery.setCourseInfoIds(allCourseInfoIds);
resourcesQuestionQuery.setQuestionStatus(1);
return getValuesByQuery(resourcesQuestionQuery);
}
}

204
web/src/main/java/com/ibeetl/jlw/service/ResourcesQuestionSnapshotService.java
Unescape Escape View File

@ -15,26 +15,29 @@ import com.ibeetl.jlw.dao.TeacherOpenCourseMergeResourcesQuestionDao;
import com.ibeetl.jlw.entity.*;
import com.ibeetl.jlw.entity.dto.TeacherOpenCourseQuestionSettingDTO;
import com.ibeetl.jlw.web.query.ResourcesQuestionSnapshotQuery;
import com.ibeetl.jlw.web.query.TeacherOpenCourseQuestionSettingQuery;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.assertj.core.util.Lists;
import org.beetl.sql.core.SQLReady;
import org.beetl.sql.core.SqlId;
import org.beetl.sql.core.engine.PageQuery;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import javax.annotation.Nullable;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.*;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import static cn.hutool.core.util.ArrayUtil.join;
import static com.ibeetl.admin.core.util.user.CacheUserUtil.getUserId;
/**
@ -45,11 +48,14 @@ import static com.ibeetl.admin.core.util.user.CacheUserUtil.getUserId;
@Service
@Transactional
@Validated
public class ResourcesQuestionSnapshotService extends CoreBaseService<ResourcesQuestionSnapshot>{
@Slf4j
public class ResourcesQuestionSnapshotService extends CoreBaseService<ResourcesQuestionSnapshot> implements DeleteResourcesBy{
@Autowired private ResourcesQuestionSnapshotDao resourcesQuestionSnapshotDao;
@Autowired private StudentDao studentDao;
@Autowired private TeacherOpenCourseMergeResourcesQuestionDao teacherOpenCourseMergeResourcesQuestionDao;
@Autowired @Lazy
private TeacherOpenCourseQuestionSettingService teacherOpenCourseQuestionSettingService;
public PageQuery<ResourcesQuestionSnapshot>queryByCondition(PageQuery query){
PageQuery ret = resourcesQuestionSnapshotDao.queryByCondition(query);
@ -82,6 +88,18 @@ public class ResourcesQuestionSnapshotService extends CoreBaseService<ResourcesQ
}
}
/**
* 批量删除(通过题目配置ID)
* @param settingIds
*/
public void deleteByTeacherOpenCourseQuestionSettingIds(String settingIds){
try {
resourcesQuestionSnapshotDao.deleteByTeacherOpenCourseQuestionSettingIds(settingIds);
} catch (Exception e) {
throw new PlatformException("批量删除题目快照失败", e);
}
}
public String addAll(ResourcesQuestionSnapshotQuery resourcesQuestionSnapshotQuery){
String msg = "";
List<ResourcesQuestionSnapshot> resourcesQuestionSnapshotList = new ArrayList<>();
@ -165,29 +183,127 @@ public class ResourcesQuestionSnapshotService extends CoreBaseService<ResourcesQ
}
/**
* 传入题目ID 批量导入到快照表中
* 根据题目配置批量导入
* 从开课题库中导入
*
* @param teacherOpenCourseQuestionSettingId 开课题目配置ID
* @param questionSettingOptions 根据题型动态分配题目
* @param courseInfoIdPair 根据题型动态分配题目
*/
public void insertBatchByMergeResourcesQuestion(@NotNull(message = "开课题目配置ID不能为空！") final Long teacherOpenCourseQuestionSettingId,
@Nullable List<TeacherOpenCourseQuestionSettingDTO> questionSettingOptions, Map<Long, Long> courseInfoIdPair) {
// 在插入之前，先清空列表。这种情况下，支持题目配置还在，重置题目列表的操作。
deleteByTeacherOpenCourseQuestionSettingIds(teacherOpenCourseQuestionSettingId.toString());
// 题目设置，来动态获取题目
if(ObjectUtil.isNotEmpty(questionSettingOptions)) {
// 数据库动态设置分数，并获取题目列表
List<ResourcesQuestionSnapshot> insertList = getOpenResourcesQuestionSnapListBySettingOptions(
teacherOpenCourseQuestionSettingId, questionSettingOptions, courseInfoIdPair);
resourcesQuestionSnapshotDao.insertBatch(insertList);
}
}
/**
* 传入题目ID 批量导入到快照表中
* 从系统题库导入
*
* @param teacherOpenCourseQuestionSettingId 开课题目配置ID
* @param questionSettingOptions 根据题型动态分配题目
* @param courseInfoIdPair 根据题型动态分配题目
*/
public void insertBatchByQuestionIds(@NotNull(message = "开课题目配置ID不能为空！") final Long teacherOpenCourseQuestionSettingId,
List<TeacherOpenCourseQuestionSettingDTO> questionSettingOptions) {
public void insertBatchBySystemResourcesQuestion(@NotNull(message = "开课题目配置ID不能为空！") final Long teacherOpenCourseQuestionSettingId,
@Nullable List<TeacherOpenCourseQuestionSettingDTO> questionSettingOptions, Map<Long, Long> courseInfoIdPair) {
// 在插入之前，先清空列表。这种情况下，支持题目配置还在，重置题目列表的操作。
ResourcesQuestionSnapshot deleteCondition = new ResourcesQuestionSnapshot();
deleteCondition.setTeacherOpenCourseQuestionSettingId(teacherOpenCourseQuestionSettingId);
deleteCondition.setQuestionStatus(1);
deleteByCondition(deleteCondition);
deleteByTeacherOpenCourseQuestionSettingIds(teacherOpenCourseQuestionSettingId.toString());
// 题目设置，来动态获取题目
if(ObjectUtil.isNotEmpty(questionSettingOptions)) {
List<ResourcesQuestionSnapshot> insertList = getResourcesQuestionSnapshotListByQuestionSettingOptions(
teacherOpenCourseQuestionSettingId, questionSettingOptions);
// 数据库动态设置分数，并获取题目列表
List<ResourcesQuestionSnapshot> insertList = getMergeResourcesQuestionSnapListByQuestionSettingOptionsBySystem(
teacherOpenCourseQuestionSettingId, questionSettingOptions, courseInfoIdPair);
insertList.forEach(item -> item.setTeacherOpenCourseQuestionSettingId(teacherOpenCourseQuestionSettingId));
setNewCourseInfoId(insertList, courseInfoIdPair);
resourcesQuestionSnapshotDao.insertBatch(insertList);
}
}
/**
* 从开课题库中获取题目。可以单独设置类型下的分数
*
* @param teacherOpenCourseQuestionSettingId 开课题目配置ID
* @param questionSettingOptions 根据题型动态分配题目
* @param courseInfoIdPair 根据题型动态分配题目
*/
public List<ResourcesQuestionSnapshot> getByOpenCourseResourcesQuestion(@NotNull(message = "开课题目配置ID不能为空！") final Long teacherOpenCourseQuestionSettingId,
@Nullable List<TeacherOpenCourseQuestionSettingDTO> questionSettingOptions, Map<Long, Long> courseInfoIdPair) {
// 题目设置，来动态获取题目
if(ObjectUtil.isNotEmpty(questionSettingOptions)) {
// 数据库动态设置分数，并获取题目列表
List<ResourcesQuestionSnapshot> insertList = getOpenResourcesQuestionSnapListBySettingOptions(
teacherOpenCourseQuestionSettingId, questionSettingOptions, courseInfoIdPair);
setNewCourseInfoId(insertList, courseInfoIdPair);
return insertList;
}
return Lists.emptyList();
}
/**
* 从系统题库中获取题目。可以单独设置类型下的分数
*
* @param teacherOpenCourseQuestionSettingId 开课题目配置ID
* @param questionSettingOptions 根据题型动态分配题目
* @param courseInfoIdPair 根据题型动态分配题目
*/
public List<ResourcesQuestionSnapshot> getBySystemResourcesQuestion(@NotNull(message = "开课题目配置ID不能为空！") final Long teacherOpenCourseQuestionSettingId,
@Nullable List<TeacherOpenCourseQuestionSettingDTO> questionSettingOptions, Map<Long, Long> courseInfoIdPair) {
// 题目设置，来动态获取题目
if(ObjectUtil.isNotEmpty(questionSettingOptions)) {
// 数据库动态设置分数，并获取题目列表
List<ResourcesQuestionSnapshot> insertList = getMergeResourcesQuestionSnapListByQuestionSettingOptionsBySystem(
teacherOpenCourseQuestionSettingId, questionSettingOptions, courseInfoIdPair);
setNewCourseInfoId(insertList, courseInfoIdPair);
return insertList;
}
return Lists.emptyList();
}
/**
* 根据课程新旧ID片段集合，设置新的课程ID
*
* @param insertList
* @param courseInfoIdPair
*/
public void setNewCourseInfoId(@NotNull List<ResourcesQuestionSnapshot> insertList, @NotNull Map<Long, Long> courseInfoIdPair) {
insertList.forEach(item -> {
Long courseMergeCourseInfoId = item.getTeacherOpenCourseMergeCourseInfoId();
item.setTeacherOpenCourseMergeCourseInfoId(courseInfoIdPair.getOrDefault(courseMergeCourseInfoId, courseMergeCourseInfoId));
});
}
/**
* 根据课程新旧ID片段集合，设置新的课程ID
*
* @param insertList
* @param courseInfoIdPair
*/
public void setRQNewCourseInfoId(@NotNull List<TeacherOpenCourseMergeResourcesQuestion> insertList, @NotNull Map<Long, Long> courseInfoIdPair) {
insertList.forEach(item -> {
Long courseMergeCourseInfoId = item.getTeacherOpenCourseMergeCourseInfoId();
item.setTeacherOpenCourseMergeCourseInfoId(courseInfoIdPair.getOrDefault(courseMergeCourseInfoId, courseMergeCourseInfoId));
});
}
/**
* 根据题目ID集合
* 获取题目快照列表。并配置题目配置ID
@ -219,7 +335,7 @@ public class ResourcesQuestionSnapshotService extends CoreBaseService<ResourcesQ
* @param otherConsumer 其他消费操作
* @return
*/
public List<ResourcesQuestionSnapshot> getResourcesQuestionSnapshotList(
public List<ResourcesQuestionSnapshot> getResourcesQuestionSnapshotList (
@NotEmpty(message = "开课题库列表不能为空！") final List<TeacherOpenCourseMergeResourcesQuestion> questionList,
@NotBlank(message = "题目配置ID不能为空！") Long teacherOpenCourseQuestionSettingId, Consumer<ResourcesQuestionSnapshot> otherConsumer) {
// 批量插入快照表
@ -243,7 +359,7 @@ public class ResourcesQuestionSnapshotService extends CoreBaseService<ResourcesQ
* @param questionScore 统一给这些题目ID设置分数
* @return
*/
public List<ResourcesQuestionSnapshot> getResourcesQuestionSnapshotListByQuestionIds(
public List<ResourcesQuestionSnapshot> getResourcesQuestionSnapshotListByQuestionIds (
@NotNull(message = "开课题目配置ID不能为空！") final Long teacherOpenCourseQuestionSettingId,
@NotBlank(message = "题目ID列表不能为空！") String questionIdPlural,
@NotNull(message = "题目分数不能为空！") final BigDecimal questionScore) {
@ -257,16 +373,16 @@ public class ResourcesQuestionSnapshotService extends CoreBaseService<ResourcesQ
}
/**
* 根据题目类型配置
* 根据题目类型配置。从开课题库
* 获取题目快照列表。并配置题目配置ID
*
* @param teacherOpenCourseQuestionSettingId
* @param questionSettingOptions
* @return
*/
public List<ResourcesQuestionSnapshot> getResourcesQuestionSnapshotListByQuestionSettingOptions(
public List<ResourcesQuestionSnapshot> getOpenResourcesQuestionSnapListBySettingOptions (
@NotNull(message = "开课题目配置ID不能为空！") final Long teacherOpenCourseQuestionSettingId,
@NotBlank(message = "题目设置不能为空！") List<TeacherOpenCourseQuestionSettingDTO> questionSettingOptions) {
@NotBlank(message = "题目设置不能为空！") List<TeacherOpenCourseQuestionSettingDTO> questionSettingOptions, Map<Long, Long> courseInfoIdPair) {
List<ResourcesQuestionSnapshot> result = new ArrayList<>();
@ -275,6 +391,36 @@ public class ResourcesQuestionSnapshotService extends CoreBaseService<ResourcesQ
List<TeacherOpenCourseMergeResourcesQuestion> randomMergeResourcesQuestionList =
teacherOpenCourseMergeResourcesQuestionDao.getRandomMergeResourcesQuestionList(questionSettingOption);
setRQNewCourseInfoId(randomMergeResourcesQuestionList, courseInfoIdPair);
// 放入最终的集合中
result.addAll(getResourcesQuestionSnapshotList(randomMergeResourcesQuestionList, teacherOpenCourseQuestionSettingId, e -> {}));
}
return result;
}
/**
* 根据题目类型配置。从系统题库获取
* 获取题目快照列表。并配置题目配置ID
* 导入课程，用此方法。
* 会从系统题库查找
*
* @param teacherOpenCourseQuestionSettingId
* @param questionSettingOptions
* @return
*/
public List<ResourcesQuestionSnapshot> getMergeResourcesQuestionSnapListByQuestionSettingOptionsBySystem (
@NotNull(message = "开课题目配置ID不能为空！") final Long teacherOpenCourseQuestionSettingId,
@NotBlank(message = "题目设置不能为空！") List<TeacherOpenCourseQuestionSettingDTO> questionSettingOptions, Map<Long, Long> courseInfoIdPair) {
List<ResourcesQuestionSnapshot> result = new ArrayList<>();
for (TeacherOpenCourseQuestionSettingDTO questionSettingOption : questionSettingOptions) {
// 根据配置随机出题。这里直接设置题目的分值。
List<TeacherOpenCourseMergeResourcesQuestion> randomMergeResourcesQuestionList =
teacherOpenCourseMergeResourcesQuestionDao.getRandomMergeResourcesQuestionListBySystem(questionSettingOption);
setRQNewCourseInfoId(randomMergeResourcesQuestionList, courseInfoIdPair);
// 放入最终的集合中
result.addAll(getResourcesQuestionSnapshotList(randomMergeResourcesQuestionList, teacherOpenCourseQuestionSettingId, e -> {}));
}
@ -360,4 +506,24 @@ public class ResourcesQuestionSnapshotService extends CoreBaseService<ResourcesQ
@NotEmpty(message = "知识点ID不能为空！") Set<Long> teacherOpenCourseKnowledgePointsIds) {
return null;
}
@Override
public void resetOperationByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("重置题目快照！");
TeacherOpenCourseQuestionSettingQuery teacherOpenCourseQuestionSettingQuery = new TeacherOpenCourseQuestionSettingQuery();
teacherOpenCourseQuestionSettingQuery.setTeacherOpenCourseId(teacherOpenCourseId);
List<TeacherOpenCourseQuestionSetting> valuesByQuery =
teacherOpenCourseQuestionSettingService.getValuesByQuery(teacherOpenCourseQuestionSettingQuery);
if (ObjectUtil.isNotEmpty(valuesByQuery)) {
Set<Long> settingIdSet = valuesByQuery.stream()
.map(TeacherOpenCourseQuestionSetting::getTeacherOpenCourseQuestionSettingId).collect(Collectors.toSet());
deleteByTeacherOpenCourseQuestionSettingIds(join(settingIdSet.toArray(), ","));
}
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}
}

4
web/src/main/java/com/ibeetl/jlw/service/TeacherMergeApplicationService.java
Unescape Escape View File

@ -246,11 +246,11 @@ public class TeacherMergeApplicationService extends CoreBaseService<TeacherMerge
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}
}

5
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseChatLogService.java
Unescape Escape View File

@ -18,6 +18,7 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.validation.constraints.NotNull;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
@ -151,11 +152,11 @@ public class TeacherOpenCourseChatLogService extends CoreBaseService<TeacherOpen
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}

9
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseHandsOnService.java
Unescape Escape View File

@ -21,6 +21,7 @@ import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import javax.validation.constraints.NotNull;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
@ -171,9 +172,7 @@ public class TeacherOpenCourseHandsOnService extends CoreBaseService<TeacherOpen
HandsOnQuery handsOnQuery = new HandsOnQuery();
handsOnQuery.setCourseInfoId(courseInfoId);
List<HandsOn> handsOnList = handsOnService.getValuesByQuery(handsOnQuery);
TeacherOpenCourseHandsOn handsOn = new TeacherOpenCourseHandsOn();
handsOn.setCourseInfoId(courseInfoId);
deleteByCondition(handsOn);
sqlManager.lambdaQuery(TeacherOpenCourseHandsOn.class).andEq(TeacherOpenCourseHandsOn::getCourseInfoId, courseInfoId).delete();
List<TeacherOpenCourseHandsOn> teacherOpenCourseHandsOns = BeanUtil.copyToList(handsOnList, TeacherOpenCourseHandsOn.class);
StringJoiner joiner = new StringJoiner(",");
for (TeacherOpenCourseHandsOn teacherOpenCourseHandsOn : teacherOpenCourseHandsOns) {
@ -274,11 +273,11 @@ public class TeacherOpenCourseHandsOnService extends CoreBaseService<TeacherOpen
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}
}

5
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseHandsOnSimulationTasksFileService.java
Unescape Escape View File

@ -19,6 +19,7 @@ import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import javax.validation.constraints.NotNull;
import java.util.ArrayList;
import java.util.List;
@ -154,11 +155,11 @@ public class TeacherOpenCourseHandsOnSimulationTasksFileService extends CoreBase
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}
}

11
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseHandsOnSimulationTasksService.java
Unescape Escape View File

@ -24,6 +24,7 @@ import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import javax.validation.constraints.NotNull;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
@ -178,9 +179,9 @@ public class TeacherOpenCourseHandsOnSimulationTasksService extends CoreBaseServ
}
teacherOpenCourseHandsOnSimulationTasksDao.updateTemplateById(teacherOpenCourseHandsOnSimulationTasks);
String tasksFile = teacherOpenCourseHandsOnSimulationTasksQuery.getTeacherOpenCourseHandsOnSimulationTasksFile();
TeacherOpenCourseHandsOnSimulationTasksFile file = new TeacherOpenCourseHandsOnSimulationTasksFile();
file.setTaskId(teacherOpenCourseHandsOnSimulationTasksQuery.getTaskId());
teacherOpenCourseHandsOnSimulationTasksFileService.deleteByCondition(file);
sqlManager.lambdaQuery(TeacherOpenCourseHandsOnSimulationTasksFile.class)
.andEq(TeacherOpenCourseHandsOnSimulationTasksFile::getTaskId, teacherOpenCourseHandsOnSimulationTasksQuery.getTaskId())
.delete();
if (StringUtils.isNotEmpty(tasksFile)) {
List<TeacherOpenCourseHandsOnSimulationTasksFileQuery> teacherOpenCourseHandsOnSimulationTasksFiles = JSONArray.parseArray(tasksFile, TeacherOpenCourseHandsOnSimulationTasksFileQuery.class);
for (TeacherOpenCourseHandsOnSimulationTasksFileQuery teacherOpenCourseHandsOnSimulationTasksFile : teacherOpenCourseHandsOnSimulationTasksFiles) {
@ -354,11 +355,11 @@ public class TeacherOpenCourseHandsOnSimulationTasksService extends CoreBaseServ
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}
}

5
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseKnowledgePointRelationService.java
Unescape Escape View File

@ -19,6 +19,7 @@ import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import javax.validation.constraints.NotNull;
import java.util.ArrayList;
import java.util.List;
@ -154,11 +155,11 @@ public class TeacherOpenCourseKnowledgePointRelationService extends CoreBaseServ
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}

5
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseKnowledgePointService.java
Unescape Escape View File

@ -19,6 +19,7 @@ import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import javax.validation.constraints.NotNull;
import java.util.ArrayList;
import java.util.List;
@ -150,11 +151,11 @@ public class TeacherOpenCourseKnowledgePointService extends CoreBaseService<Teac
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}

177
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseMergeCourseInfoService.java
Unescape Escape View File

@ -6,10 +6,10 @@ import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.lang.Snowflake;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.stream.CollectorUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.extra.spring.SpringUtil;
import cn.jlw.util.ToolUtils;
import cn.jlw.validate.ValidateConfig;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.google.common.base.Optional;
@ -23,10 +23,10 @@ import com.ibeetl.admin.core.web.JsonResult;
import com.ibeetl.admin.core.web.JsonReturnCode;
import com.ibeetl.jlw.dao.TeacherOpenCourseMergeCourseInfoDao;
import com.ibeetl.jlw.entity.*;
import com.ibeetl.jlw.web.query.ResourcesInfoQuery;
import com.ibeetl.jlw.web.query.ResourcesQuestionQuery;
import com.ibeetl.jlw.entity.dto.TeacherOpenCourseQuestionSettingDTO;
import com.ibeetl.jlw.web.query.TeacherOpenCourseMergeCourseInfoQuery;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Row;
@ -41,6 +41,7 @@ import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import javax.annotation.Nullable;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
@ -53,7 +54,6 @@ import java.util.concurrent.CopyOnWriteArrayList;
import static cn.hutool.core.util.ArrayUtil.join;
import static cn.hutool.core.util.ObjectUtil.defaultIfNull;
import static com.ibeetl.admin.core.util.ExcelUtil.getCellFormatValue;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toSet;
/**
@ -64,12 +64,14 @@ import static java.util.stream.Collectors.toSet;
@Service
@Transactional
@Validated
@Slf4j
public class TeacherOpenCourseMergeCourseInfoService extends CoreBaseService<TeacherOpenCourseMergeCourseInfo> implements DeleteResourcesBy {
@Autowired private TeacherOpenCourseMergeCourseInfoDao teacherOpenCourseMergeCourseInfoDao;
@Autowired private CourseInfoService courseInfoService;
@Autowired private TeacherOpenCourseMergeResourcesQuestionService teacherOpenCourseMergeResourcesQuestionService;
@Autowired private StudentService studentService;
@Autowired @Lazy private TeacherOpenCourseQuestionSettingService teacherOpenCourseQuestionSettingService;
@Autowired
private UniversitiesCollegesJurisdictionExperimentalSystemService universitiesCollegesJurisdictionExperimentalSystemService;
@Autowired
@ -189,6 +191,12 @@ public class TeacherOpenCourseMergeCourseInfoService extends CoreBaseService<Tea
return msg;
}
/**
* 开课题目配置单表新增
* 更新缓存
* @param teacherOpenCourseMergeCourseInfoQuery
* @return
*/
public JsonResult add(TeacherOpenCourseMergeCourseInfoQuery teacherOpenCourseMergeCourseInfoQuery){
String msg = "";
TeacherOpenCourseMergeCourseInfo teacherOpenCourseMergeCourseInfo = teacherOpenCourseMergeCourseInfoQuery.pojo();
@ -204,6 +212,33 @@ public class TeacherOpenCourseMergeCourseInfoService extends CoreBaseService<Tea
return jsonResult;
}
/**
* 添加开课课程
*
* 任务一：添加开课课程主表
* 任务二：如果是章节节点，则根据开课课程的章节名称来添加到开课题目配置表；
* 任务三：添加开课题目快照表
*
* @param teacherOpenCourseMergeCourseInfoQuery
* @return
*/
public JsonResult addCourseAndQuestionWithQuestionSnap(@Validated(ValidateConfig.ADD.class) @NotNull(message = "开课题目信息不能为空！")
TeacherOpenCourseMergeCourseInfoQuery teacherOpenCourseMergeCourseInfoQuery,
@Nullable List<TeacherOpenCourseQuestionSettingDTO> questionSettingOptions, Map<Long, Long> courseInfoIdPair) {
// 添加开课课程表
JsonResult jsonResult = add(teacherOpenCourseMergeCourseInfoQuery);
// 开课课程：2 章节节点
if(Integer.valueOf(2).equals(teacherOpenCourseMergeCourseInfoQuery.getCourseInfoType())) {
// 添加到题目配置和开课题目快照表，这里null 不拷贝题目
teacherOpenCourseQuestionSettingService.addTeacherOpenCourseQuestionByCourseInfo(teacherOpenCourseMergeCourseInfoQuery, questionSettingOptions, courseInfoIdPair);
}
return jsonResult;
}
public String edit(TeacherOpenCourseMergeCourseInfoQuery teacherOpenCourseMergeCourseInfoQuery){
String msg = "";
TeacherOpenCourseMergeCourseInfo teacherOpenCourseMergeCourseInfo = teacherOpenCourseMergeCourseInfoQuery.pojo();
@ -480,11 +515,11 @@ public class TeacherOpenCourseMergeCourseInfoService extends CoreBaseService<Tea
*
* @param copyToList 带递归层级的开课课程列表
* @param parentId 开课课程 父辈ID
* @param idPair 转换之前的ID和转换之后的ID对（用于后面的题目、资源的ID替换）
* @param courseInfoIdPair 转换之前的ID和转换之后的ID对（用于后面的题目、资源的ID替换）
* @return 转换之前的ID和转换之后的ID对（用于后面的题目、资源的ID替换）
*/
public void batchUpdateSomeMergeId(List<TeacherOpenCourseMergeCourseInfoTree> copyToList,
final Long parentId, ConcurrentHashMap<Long, Long> idPair) {
final Long parentId, ConcurrentHashMap<Long, Long> courseInfoIdPair) {
// 转换成线程安全的集合，来并行操作。
List<TeacherOpenCourseMergeCourseInfoTree> safeList = new CopyOnWriteArrayList<>(copyToList);
@ -496,8 +531,8 @@ public class TeacherOpenCourseMergeCourseInfoService extends CoreBaseService<Tea
Long newId = defaultIfNull(parentId, snowflake.nextId());
item.setTeacherOpenCourseMergeCourseInfoId(newId);
// 存储ID对
idPair.put(item.getTeacherOpenCourseMergeCourseInfoId(), newId);
batchUpdateSomeMergeId(item.getChildren(), snowflake.nextId(), idPair);
courseInfoIdPair.put(item.getTeacherOpenCourseMergeCourseInfoId(), newId);
batchUpdateSomeMergeId(item.getChildren(), snowflake.nextId(), courseInfoIdPair);
});
}
@ -506,13 +541,13 @@ public class TeacherOpenCourseMergeCourseInfoService extends CoreBaseService<Tea
* 处理一维集合，更换ID和父辈ID的方法
*
* @param copyToList 开课课程列表
* @param initIdPair 初始化的ID对
* @param initcourseInfoIdPair 初始化的ID对
*/
public Map<Long, Long> batchUpdateArrayListSomeMergeId(List<TeacherOpenCourseMergeCourseInfo> copyToList,
// 不能为空，但是可以传递empty的Map
@NotNull(message = "初始化ID对不能为空！") Map<Long, Long> initIdPair) {
@NotNull(message = "初始化ID对不能为空！") Map<Long, Long> initcourseInfoIdPair) {
Map<Long, Long> idPair = new HashMap<>(initIdPair);
Map<Long, Long> courseInfoIdPair = new HashMap<>(initcourseInfoIdPair);
// 查找列表中所有的ID
Set<Long> mergeCourseInfoIdSet = copyToList.stream()
@ -520,15 +555,15 @@ public class TeacherOpenCourseMergeCourseInfoService extends CoreBaseService<Tea
for (Long oldId : mergeCourseInfoIdSet) {
// 只取第一次ID对，后面加进来的丢弃
if (!idPair.containsKey(oldId)) {
idPair.put(oldId, snowflake.nextId());
if (!courseInfoIdPair.containsKey(oldId)) {
courseInfoIdPair.put(oldId, snowflake.nextId());
}
}
// 替换ID和父类ID
updateSpecifyMergeCourseInfoIdTargetList(copyToList, idPair);
updateSpecifyMergeCourseInfoIdTargetList(copyToList, courseInfoIdPair);
return idPair;
return courseInfoIdPair;
}
/**
@ -606,12 +641,12 @@ public class TeacherOpenCourseMergeCourseInfoService extends CoreBaseService<Tea
* 修改章节点的父类ID字段
*
* @param courseInfoList 系统课程列表
* @param someIdPair 一些修改前修改后的ID对（指定一些修改的ID对）
* @param somecourseInfoIdPair 一些修改前修改后的ID对（指定一些修改的ID对）
*/
public void updateSpecifyIdTargetList(List<CourseInfo> courseInfoList,
@NotEmpty(message = "ID对不能为空！") Map<Long, Long> someIdPair) {
@NotEmpty(message = "ID对不能为空！") Map<Long, Long> somecourseInfoIdPair) {
for (CourseInfo courseInfo : courseInfoList) {
someIdPair.forEach((oldId, newId) -> {
somecourseInfoIdPair.forEach((oldId, newId) -> {
if(courseInfo.getCourseInfoId().equals(oldId)) {
courseInfo.setCourseInfoId(newId);
}
@ -626,12 +661,12 @@ public class TeacherOpenCourseMergeCourseInfoService extends CoreBaseService<Tea
* 修改章节点的父类ID字段
*
* @param courseInfoList 系统课程列表
* @param someIdPair 一些修改前修改后的ID对（指定一些修改的ID对）
* @param somecourseInfoIdPair 一些修改前修改后的ID对（指定一些修改的ID对）
*/
public void updateSpecifyMergeCourseInfoIdTargetList(List<TeacherOpenCourseMergeCourseInfo> courseInfoList,
@NotEmpty(message = "ID对不能为空！") Map<Long, Long> someIdPair) {
@NotEmpty(message = "ID对不能为空！") Map<Long, Long> somecourseInfoIdPair) {
for (TeacherOpenCourseMergeCourseInfo courseInfo : courseInfoList) {
someIdPair.forEach((oldId, newId) -> {
somecourseInfoIdPair.forEach((oldId, newId) -> {
if(courseInfo.getTeacherOpenCourseMergeCourseInfoId().equals(oldId)) {
courseInfo.setTeacherOpenCourseMergeCourseInfoId(newId);
}
@ -654,7 +689,7 @@ public class TeacherOpenCourseMergeCourseInfoService extends CoreBaseService<Tea
public Map<Long, Long> copyFromCourseInfo(@NotEmpty(message = "系统课程ID不能为空！") Set<Long> courseInfoIds,
@NotNull(message = "开课ID不能为空！") final Long teacherOpenCourseId) {
ConcurrentHashMap<Long, Long> idPair = new ConcurrentHashMap<>();
ConcurrentHashMap<Long, Long> courseInfoIdPair = new ConcurrentHashMap<>(16);
// 查询是否绑定过课程
boolean notExists = teacherOpenCourseMergeCourseInfoDao.isNotExistsByTeacherOpenCourseId(teacherOpenCourseId);
@ -672,30 +707,39 @@ public class TeacherOpenCourseMergeCourseInfoService extends CoreBaseService<Tea
List<CourseInfo> chapterList = courseInfoService.getCourseResources(courseInfoId);
// 全部归类到教师开课时候，创建的开课课程ID下。支持一对多个系统课程的拷贝
idPair.put(currentCourseInfo.getCourseInfoId(), openCourseTargetInfo.getTeacherOpenCourseMergeCourseInfoId());
courseInfoIdPair.put(currentCourseInfo.getCourseInfoId(), openCourseTargetInfo.getTeacherOpenCourseMergeCourseInfoId());
// 先根据ID清楚现有的课程章节小节这个表
String delCourseInfoIds = chapterList.stream().map(CourseInfo::getCourseInfoId).collect(CollectorUtil.joining(","));
deleteTeacherOpenCourseMergeCourseInfo(delCourseInfoIds);
// 拷贝部分字段映射
CopyOptions copyOptions = CopyOptions.create().setFieldMapping(MapUtil.of("courseInfoId", "teacherOpenCourseMergeCourseInfoId"));
List<TeacherOpenCourseMergeCourseInfo> copyToList =
BeanUtil.copyToList(chapterList, TeacherOpenCourseMergeCourseInfo.class, copyOptions);
if (ObjectUtil.isEmpty(copyToList)) { return; }
// 设置开课ID
copyToList.forEach(item -> {
item.setTeacherOpenCourseId(teacherOpenCourseId);
item.setCourseInfoName(item.getCourseInfoName().replaceAll("&nbsp;", ""));
});
resetOperationByTeacherOpenCourseId(teacherOpenCourseId);
List<TeacherOpenCourseMergeCourseInfo> copyToList = new ArrayList<>();
// 类转换
courseInfoListConvertTeacherOpenCourseMergeCourseInfoList(chapterList, copyToList);
// 最右侧的idPair 可以理解成是初始化的Map。Map特性Key是唯一的。
idPair.putAll(batchUpdateArrayListSomeMergeId(copyToList, idPair));
if (ObjectUtil.isNotEmpty(copyToList)) {
// 设置开课ID
copyToList.forEach(item -> {
item.setTeacherOpenCourseId(teacherOpenCourseId);
item.setCourseInfoName(item.getCourseInfoName().replaceAll("&nbsp;", ""));
});
// 批量插入
teacherOpenCourseMergeCourseInfoDao.insertBatch(copyToList);
// 最右侧的courseInfoIdPair 可以理解成是初始化的Map。Map特性Key是唯一的。
courseInfoIdPair.putAll(batchUpdateArrayListSomeMergeId(copyToList, courseInfoIdPair));
// 批量插入
teacherOpenCourseMergeCourseInfoDao.insertBatch(copyToList);
}
});
return idPair;
return Collections.unmodifiableMap(courseInfoIdPair);
}
private void courseInfoListConvertTeacherOpenCourseMergeCourseInfoList(@NotNull List<CourseInfo> chapterList, @NotNull Collection<TeacherOpenCourseMergeCourseInfo> result) {
// 拷贝部分字段映射
CopyOptions copyOptions = CopyOptions.create().setFieldMapping(MapUtil.of("courseInfoId", "teacherOpenCourseMergeCourseInfoId"));
List<TeacherOpenCourseMergeCourseInfo> copyToList =
BeanUtil.copyToList(chapterList, TeacherOpenCourseMergeCourseInfo.class, copyOptions);
result.addAll(copyToList);
}
/**
@ -710,39 +754,28 @@ public class TeacherOpenCourseMergeCourseInfoService extends CoreBaseService<Tea
public void importCourseInfo(@NotEmpty(message = "系统课程ID不能为空！") Set<Long> courseInfoIds,
@NotNull(message = "开课ID不能为空！") final Long teacherOpenCourseId) {
// 拷贝课程章节
Map<Long, Long> idPair = copyFromCourseInfo(courseInfoIds, teacherOpenCourseId);
// 拷贝课程章节。返回的Map是不可修改的。
Map<Long, Long> courseInfoIdPair = copyFromCourseInfo(courseInfoIds, teacherOpenCourseId);
// 开启并行处理
courseInfoIds.stream().parallel().forEach(courseInfoId -> {
// 当前的课程节点信息
// CourseInfo currentCourseInfo = courseInfoService.getById(courseInfoId);
// 获取这个课程章节下的所有的子章节信息
// #courseInfoId 这里指的是课程节点的ID
List<CourseInfo> chapterList = courseInfoService.getCourseResources(courseInfoId);
// 去重后的章和节
HashSet<CourseInfo> courseInfos = CollectionUtil.newHashSet(chapterList);
// 如果课程章节没查到记录，则下面的资源也没必要执行，资源依赖课程章节
if (ObjectUtil.isEmpty(courseInfos)) { return; }
// 取出来所有的课程章节ID
String allCourseInfoIdsJoin = courseInfos.stream().map(item -> item.getCourseInfoId().toString()).collect(joining(","));
ResourcesQuestionQuery resourcesQuestionQuery = new ResourcesQuestionQuery();
resourcesQuestionQuery.setCourseInfoIds(allCourseInfoIdsJoin);
resourcesQuestionQuery.setQuestionStatus(1);
List<ResourcesQuestion> resourcesQuestionList = resourcesQuestionService.getValuesByQuery(resourcesQuestionQuery);
// 系统题目库ID集合
Set<Long> resourcesQuestionIds = resourcesQuestionList.stream().map(ResourcesQuestion::getResourcesQuestionId).collect(toSet());
// 拷贝系统题目库到教师开课
teacherOpenCourseMergeResourcesQuestionService.copyFromQuestion(resourcesQuestionIds, teacherOpenCourseId, idPair);
ResourcesInfoQuery resourcesInfoQuery = new ResourcesInfoQuery();
resourcesInfoQuery.setCourseInfoIds(allCourseInfoIdsJoin);
List<ResourcesInfo> resourcesInfoList = resourcesInfoService.getValuesByQuery(resourcesInfoQuery);
// 系统资源库ID集合
Set<Long> resourcesInfoIds = resourcesInfoList.stream().map(ResourcesInfo::getResourcesInfoId).collect(toSet());
// 拷贝系统资源库到教师开课
teacherOpenCourseMergeResourcesInfoService.copyFromResourcesInfo(resourcesInfoIds, teacherOpenCourseId, idPair);
if (ObjectUtil.isNotEmpty(courseInfos)) {
// 拷贝系统题目库到教师开课
teacherOpenCourseMergeResourcesQuestionService.copyFromQuestionByCourseChapterInfoIds(teacherOpenCourseId, courseInfos, courseInfoIdPair);
// 取出来所有的课程章、节的ID。大于等于2，就是章和他的子节点
teacherOpenCourseQuestionSettingService.processGroupChapterListToQuestionSetting(teacherOpenCourseId, courseInfos, courseInfoIdPair);
// 拷贝系统资源库到教师开课
teacherOpenCourseMergeResourcesInfoService.copyFromQuestionByCourseChapterInfoIds(teacherOpenCourseId, courseInfos, courseInfoIdPair);
}
});
}
@ -772,6 +805,7 @@ public class TeacherOpenCourseMergeCourseInfoService extends CoreBaseService<Tea
*/
@Override
public void resetOperationByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") final Long teacherOpenCourseId) {
log.info("重置开课课程");
TeacherOpenCourseMergeCourseInfoQuery courseInfoQuery = new TeacherOpenCourseMergeCourseInfoQuery();
courseInfoQuery.setTeacherOpenCourseId(teacherOpenCourseId);
// 考虑后期可能会有4的情况，暂时多加一个数字4。不查询课程节点的数据
@ -780,11 +814,18 @@ public class TeacherOpenCourseMergeCourseInfoService extends CoreBaseService<Tea
// 根据ID删除数据
Set<Long> delIdList = values.stream().map(TeacherOpenCourseMergeCourseInfo::getTeacherOpenCourseMergeCourseInfoId).collect(toSet());
deleteTeacherOpenCourseMergeCourseInfo(join(delIdList.toArray(), ","));
if(ObjectUtil.isNotEmpty(delIdList)) {
deleteTeacherOpenCourseMergeCourseInfo(join(delIdList.toArray(), ","));
}
}
/**
* 指定开课ID清空所有的章节信息
*
* @param teacherOpenCourseId
*/
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
TeacherOpenCourseMergeCourseInfoQuery courseInfoQuery = new TeacherOpenCourseMergeCourseInfoQuery();
courseInfoQuery.setTeacherOpenCourseId(teacherOpenCourseId);
List<TeacherOpenCourseMergeCourseInfo> values = getValuesByQueryNotWithPermission(courseInfoQuery);

69
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseMergeResourcesInfoService.java
Unescape Escape View File

@ -13,11 +13,13 @@ import com.ibeetl.admin.core.util.PlatformException;
import com.ibeetl.admin.core.web.JsonResult;
import com.ibeetl.admin.core.web.JsonReturnCode;
import com.ibeetl.jlw.dao.TeacherOpenCourseMergeResourcesInfoDao;
import com.ibeetl.jlw.entity.CourseInfo;
import com.ibeetl.jlw.entity.FileEntity;
import com.ibeetl.jlw.entity.ResourcesInfo;
import com.ibeetl.jlw.entity.TeacherOpenCourseMergeResourcesInfo;
import com.ibeetl.jlw.web.query.ResourcesInfoQuery;
import com.ibeetl.jlw.web.query.TeacherOpenCourseMergeResourcesInfoQuery;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Row;
@ -31,11 +33,14 @@ import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import javax.annotation.Nullable;
import javax.validation.constraints.NotNull;
import java.io.*;
import java.util.*;
import static com.ibeetl.admin.core.util.ExcelUtil.getCellFormatValue;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toSet;
import static org.apache.commons.lang3.StringUtils.join;
/**
@ -46,6 +51,7 @@ import static org.apache.commons.lang3.StringUtils.join;
@Service
@Transactional
@Validated
@Slf4j
public class TeacherOpenCourseMergeResourcesInfoService extends CoreBaseService<TeacherOpenCourseMergeResourcesInfo> implements DeleteResourcesBy {
@Autowired private TeacherOpenCourseMergeResourcesInfoDao teacherOpenCourseMergeResourcesInfoDao;
@ -316,6 +322,46 @@ public class TeacherOpenCourseMergeResourcesInfoService extends CoreBaseService<
return teacherOpenCourseMergeResourcesInfoDao.getExcelValues(teacherOpenCourseMergeResourcesInfoQuery);
}
/**
* 根据指定的课程ID和章节ID集合，去从系统资源拷贝到开课资源库
*
* @param teacherOpenCourseId 开课ID
* @param allCourseInfo 指定的所有课程章节
* @param courseInfoIdPair 拷贝过来的ID段，旧ID和新ID的一个映射关系（非必填）
*/
public void copyFromQuestionByCourseChapterInfoIds(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId,
Collection<CourseInfo> allCourseInfo, @Nullable Map<Long, Long> courseInfoIdPair) {
ResourcesInfoQuery resourcesInfoQuery = new ResourcesInfoQuery();
// 取出所有的课程章节ID
String courseInfoIds = allCourseInfo.stream().map(item -> item.getCourseInfoId().toString()).collect(joining(","));
resourcesInfoQuery.setCourseInfoIds(courseInfoIds);
List<ResourcesInfo> resourcesInfoList = resourcesInfoService.getValuesByQuery(resourcesInfoQuery);
// 系统资源库ID集合
Set<Long> resourcesInfoIds = resourcesInfoList.stream().map(ResourcesInfo::getResourcesInfoId).collect(toSet());
// 拷贝系统资源库到教师开课
copyFromResourcesInfo(resourcesInfoIds, teacherOpenCourseId, courseInfoIdPair);
}
/**
* 根据指定的课程ID和章节ID集合，去从系统资源拷贝到开课资源库
*
* @param teacherOpenCourseId 开课ID
* @param allCourseInfoIdsJoin 指定的所有课程章节ID
* @param courseInfoIdPair 拷贝过来的ID段，旧ID和新ID的一个映射关系（非必填）
*/
public void copyFromQuestionByCourseChapterInfoIds(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId,
String allCourseInfoIdsJoin, @Nullable Map<Long, Long> courseInfoIdPair) {
ResourcesInfoQuery resourcesInfoQuery = new ResourcesInfoQuery();
resourcesInfoQuery.setCourseInfoIds(allCourseInfoIdsJoin);
List<ResourcesInfo> resourcesInfoList = resourcesInfoService.getValuesByQuery(resourcesInfoQuery);
// 系统资源库ID集合
Set<Long> resourcesInfoIds = resourcesInfoList.stream().map(ResourcesInfo::getResourcesInfoId).collect(toSet());
// 拷贝系统资源库到教师开课
copyFromResourcesInfo(resourcesInfoIds, teacherOpenCourseId, courseInfoIdPair);
}
/**
* 教师端-导入资源操作，逻辑拆分
@ -324,11 +370,11 @@ public class TeacherOpenCourseMergeResourcesInfoService extends CoreBaseService<
*
* @param resourcesInfoIds 资源信息ID集合
* @param teacherOpenCourseId 开课ID
* @param idPair
* @param courseInfoIdPair
* @return
*/
public void copyFromResourcesInfo(Set<Long> resourcesInfoIds,
@NotNull(message = "开课ID不能为空！") final Long teacherOpenCourseId, Map<Long, Long> idPair) {
@NotNull(message = "开课ID不能为空！") final Long teacherOpenCourseId, Map<Long, Long> courseInfoIdPair) {
if (ObjectUtil.isEmpty(resourcesInfoIds)) { return; }
ResourcesInfoQuery resourcesInfoQuery = new ResourcesInfoQuery();
@ -342,7 +388,7 @@ public class TeacherOpenCourseMergeResourcesInfoService extends CoreBaseService<
BeanUtil.copyToList(resourcesInfoList, TeacherOpenCourseMergeResourcesInfo.class, copyOptions);
copyToList.forEach(item -> item.setTeacherOpenCourseId(teacherOpenCourseId));
resetNewId(copyToList, idPair);
resetNewId(copyToList, courseInfoIdPair);
// 批量插入资源和开课关联表
insertBatch(copyToList);
@ -351,12 +397,12 @@ public class TeacherOpenCourseMergeResourcesInfoService extends CoreBaseService<
/**
* 重置开课课程ID。需要拿到新旧改变的关系
* @param copyToList
* @param idPair
* @param courseInfoIdPair
*/
public void resetNewId(List<TeacherOpenCourseMergeResourcesInfo> copyToList, Map<Long, Long> idPair) {
if (ObjectUtil.isEmpty(idPair)) {return;}
public void resetNewId(List<TeacherOpenCourseMergeResourcesInfo> copyToList, Map<Long, Long> courseInfoIdPair) {
if (ObjectUtil.isEmpty(courseInfoIdPair)) {return;}
copyToList.forEach(item -> {
item.setTeacherOpenCourseMergeCourseInfoId(idPair.get(item.getTeacherOpenCourseMergeCourseInfoId()));
item.setTeacherOpenCourseMergeCourseInfoId(courseInfoIdPair.get(item.getTeacherOpenCourseMergeCourseInfoId()));
});
}
@ -368,13 +414,14 @@ public class TeacherOpenCourseMergeResourcesInfoService extends CoreBaseService<
*/
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
TeacherOpenCourseMergeResourcesInfo teacherOpenCourseMergeResourcesInfo = new TeacherOpenCourseMergeResourcesInfo();
teacherOpenCourseMergeResourcesInfo.setTeacherOpenCourseId(teacherOpenCourseId);
deleteByCondition(teacherOpenCourseMergeResourcesInfo);
log.info("重置开课课程资源");
sqlManager.lambdaQuery(TeacherOpenCourseMergeResourcesInfo.class)
.andEq(TeacherOpenCourseMergeResourcesInfo::getTeacherOpenCourseId, teacherOpenCourseId)
.delete();
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
}
}

110
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseMergeResourcesQuestionService.java
Unescape Escape View File

@ -14,12 +14,14 @@ import com.ibeetl.admin.core.web.JsonResult;
import com.ibeetl.admin.core.web.JsonReturnCode;
import com.ibeetl.jlw.dao.ResourcesQuestionDao;
import com.ibeetl.jlw.dao.TeacherOpenCourseMergeResourcesQuestionDao;
import com.ibeetl.jlw.entity.CourseInfo;
import com.ibeetl.jlw.entity.FileEntity;
import com.ibeetl.jlw.entity.ResourcesQuestion;
import com.ibeetl.jlw.entity.TeacherOpenCourseMergeResourcesQuestion;
import com.ibeetl.jlw.entity.vo.TeacherOpenCourseQuestionSettingVO;
import com.ibeetl.jlw.web.query.ResourcesQuestionQuery;
import com.ibeetl.jlw.web.query.TeacherOpenCourseMergeResourcesQuestionQuery;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Row;
@ -40,6 +42,8 @@ import java.util.*;
import static cn.hutool.core.util.ArrayUtil.join;
import static com.ibeetl.admin.core.util.ExcelUtil.getCellFormatValue;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toSet;
/**
* 开课题目拉取 Service
@ -49,10 +53,12 @@ import static com.ibeetl.admin.core.util.ExcelUtil.getCellFormatValue;
@Service
@Transactional
@Validated
@Slf4j
public class TeacherOpenCourseMergeResourcesQuestionService extends CoreBaseService<TeacherOpenCourseMergeResourcesQuestion> implements DeleteResourcesBy {
@Autowired private TeacherOpenCourseMergeResourcesQuestionDao teacherOpenCourseMergeResourcesQuestionDao;
@Autowired private ResourcesQuestionDao resourcesQuestionDao;
@Autowired private ResourcesQuestionService resourcesQuestionService;
public PageQuery<TeacherOpenCourseMergeResourcesQuestion>queryByCondition(PageQuery query){
PageQuery ret = teacherOpenCourseMergeResourcesQuestionDao.queryByCondition(query);
@ -366,6 +372,55 @@ public class TeacherOpenCourseMergeResourcesQuestionService extends CoreBaseServ
return teacherOpenCourseMergeResourcesQuestionDao.getExcelValues(teacherOpenCourseMergeResourcesQuestionQuery);
}
/**
* 根据指定的课程ID和章节ID集合，去从系统题目拷贝到开课题目库
*
* @param teacherOpenCourseId 开课ID
* @param allCourseInfo 指定的所有课程章节信息
* @param courseInfoIdPair 拷贝过来的ID段，旧ID和新ID的一个映射关系（非必填）
*/
public void copyFromQuestionByCourseChapterInfoIds(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId,
Collection<CourseInfo> allCourseInfo, @NotNull Map<Long, Long> courseInfoIdPair) {
// 待拷贝的系统课程ID不能为空.才会执行
if (ObjectUtil.isNotEmpty(allCourseInfo)) {
ResourcesQuestionQuery resourcesQuestionQuery = new ResourcesQuestionQuery();
// 取出所有的课程章节ID
String courseInfoIds = allCourseInfo.stream().map(item -> item.getCourseInfoId().toString()).collect(joining(","));
resourcesQuestionQuery.setCourseInfoIds(courseInfoIds);
resourcesQuestionQuery.setQuestionStatus(1);
List<ResourcesQuestion> resourcesQuestionList = resourcesQuestionService.getValuesByQuery(resourcesQuestionQuery);
// 系统题目库ID集合
Set<Long> resourcesQuestionIds = resourcesQuestionList.stream().map(ResourcesQuestion::getResourcesQuestionId).collect(toSet());
// 拷贝系统题目库到教师开课
copyFromQuestion(resourcesQuestionIds, teacherOpenCourseId, courseInfoIdPair);
}
}
/**
* 根据指定的课程ID和章节ID集合，去从系统题目拷贝到开课题目库
*
* @param teacherOpenCourseId 开课ID
* @param allCourseInfoIdsJoin 指定的所有课程章节ID
* @param courseInfoIdPair 拷贝过来的ID段，旧ID和新ID的一个映射关系（非必填）
*/
public void copyFromQuestionByCourseChapterInfoIds(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId,
String allCourseInfoIdsJoin, @NotNull Map<Long, Long> courseInfoIdPair) {
// 待拷贝的系统课程ID不能为空.才会执行
if (ObjectUtil.isNotEmpty(allCourseInfoIdsJoin)) {
ResourcesQuestionQuery resourcesQuestionQuery = new ResourcesQuestionQuery();
resourcesQuestionQuery.setCourseInfoIds(allCourseInfoIdsJoin);
resourcesQuestionQuery.setQuestionStatus(1);
List<ResourcesQuestion> resourcesQuestionList = resourcesQuestionService.getValuesByQuery(resourcesQuestionQuery);
// 系统题目库ID集合
Set<Long> resourcesQuestionIds = resourcesQuestionList.stream().map(ResourcesQuestion::getResourcesQuestionId).collect(toSet());
// 拷贝系统题目库到教师开课
copyFromQuestion(resourcesQuestionIds, teacherOpenCourseId, courseInfoIdPair);
}
}
/**
* 从resources_question 表，拷贝数据。类似从模板中，拉取数据
@ -375,11 +430,11 @@ public class TeacherOpenCourseMergeResourcesQuestionService extends CoreBaseServ
*
* @param resourcesQuestionIds
* @param teacherOpenCourseId
* @param idPair
* @param courseInfoIdPair
* @return
*/
public void copyFromQuestion(Set<Long> resourcesQuestionIds,
@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId, Map<Long, Long> idPair) {
@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId, Map<Long, Long> courseInfoIdPair) {
if (ObjectUtil.isEmpty(resourcesQuestionIds)) { return; }
// 题目ID集合
@ -390,22 +445,35 @@ public class TeacherOpenCourseMergeResourcesQuestionService extends CoreBaseServ
resourcesQuestionQuery.setQuestionStatus(1);
List<ResourcesQuestion> resourcesQuestions = resourcesQuestionDao.getValuesByQuery(resourcesQuestionQuery);
// 转换后的数据暂存
List<TeacherOpenCourseMergeResourcesQuestion> convertedList = new ArrayList<>();
// 类转换方法
resourcesQuestionConvertToTeacherOpenCourseMergeResourcesQuestion(resourcesQuestions, convertedList, courseInfoIdPair );
// 设置开课ID
convertedList.forEach(item -> item.setTeacherOpenCourseId(teacherOpenCourseId));
// 批量插入
teacherOpenCourseMergeResourcesQuestionDao.insertBatch(convertedList);
}
/**
* 类转换 ResourcesQuestion => TeacherOpenCourseMergeResourcesQuestion
* @param from
* @param to
* @param courseInfoIdPair
*/
public void resourcesQuestionConvertToTeacherOpenCourseMergeResourcesQuestion(
@NotNull Collection<ResourcesQuestion> from,
@NotNull Collection<TeacherOpenCourseMergeResourcesQuestion> to,
Map<Long, Long> courseInfoIdPair) {
// 拷贝部分字段映射
CopyOptions copyOptions = CopyOptions.create().setFieldMapping(MapUtil.of("courseInfoId", "teacherOpenCourseMergeCourseInfoId"));
// 拷贝
List<TeacherOpenCourseMergeResourcesQuestion> copyToList =
BeanUtil.copyToList(resourcesQuestions, TeacherOpenCourseMergeResourcesQuestion.class, copyOptions);
to.addAll(BeanUtil.copyToList(from, TeacherOpenCourseMergeResourcesQuestion.class, copyOptions));
if (ObjectUtil.isEmpty(copyToList)) { return; }
// 设置开课ID
copyToList.forEach(item -> item.setTeacherOpenCourseId(teacherOpenCourseId));
if (ObjectUtil.isAllEmpty(to, courseInfoIdPair)) { return; }
// 重置开课课程ID
resetNewId(copyToList, idPair);
// 批量插入
teacherOpenCourseMergeResourcesQuestionDao.insertBatch(copyToList);
resetNewId(to, courseInfoIdPair);
}
/**
@ -417,25 +485,27 @@ public class TeacherOpenCourseMergeResourcesQuestionService extends CoreBaseServ
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
TeacherOpenCourseMergeResourcesQuestion teacherOpenCourseIdCondition = new TeacherOpenCourseMergeResourcesQuestion();
teacherOpenCourseIdCondition.setTeacherOpenCourseId(teacherOpenCourseId);
deleteByCondition(teacherOpenCourseIdCondition);
log.info("重置开课课程题目");
sqlManager.lambdaQuery(TeacherOpenCourseMergeResourcesQuestion.class)
.andEq(TeacherOpenCourseMergeResourcesQuestion::getTeacherOpenCourseId, teacherOpenCourseId)
.delete();
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
resetOperationByTeacherOpenCourseId(teacherOpenCourseId);
}
/**
* 重置开课课程ID。需要拿到新旧改变的关系
* @param copyToList
* @param idPair
* @param courseInfoIdPair
*/
public void resetNewId(List<TeacherOpenCourseMergeResourcesQuestion> copyToList, Map<Long, Long> idPair) {
if (ObjectUtil.isEmpty(idPair)) {return;}
public void resetNewId(@NotNull Collection<TeacherOpenCourseMergeResourcesQuestion> copyToList, @NotNull Map<Long, Long> courseInfoIdPair) {
if (ObjectUtil.isEmpty(courseInfoIdPair)) {return;}
copyToList.forEach(item -> {
item.setTeacherOpenCourseMergeCourseInfoId(idPair.get(item.getTeacherOpenCourseMergeCourseInfoId()));
Long mergeCourseInfoId = item.getTeacherOpenCourseMergeCourseInfoId();
item.setTeacherOpenCourseMergeCourseInfoId(courseInfoIdPair.getOrDefault(mergeCourseInfoId, mergeCourseInfoId));
});
}

5
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseMergeScheduleSessionService.java
Unescape Escape View File

@ -26,6 +26,7 @@ import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import javax.validation.constraints.NotNull;
import java.io.*;
import java.util.*;
@ -292,11 +293,11 @@ public class TeacherOpenCourseMergeScheduleSessionService extends CoreBaseServic
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}
}

5
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseMergeSchoolClassService.java
Unescape Escape View File

@ -18,6 +18,7 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.validation.constraints.NotNull;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
@ -162,11 +163,11 @@ public class TeacherOpenCourseMergeSchoolClassService extends CoreBaseService<Te
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}

4
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseMergeStudentService.java
Unescape Escape View File

@ -261,11 +261,11 @@ public class TeacherOpenCourseMergeStudentService extends CoreBaseService<Teache
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}
}

4
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseMergeTeacherService.java
Unescape Escape View File

@ -299,11 +299,11 @@ public class TeacherOpenCourseMergeTeacherService extends CoreBaseService<Teache
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}
}

5
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseNoticeService.java
Unescape Escape View File

@ -20,6 +20,7 @@ import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import javax.validation.constraints.NotNull;
import java.util.ArrayList;
import java.util.List;
@ -158,11 +159,11 @@ public class TeacherOpenCourseNoticeService extends CoreBaseService<TeacherOpenC
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}
}

20
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseQuestionLogService.java
Unescape Escape View File

@ -30,6 +30,7 @@ import org.apache.commons.lang3.StringUtils;
import org.beetl.sql.core.SqlId;
import org.beetl.sql.core.engine.PageQuery;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
@ -61,7 +62,8 @@ public class TeacherOpenCourseQuestionLogService extends CoreBaseService<Teacher
@Autowired private TeacherOpenCourseQuestionLogDao teacherOpenCourseQuestionLogDao;
@Autowired private StudentDao studentDao;
@Autowired private ResourcesQuestionSnapshotDao resourcesQuestionSnapshotDao;
@Autowired private TeacherOpenCourseQuestionSettingService teacherOpenCourseQuestionSettingSettingService;
@Autowired @Lazy
private TeacherOpenCourseQuestionSettingService teacherOpenCourseQuestionSettingSettingService;
@Autowired private TeacherOpenCourseQuestionLogWrongService teacherOpenCourseQuestionLogWrongService;
public PageQuery<TeacherOpenCourseQuestionLog>queryByCondition(PageQuery query){
@ -95,6 +97,18 @@ public class TeacherOpenCourseQuestionLogService extends CoreBaseService<Teacher
}
}
/**
* 根据题目配置ID 批量真删除
* @param settingIds
*/
public void deleteByTeacherOpenCourseQuestionSettingIds(String settingIds) {
try {
teacherOpenCourseQuestionLogDao.deleteByTeacherOpenCourseQuestionSettingIds(settingIds);
} catch (Exception e) {
throw new PlatformException("批量删除题目日志失败", e);
}
}
public void logicDeleteTeacherOpenCourseQuestionLogBySettingIds(String settingIds){
try {
teacherOpenCourseQuestionLogDao.logicDeleteTeacherOpenCourseQuestionLogBySettingIds(settingIds);
@ -447,11 +461,11 @@ public class TeacherOpenCourseQuestionLogService extends CoreBaseService<Teacher
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}
}

17
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseQuestionLogWrongService.java
Unescape Escape View File

@ -30,6 +30,7 @@ import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import javax.validation.constraints.NotNull;
import java.io.*;
import java.math.BigDecimal;
import java.util.*;
@ -81,6 +82,18 @@ public class TeacherOpenCourseQuestionLogWrongService extends CoreBaseService<Te
}
}
/**
* 根据题目配置ID 批量真删除
* @param settingIds
*/
public void deleteByTeacherOpenCourseQuestionSettingIds(String settingIds) {
try {
teacherOpenCourseQuestionLogWrongDao.deleteByTeacherOpenCourseQuestionSettingIds(settingIds);
} catch (Exception e) {
throw new PlatformException("批量删除错题集失败", e);
}
}
public String addAll(TeacherOpenCourseQuestionLogWrongQuery teacherOpenCourseQuestionLogWrongQuery){
String msg = "";
List<TeacherOpenCourseQuestionLogWrong> teacherOpenCourseQuestionLogWrongList = new ArrayList<>();
@ -409,11 +422,11 @@ public class TeacherOpenCourseQuestionLogWrongService extends CoreBaseService<Te
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}

348
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseQuestionSettingService.java
Unescape Escape View File

@ -1,5 +1,9 @@
package com.ibeetl.jlw.service;
import cn.hutool.core.lang.func.Func1;
import cn.hutool.core.util.EnumUtil;
import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.jlw.util.ToolUtils;
import cn.jlw.validate.ValidateConfig;
import com.alibaba.fastjson.JSON;
@ -9,11 +13,18 @@ import com.ibeetl.admin.core.util.PlatformException;
import com.ibeetl.admin.core.web.JsonResult;
import com.ibeetl.admin.core.web.JsonReturnCode;
import com.ibeetl.jlw.dao.TeacherOpenCourseQuestionSettingDao;
import com.ibeetl.jlw.entity.CourseInfo;
import com.ibeetl.jlw.entity.ResourcesQuestion;
import com.ibeetl.jlw.entity.TeacherOpenCourseMergeCourseInfo;
import com.ibeetl.jlw.entity.TeacherOpenCourseQuestionSetting;
import com.ibeetl.jlw.entity.dto.TeacherOpenCourseQuestionSettingDTO;
import com.ibeetl.jlw.enums.ResourcesQuestionTypeEnum;
import com.ibeetl.jlw.web.query.ResourcesQuestionQuery;
import com.ibeetl.jlw.web.query.TeacherOpenCourseMergeCourseInfoQuery;
import com.ibeetl.jlw.web.query.TeacherOpenCourseQuestionSettingQuery;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.assertj.core.util.Lists;
import org.beetl.sql.core.SqlId;
import org.beetl.sql.core.engine.PageQuery;
import org.springframework.beans.factory.annotation.Autowired;
@ -21,8 +32,18 @@ import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import java.util.ArrayList;
import java.util.List;
import javax.annotation.Nullable;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import java.math.BigDecimal;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.stream.Collectors;
import static cn.hutool.core.text.CharSequenceUtil.join;
import static java.util.stream.Collectors.groupingBy;
import static java.util.stream.Collectors.joining;
/**
* 题目配置 Service
@ -36,6 +57,10 @@ public class TeacherOpenCourseQuestionSettingService extends CoreBaseService<Tea
@Autowired private TeacherOpenCourseQuestionSettingDao teacherOpenCourseQuestionSettingDao;
@Autowired private ResourcesQuestionSnapshotService resourcesQuestionSnapshotService;
@Autowired private TeacherOpenCourseQuestionLogService teacherOpenCourseQuestionLogService;
@Autowired private TeacherOpenCourseQuestionLogWrongService teacherOpenCourseQuestionLogWrongService;
@Autowired private ResourcesQuestionService resourcesQuestionService;
@Autowired private CourseInfoService courseInfoService;
public PageQuery<TeacherOpenCourseQuestionSetting>queryByCondition(PageQuery query){
PageQuery ret = teacherOpenCourseQuestionSettingDao.queryByCondition(query);
@ -153,10 +178,49 @@ public class TeacherOpenCourseQuestionSettingService extends CoreBaseService<Tea
/**
* 增加题目类型的数据
*
* 任务一；添加题目配置主表
* 任务二：添加题目快照表
* @param settingQuery
* @return
*/
public void addByMergeQuestion(@Validated(ValidateConfig.ADD.class) TeacherOpenCourseQuestionSettingQuery settingQuery, Map<Long, Long> courseInfoIdPair ) {
if (null == settingQuery.getTeacherOpenCourseQuestionSettingStatus()) {
settingQuery.setTeacherOpenCourseQuestionSettingStatus(1);
}
if (null == settingQuery.getTeacherOpenCourseQuestionSettingPushStatus()) {
settingQuery.setTeacherOpenCourseQuestionSettingPushStatus(1);
}
// 添加到作业主表中
add(settingQuery);
// 插入快照
Long teacherOpenCourseQuestionSettingId = settingQuery.getTeacherOpenCourseQuestionSettingId();
List<TeacherOpenCourseQuestionSettingDTO> questionSettingOptions = settingQuery.getQuestionSettingOptions();
resourcesQuestionSnapshotService.insertBatchByMergeResourcesQuestion(teacherOpenCourseQuestionSettingId, questionSettingOptions, courseInfoIdPair);
}
/**
* 增加题目类型的数据
* 从系统题库中拉取
* <p>
* 任务一；添加题目配置主表
* 任务二：添加题目快照表
*
* @param settingQuery
* @return
*/
public void addQuestionByType(@Validated(ValidateConfig.ADD.class) TeacherOpenCourseQuestionSettingQuery settingQuery) {
public void addQuestionByTypeFromSystem(@Validated(ValidateConfig.ADD.class) TeacherOpenCourseQuestionSettingQuery settingQuery, Map<Long, Long> courseInfoIdPair ) {
if (null == settingQuery.getTeacherOpenCourseQuestionSettingStatus()) {
settingQuery.setTeacherOpenCourseQuestionSettingStatus(1);
}
if (null == settingQuery.getTeacherOpenCourseQuestionSettingPushStatus()) {
settingQuery.setTeacherOpenCourseQuestionSettingPushStatus(1);
}
// 添加到作业主表中
add(settingQuery);
@ -164,17 +228,289 @@ public class TeacherOpenCourseQuestionSettingService extends CoreBaseService<Tea
// 插入快照
Long teacherOpenCourseQuestionSettingId = settingQuery.getTeacherOpenCourseQuestionSettingId();
List<TeacherOpenCourseQuestionSettingDTO> questionSettingOptions = settingQuery.getQuestionSettingOptions();
resourcesQuestionSnapshotService.insertBatchByQuestionIds(teacherOpenCourseQuestionSettingId, questionSettingOptions);
resourcesQuestionSnapshotService.insertBatchBySystemResourcesQuestion(teacherOpenCourseQuestionSettingId, questionSettingOptions, courseInfoIdPair);
}
/**
* 通过无类别区分的题目ID，对题目进行分组。并构建需要的数据
* 只适用于手动出题这块。
*
* @param noDiffResourcesQuestionIdPlural 题目ID来自ResourcesQuestion表。
* @return
*/
public Map<ResourcesQuestionTypeEnum, TeacherOpenCourseQuestionSettingDTO> buildSettingDtoListByNoDiffQuestionIds(
@NotEmpty(message = "系统题目ID不能为空！") String noDiffResourcesQuestionIdPlural) {
// 只查询正常状态的题目列表
ResourcesQuestionQuery resourcesQuestionQuery = new ResourcesQuestionQuery();
resourcesQuestionQuery.setQuestionStatus(1);
resourcesQuestionQuery.setResourcesQuestionIds(noDiffResourcesQuestionIdPlural);
List<ResourcesQuestion> valuesByQuery = resourcesQuestionService.getValuesByQuery(resourcesQuestionQuery);
return buildSettingDtoListByNoDiffQuestionList(valuesByQuery);
}
/**
* 处理章节节点，下面所有的题目
* 并保存到题目配置和题目快照表
* 从系统题库表拷贝！！！
*
* @param teacherOpenCourseId 开课ID
* @param courseInfos 当前课程下的子节点
* @param courseInfoIdPair 课程的新旧ID片段集合
*/
public void processGroupChapterListToQuestionSetting(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId,
Collection<CourseInfo> courseInfos, Map<Long, Long> courseInfoIdPair) {
// 章节对应下面的所有子集
Map<CourseInfo, List<CourseInfo>> courseChapterInfoIdsWithChildren = courseInfoService.getCourseChapterInfoIdsWithChildren(courseInfos);
courseChapterInfoIdsWithChildren.forEach((courseInfo, chapterInfoList) -> {
// 该列表下的所有ID合并
String allCourseInfoIds = chapterInfoList.stream().map(item -> item.getCourseInfoId().toString()).collect(joining(","));
List<ResourcesQuestion> questionList = resourcesQuestionService.getByCourseInfoIds(allCourseInfoIds);
// 有题目才继续执行
if(ObjectUtil.isNotEmpty(questionList)) {
Map<ResourcesQuestionTypeEnum, TeacherOpenCourseQuestionSettingDTO> map = buildSettingDtoListByNoDiffQuestionList(questionList);
Map<CourseInfo, Collection<TeacherOpenCourseQuestionSettingDTO>> courseInfoIdWithQuestionSettingOptions = new HashMap<>(1);
courseInfoIdWithQuestionSettingOptions.put(courseInfo, map.values());
addTeacherOpenCourseQuestionBySystemCourseInfo(teacherOpenCourseId, courseInfoIdWithQuestionSettingOptions, courseInfoIdPair);
}
});
}
/**
* 根据开课的课程信息，添加题目配置和题目
* 这里不区分节点是什么类型的。
* 严格要求：
*
* 添加主表
* 任务一：添加主表
* 任务二：添加到题目配置主表；
* 任务二：也可以添加题目快照（非必选）
*/
public void addTeacherOpenCourseQuestionByCourseInfo(@Validated(ValidateConfig.ADD.class) TeacherOpenCourseMergeCourseInfoQuery teacherOpenCourseMergeCourseInfoQuery,
@Nullable Collection<TeacherOpenCourseQuestionSettingDTO> questionSettingOptions, Map<Long, Long> courseInfoIdPair) {
Long teacherOpenCourseId = teacherOpenCourseMergeCourseInfoQuery.getTeacherOpenCourseId();
TeacherOpenCourseQuestionSettingQuery settingQuery = new TeacherOpenCourseQuestionSettingQuery();
// 设置章节练习的默认配置，并设置开课ID
settingQuery.setCourseTestDefault().setTeacherOpenCourseId(teacherOpenCourseId);
settingQuery.setTeacherOpenCourseQuestionSettingName(teacherOpenCourseMergeCourseInfoQuery.getCourseInfoName());
settingQuery.setQuestionSettingOptions(new ArrayList<>(questionSettingOptions));
addQuestionByTypeFromSystem(settingQuery, courseInfoIdPair);
}
/**
* 根据开课的课程信息，添加题目配置和题目
*
* 添加主表
* 任务一：添加主表
* 任务二：添加到题目配置主表；
* 任务二：也可以添加题目快照（非必选）
* @param teacherOpenCourseId 开课ID
* @param courseInfoIdWithQuestionSettingOptions Key：课程名称，Value：题型和题目ID的组合列表
*/
public void addTeacherOpenCourseQuestionByCourseInfo(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId,
@Nullable Map<TeacherOpenCourseMergeCourseInfo, Collection<TeacherOpenCourseQuestionSettingDTO>> courseInfoIdWithQuestionSettingOptions,
@NotNull Map<Long, Long> courseInfoIdPair) {
addTeacherOpenCourseQuestionByCourseInfo(teacherOpenCourseId, courseInfoIdWithQuestionSettingOptions, Integer.valueOf(2), TeacherOpenCourseMergeCourseInfo::getCourseInfoType, courseInfoIdPair);
}
/**
* 根据开课的课程信息，添加题目配置和题目
* <p>
* 添加主表
* 任务一：添加主表
* 任务二：添加到题目配置主表；
* 任务二：也可以添加题目快照（非必选）
*
* @param teacherOpenCourseId 开课ID
* @param courseInfoIdWithQuestionSettingOptions Key：课程名称，Value：题型和题目ID的组合列表
* @param eq 待比对的值
* @param func1 比对的字段取值接口
* @param courseInfoIdPair
*/
public void addTeacherOpenCourseQuestionByCourseInfo(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId,
@Nullable Map<TeacherOpenCourseMergeCourseInfo, Collection<TeacherOpenCourseQuestionSettingDTO>> courseInfoIdWithQuestionSettingOptions,
@NotNull Object eq, @NotNull Func1<TeacherOpenCourseMergeCourseInfo, Integer> func1, @NotNull Map<Long, Long> courseInfoIdPair) {
TeacherOpenCourseQuestionSettingQuery settingQuery = new TeacherOpenCourseQuestionSettingQuery();
// 设置章节练习的默认配置，并设置开课ID
settingQuery.setCourseTestDefault().setTeacherOpenCourseId(teacherOpenCourseId);
courseInfoIdWithQuestionSettingOptions.forEach((courseInfo, settingDtoList) -> {
// 判断，添加交给外部来控制
try {
if(eq.equals(func1.call(courseInfo))) {
settingQuery.setQuestionSettingOptions(new ArrayList<>(settingDtoList));
settingQuery.setTeacherOpenCourseQuestionSettingName(courseInfo.getCourseInfoName());
addByMergeQuestion(settingQuery, courseInfoIdPair);
}
} catch (Exception e) { }
});
}
/**
* 根据开课的课程信息，添加题目配置和题目
*
* 添加主表
* 任务一：添加主表
* 任务二：添加到题目配置主表；
* 任务二：也可以添加题目快照（非必选）
* @param teacherOpenCourseId 开课ID
* @param courseInfoIdWithQuestionSettingOptions Key：课程名称，Value：题型和题目ID的组合列表
*/
public void addTeacherOpenCourseQuestionBySystemCourseInfo(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId,
@Nullable Map<CourseInfo, Collection<TeacherOpenCourseQuestionSettingDTO>> courseInfoIdWithQuestionSettingOptions,
@NotNull Map<Long, Long> courseInfoIdPair) {
addTeacherOpenCourseQuestionBySystemCourseInfo(teacherOpenCourseId, courseInfoIdWithQuestionSettingOptions, Integer.valueOf(2), CourseInfo::getCourseInfoType, courseInfoIdPair);
}
/**
* 根据开课的课程信息，添加题目配置和题目
* <p>
* 添加主表
* 任务一：添加主表
* 任务二：添加到题目配置主表；
* 任务二：也可以添加题目快照（非必选）
*
* @param teacherOpenCourseId 开课ID
* @param courseInfoIdWithQuestionSettingOptions Key：课程名称，Value：题型和题目ID的组合列表
* @param eq 待比对的值
* @param func1 比对的字段取值接口
* @param courseInfoIdPair
*/
public void addTeacherOpenCourseQuestionBySystemCourseInfo(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId,
@Nullable Map<CourseInfo, Collection<TeacherOpenCourseQuestionSettingDTO>> courseInfoIdWithQuestionSettingOptions,
@NotNull Object eq, @NotNull Func1<CourseInfo, Integer> func1, @NotNull Map<Long, Long> courseInfoIdPair) {
TeacherOpenCourseQuestionSettingQuery settingQuery = new TeacherOpenCourseQuestionSettingQuery();
// 设置章节练习的默认配置，并设置开课ID
settingQuery.setCourseTestDefault().setTeacherOpenCourseId(teacherOpenCourseId);
courseInfoIdWithQuestionSettingOptions.forEach((courseInfo, settingDtoList) -> {
// 判断，添加交给外部来控制
try {
if(eq.equals(func1.call(courseInfo))) {
settingQuery.setQuestionSettingOptions(new ArrayList<>(settingDtoList));
settingQuery.setTeacherOpenCourseQuestionSettingName(courseInfo.getCourseInfoName());
addQuestionByTypeFromSystem(settingQuery, courseInfoIdPair);
}
} catch (Exception e) { }
});
}
/**
* 通过无类别区分的题目列表，对题目进行分组。并构建需要的数据
* 只适用于手动出题这块。
*
* @param resourcesQuestionList
* @return
*/
public Map<ResourcesQuestionTypeEnum, TeacherOpenCourseQuestionSettingDTO> buildSettingDtoListByNoDiffQuestionList(
List<ResourcesQuestion> resourcesQuestionList) {
if (ObjectUtil.isEmpty(resourcesQuestionList)) {
return null;
}
// 先构建初始的属性
Function<ResourcesQuestion, TeacherOpenCourseQuestionSettingDTO> buildFunc =
item -> TeacherOpenCourseQuestionSettingDTO.builder()
.questionType(EnumUtil.likeValueOf(ResourcesQuestionTypeEnum.class, item.getQuestionType()))
.resourcesQuestionIdPlural(item.getResourcesQuestionId().toString())
.singleScore(item.getQuestionScore())
.build();
// 根据类型分组
Map<ResourcesQuestionTypeEnum, List<TeacherOpenCourseQuestionSettingDTO>> groupMap =
resourcesQuestionList.stream().map(buildFunc).collect(groupingBy(TeacherOpenCourseQuestionSettingDTO::getQuestionType));
Map<ResourcesQuestionTypeEnum, TeacherOpenCourseQuestionSettingDTO> result = new ConcurrentHashMap<>(5);
// 分组后的数据，再处理
groupMap.forEach((key, value) -> {
// resourcesQuestionIdPlural 上面暂存的是单个题目ID，这里将所有的题目ID处理成逗号隔开的字符
String questionIds = value.stream()
.map(TeacherOpenCourseQuestionSettingDTO::getResourcesQuestionIdPlural).collect(joining(","));
// 查询到的题目的数量
Integer selectCount = ObjectUtil.defaultIfNull(value, Lists.emptyList()).size();
// 设置其他属性，如果集合长度不为空的话
if (selectCount > 0) {
TeacherOpenCourseQuestionSettingDTO teacherOpenCourseQuestionSettingDTO = value.get(0);
// 该类型下，单个题目的分数
BigDecimal singleScore = teacherOpenCourseQuestionSettingDTO.getSingleScore();
teacherOpenCourseQuestionSettingDTO.setResourcesQuestionIdPlural(questionIds)
.setSingleTypeTotalScore(NumberUtil.mul(singleScore, selectCount))
.setSelectCount(selectCount);
// 放入结果集中
result.put(key, teacherOpenCourseQuestionSettingDTO);
}
});
return result;
}
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("重置开课题目配置");
sqlManager.lambdaQuery(TeacherOpenCourseQuestionSetting.class)
.andEq(TeacherOpenCourseQuestionSetting::getTeacherOpenCourseId, teacherOpenCourseId)
.delete();
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
deleteWithSubDataByParams(teacherOpenCourseId, null);
}
/**
* 可以删除子表数据的方法
* 根据名称
* @param teacherOpenCourseId
* @param teacherOpenCourseQuestionSettingName （可为空，为空则不指定名称删除）
*/
public void deleteWithSubDataByParams(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId,
@Nullable String teacherOpenCourseQuestionSettingName) {
// 条件
TeacherOpenCourseQuestionSetting condition = new TeacherOpenCourseQuestionSetting();
condition.setTeacherOpenCourseId(teacherOpenCourseId);
condition.setTeacherOpenCourseQuestionSettingName(teacherOpenCourseQuestionSettingName);
List<TeacherOpenCourseQuestionSetting> settingList = getValues(condition);
// 获取需要删除的ID集合
List<Long> idList = settingList.stream()
.map(TeacherOpenCourseQuestionSetting::getTeacherOpenCourseQuestionSettingId).collect(Collectors.toList());
// 获取完ID以后，删除主表数据
sqlManager.lambdaQuery(TeacherOpenCourseQuestionSetting.class)
.andEq(TeacherOpenCourseQuestionSetting::getTeacherOpenCourseId, teacherOpenCourseId)
.andEq(TeacherOpenCourseQuestionSetting::getTeacherOpenCourseQuestionSettingName, teacherOpenCourseQuestionSettingName)
.delete();
// 获取题目配置ID集合
String settingIds = join(",", idList);
if (ObjectUtil.isNotEmpty(settingIds)) {
// 删除子表的数据（题目快照）
resourcesQuestionSnapshotService.deleteByTeacherOpenCourseQuestionSettingIds(settingIds);
// 删除子表的数据（题目配置）
teacherOpenCourseQuestionLogService.deleteByTeacherOpenCourseQuestionSettingIds(settingIds);
// 删除子表的数据（错题库）
teacherOpenCourseQuestionLogWrongService.deleteByTeacherOpenCourseQuestionSettingIds(settingIds);
}
}
}

5
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseScheduleSessionClassService.java
Unescape Escape View File

@ -20,6 +20,7 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.validation.constraints.NotNull;
import java.util.*;
import java.util.stream.Collectors;
@ -239,11 +240,11 @@ public class TeacherOpenCourseScheduleSessionClassService extends CoreBaseServic
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}

4
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseScheduleSessionService.java
Unescape Escape View File

@ -405,11 +405,11 @@ public class TeacherOpenCourseScheduleSessionService extends CoreBaseService<Tea
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}

5
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseScheduleSessionSnapService.java
Unescape Escape View File

@ -18,6 +18,7 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.validation.constraints.NotNull;
import java.util.ArrayList;
import java.util.List;
@ -149,11 +150,11 @@ public class TeacherOpenCourseScheduleSessionSnapService extends CoreBaseService
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}

5
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseScheduleSessionTagService.java
Unescape Escape View File

@ -18,6 +18,7 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.validation.constraints.NotNull;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
@ -151,11 +152,11 @@ public class TeacherOpenCourseScheduleSessionTagService extends CoreBaseService<
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}
}

5
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseScoreDashboardService.java
Unescape Escape View File

@ -30,6 +30,7 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.validation.constraints.NotNull;
import java.io.*;
import java.math.BigDecimal;
import java.text.DateFormat;
@ -493,11 +494,11 @@ public class TeacherOpenCourseScoreDashboardService extends CoreBaseService<Teac
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}
}

5
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseScoreWeightService.java
Unescape Escape View File

@ -18,6 +18,7 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.validation.constraints.NotNull;
import java.util.ArrayList;
import java.util.List;
@ -148,11 +149,11 @@ public class TeacherOpenCourseScoreWeightService extends CoreBaseService<Teacher
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}
}

2
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseService.java
Unescape Escape View File

@ -19,6 +19,7 @@ import org.apache.commons.lang3.StringUtils;
import org.beetl.sql.core.SqlId;
import org.beetl.sql.core.engine.PageQuery;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@ -179,6 +180,7 @@ public class TeacherOpenCourseService extends CoreBaseService<TeacherOpenCourse>
return teacherOpenCourseDao.getValuesByQuery(teacherOpenCourseQuery);
}
@Cacheable(value="teacherOpenCourseService.getInfo", key="#teacherOpenCourseId")
public TeacherOpenCourse getInfo (Long teacherOpenCourseId){
TeacherOpenCourseQuery teacherOpenCourseQuery = new TeacherOpenCourseQuery();
teacherOpenCourseQuery.setTeacherOpenCourseId(teacherOpenCourseId);

4
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseStudentSigninLogService.java
Unescape Escape View File

@ -626,11 +626,11 @@ public class TeacherOpenCourseStudentSigninLogService extends CoreBaseService<Te
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}
}

4
web/src/main/java/com/ibeetl/jlw/service/TeacherOpenCourseStudentSigninSettingService.java
Unescape Escape View File

@ -205,11 +205,11 @@ public class TeacherOpenCourseStudentSigninSettingService extends CoreBaseServic
@Override
public void resetOperationByTeacherOpenCourseId(Long teacherOpenCourseId) {
log.info("不需要实现重置操作！");
log.info("可能需要实现重置操作！");
}
@Override
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(Long teacherOpenCourseId) {
public void deleteTeacherOpenCourseAllRelatedByTeacherOpenCourseId(@NotNull(message = "开课ID不能为空！") Long teacherOpenCourseId) {
log.info("需要实现删除操作！");
}
}

3
web/src/main/java/com/ibeetl/jlw/web/TeacherOpenCourseMergeCourseInfoController.java
Unescape Escape View File

@ -39,6 +39,7 @@ import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@ -173,7 +174,7 @@ public class TeacherOpenCourseMergeCourseInfoController{
Assert.notNull(coreUser, "请登录后再操作");
teacherOpenCourseMergeCourseInfoQuery.setUserId(coreUser.getId());
teacherOpenCourseMergeCourseInfoQuery.setOrgId(coreUser.getOrgId());
return teacherOpenCourseMergeCourseInfoService.add(teacherOpenCourseMergeCourseInfoQuery);
return teacherOpenCourseMergeCourseInfoService.addCourseAndQuestionWithQuestionSnap(teacherOpenCourseMergeCourseInfoQuery, null, new HashMap<>());
}
}

9
web/src/main/java/com/ibeetl/jlw/web/TeacherOpenCourseQuestionSettingController.java
Unescape Escape View File

@ -20,6 +20,7 @@ import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;
import java.util.HashMap;
import java.util.List;
/**
@ -90,13 +91,7 @@ public class TeacherOpenCourseQuestionSettingController{
Assert.notNull(coreUser, "请登录后再操作");
teacherOpenCourseQuestionSettingQuery.setUserId(coreUser.getId());
teacherOpenCourseQuestionSettingQuery.setOrgId(coreUser.getOrgId());
if (null == teacherOpenCourseQuestionSettingQuery.getTeacherOpenCourseQuestionSettingStatus()) {
teacherOpenCourseQuestionSettingQuery.setTeacherOpenCourseQuestionSettingStatus(1);
}
if (null == teacherOpenCourseQuestionSettingQuery.getTeacherOpenCourseQuestionSettingPushStatus()) {
teacherOpenCourseQuestionSettingQuery.setTeacherOpenCourseQuestionSettingPushStatus(1);
}
teacherOpenCourseQuestionSettingService.addQuestionByType(teacherOpenCourseQuestionSettingQuery);
teacherOpenCourseQuestionSettingService.addByMergeQuestion(teacherOpenCourseQuestionSettingQuery, new HashMap<>(1));
return JsonResult.success();
}

8
web/src/main/java/com/ibeetl/jlw/web/query/TeacherOpenCourseMergeCourseInfoQuery.java
Unescape Escape View File

@ -5,6 +5,7 @@ import com.ibeetl.admin.core.annotation.Query;
import com.ibeetl.admin.core.web.query.PageParam;
import com.ibeetl.jlw.entity.TeacherOpenCourseMergeCourseInfo;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
/**
@ -14,8 +15,12 @@ public class TeacherOpenCourseMergeCourseInfoQuery extends PageParam {
@NotNull(message = "ID不能为空", groups =ValidateConfig.UPDATE.class)
@Query(name = "ID", display = false)
private Long teacherOpenCourseMergeCourseInfoId;
@Query(name = "开课名称", display = true,type=Query.TYPE_DICT,dict="teacher_open_course.teacher_open_course_title.teacher_open_course_status=1")
@NotNull(message = "开课ID不能为空", groups =ValidateConfig.ADD.class)
@Query(name = "开课ID", display = true,type=Query.TYPE_DICT,dict="teacher_open_course.teacher_open_course_title.teacher_open_course_status=1")
private Long teacherOpenCourseId;
@NotEmpty(message = "章节名称不能为空", groups =ValidateConfig.ADD.class)
@Query(name = "名称（课程名 或 章名 或 节名）", display = false)
private String courseInfoName;
@Query(name = "课程缩略图", display = false)
@ -29,6 +34,7 @@ public class TeacherOpenCourseMergeCourseInfoQuery extends PageParam {
@Query(name = "状态(1启用 2禁用 3删除)", display = false)
private Integer courseInfoStatus;
@Query(name = "类型(1课程 2章 3节)", display = false)
@NotNull(message = "类型不能为空", groups =ValidateConfig.ADD.class)
private Integer courseInfoType;
@Query(name = "父节点ID", display = false)
private Long courseInfoParentId;

35
web/src/main/java/com/ibeetl/jlw/web/query/TeacherOpenCourseQuestionSettingQuery.java
Unescape Escape View File

@ -1,5 +1,6 @@
package com.ibeetl.jlw.web.query;
import cn.hutool.core.date.DateField;
import cn.jlw.validate.ValidateConfig;
import com.ibeetl.admin.core.annotation.Query;
import com.ibeetl.admin.core.web.query.PageParam;
@ -14,6 +15,8 @@ import javax.validation.constraints.NotNull;
import java.util.Date;
import java.util.List;
import static cn.hutool.core.date.DateUtil.offset;
/**
*题目配置查询
*/
@ -113,6 +116,10 @@ public class TeacherOpenCourseQuestionSettingQuery extends PageParam {
return pojo;
}
/**
* 考试的默认配置
* @param setting
*/
public static void setDefault(TeacherOpenCourseQuestionSettingQuery setting) {
setting.setTeacherOpenCourseQuestionSettingStatus(1);
setting.setTeacherOpenCourseQuestionSettingAddTime(new Date());
@ -124,7 +131,33 @@ public class TeacherOpenCourseQuestionSettingQuery extends PageParam {
setting.setTeacherOpenCourseQuestionSettingSchoolClassIds("ALL");
}
public void setDefault() {
/**
* 章节练习的默认配置
* @param setting
*/
public static void setCourseTestDefault(TeacherOpenCourseQuestionSettingQuery setting) {
setting.setTeacherOpenCourseQuestionSettingStatus(1);
setting.setTeacherOpenCourseQuestionSettingAddTime(new Date());
setting.setTeacherOpenCourseQuestionSettingOptionNoOrder(1);
setting.setTeacherOpenCourseQuestionSettingQuestionNoOrder(1);
setting.setTeacherOpenCourseQuestionSettingEndShowTrueFalse(1);
setting.setTeacherOpenCourseQuestionSettingEndShowQa(1);
setting.setTeacherOpenCourseQuestionSettingDoCount(1000);
setting.setTeacherOpenCourseQuestionSettingType(ResourcesQuestionSnapshotFromTypeEnum.CHAPTER_EXERCISE);
setting.setTeacherOpenCourseQuestionSettingSchoolClassIds("ALL");
setting.setTeacherOpenCourseQuestionSettingPushStatus(1);
setting.setTeacherOpenCourseQuestionStartTime(new Date());
// 结束时间设置为20年后
setting.setTeacherOpenCourseQuestionEndTime(offset(new Date(), DateField.YEAR, 20));
}
public TeacherOpenCourseQuestionSettingQuery setCourseTestDefault() {
setCourseTestDefault(this);
return this;
}
public TeacherOpenCourseQuestionSettingQuery setDefault() {
setDefault(this);
return this;
}
}

6
web/src/main/resources/sql/jlw/resourcesQuestion.md
Unescape Escape View File

@ -123,6 +123,9 @@ getValuesByQuery
@if(!isEmpty(questionType)){
and t.question_type =#questionType#
@}
@if(!isEmpty(questionStatus)){
and t.question_status =#questionStatus#
@}
@if(!isEmpty(questionScore)){
and t.question_score =#questionScore#
@}
@ -226,6 +229,9 @@ getResourcesQuestionValues
@if(!isEmpty(userId)){
and t.user_id =#userId#
@}
@if(!isEmpty(questionStatus)){
and t.question_status =#questionStatus#
@}
getValuesToCourseInfo

8
web/src/main/resources/sql/jlw/resourcesQuestionSnapshot.md
Unescape Escape View File

@ -172,6 +172,14 @@ deleteResourcesQuestionSnapshotByIds
delete from resources_question_snapshot where find_in_set(resources_question_snapshot_id,#ids#)
deleteByTeacherOpenCourseQuestionSettingIds
===
* 批量删除(通过题目配置ID)
delete from resources_question_snapshot where find_in_set(teacher_open_course_question_setting_id,#settingIds#)
getByIds
===

43
web/src/main/resources/sql/jlw/teacherOpenCourseMergeResourcesQuestion.md
Unescape Escape View File

@ -740,6 +740,49 @@ getRandomMergeResourcesQuestionList
@}
@}
getRandomMergeResourcesQuestionListBySystem
===
* 根据题目设置随机出题（从系统的题库获取）
select
@if(!isEmpty(singleScore)){
'' as teacher_open_course_merge_resources_question_id,
'' as teacher_open_course_id,
t.course_info_id as teacher_open_course_merge_course_info_id,
t.question_type,
t.question_stem,
t.question_option_a,
t.question_option_b,
t.question_option_c,
t.question_option_d,
t.question_option_e,
t.question_answer,
#singleScore# as question_score,
t.question_analysis,
t.question_status,
t.user_id,
t.org_id
@} else {
t.*
@}
from resources_question t
where 1=1
and t.question_status = 1
@// 题目ID优先级高
@if(!isEmpty(resourcesQuestionIdPlural)) {
and find_in_set(t.resources_question_id, #resourcesQuestionIdPlural#)
@} else {
@// 随机抽题，根据题目配置动态抽取题目。会存在题库抽不够数的情况。
@if(!isEmpty(questionType)){
and find_in_set(t.question_type, #questionType#)
@}
@if(!isEmpty(selectCount)){
ORDER BY RAND()
limit #selectCount#
@}
@}
getGroupQuestionTypeCount
===
* 开课离线题库，根据题目类型分组查询数量

7
web/src/main/resources/sql/jlw/teacherOpenCourseQuestionLog.md
Unescape Escape View File

@ -331,6 +331,13 @@ deleteByIds
delete from teacher_open_course_question_log where find_in_set(teacher_open_course_question_log_id,#ids#)
deleteByTeacherOpenCourseQuestionSettingIds
===
* 根据题目配置ID 批量（真删除）
delete from teacher_open_course_question_log where find_in_set(teacher_open_course_question_setting_id, settingIds#)
getByIds

7
web/src/main/resources/sql/jlw/teacherOpenCourseQuestionLogWrong.md
Unescape Escape View File

@ -210,6 +210,13 @@ deleteByIds
delete from teacher_open_course_question_log_wrong where find_in_set(teacher_open_course_question_log_wrong_id,#ids#)
deleteByTeacherOpenCourseQuestionSettingIds
===
* 批量删除(通过题目配置ID)
delete from teacher_open_course_question_log_wrong where find_in_set(teacher_open_course_question_setting_id,#settingIds#)
getByIds
===

4
web/src/test/java/com/ibeetl/jlw/web/TeacherOpenCourseMergeSchoolClassControllerTest.java
Unescape Escape View File

@ -122,8 +122,4 @@ public class TeacherOpenCourseMergeSchoolClassControllerTest extends BaseTest {
public void delete() {
}
@Test
public void deleteByCondition() {
}
}
Write Preview
Loading…
Cancel
Save