高效选课系统：一键管理你的课程表

选课流程

数据模型

我的课程表Controller

@Api(value = "我的课程表接口", tags = "我的课程表接口")
@Slf4j
@RestController
public class MyCourseTablesController {

    @Autowired
    private MyCourseTablesService myCourseTablesService;


    @ApiOperation("添加选课")
    @PostMapping("/choosecourse/{courseId}")
    public XcChooseCourseDto addChooseCourse(@PathVariable("courseId") Long courseId) {
        // 当前登录的用户
        SecurityUtil.XcUser user = SecurityUtil.getUser();
        if (user == null) {
            XueChengPlusException.cast("请登录后继续选课");
        }
        // 用户id
        String userId = user.getId();
        // 添加选课
        XcChooseCourseDto xcChooseCourseDto = myCourseTablesService.addChooseCourse(userId, courseId);

        return xcChooseCourseDto;
    }

    @ApiOperation("查询学习资格")
    @PostMapping("/choosecourse/learnstatus/{courseId}")
    public XcCourseTablesDto getLearnstatus(@PathVariable("courseId") Long courseId) {
        log.debug("查询学习资格，参数courseId:{}", courseId);
        //登录用户
        SecurityUtil.XcUser user = SecurityUtil.getUser();
        if (user == null) {
            XueChengPlusException.cast("请登录后继续选课");
        }
        String userId = user.getId();
        return myCourseTablesService.getLearningStatus(userId, courseId);

    }


    @ApiOperation("我的课程表")
    @GetMapping("/mycoursetable")
    public PageResult<XcCourseTables> mycoursetable(MyCourseTableParams params) {
        //登录用户
        SecurityUtil.XcUser user = SecurityUtil.getUser();
        if (user == null) {
            XueChengPlusException.cast("请登录后继续选课");
        }
        String userId = user.getId();
        //设置当前的登录用户
        params.setUserId(userId);

        return myCourseTablesService.mycoursetabls(params);
    }


}

我的课程表服务

添加选课记录

/**
 * 添加选课记录
 *
 * @param userId   学生ID
 * @param courseId 课程ID
 * @return 返回选课记录Dto对象
 * @throws XueChengPlusException 当课程不存在时抛出异常
 */
@Override
public XcChooseCourseDto addChooseCourse(String userId, Long courseId) {
    // 选课调用内容管理查询课程的收费规则
    CoursePublish coursepublish = contentServiceClient.getCoursepublish(courseId);
    if (coursepublish == null) {
        XueChengPlusException.cast("课程不存在");
    }
    // 收费规则
    String charge = coursepublish.getCharge();
    // 选课记录
    XcChooseCourse xcChooseCourse = null;
    if ("201000".equals(charge)) {
        // 免费课程，向选课记录表、我的课程表写数据
        xcChooseCourse = addFreeCourse(userId, coursepublish);
        // 向我的课程表写数据
        XcCourseTables xcCourseTables = addCourseTables(xcChooseCourse);
    } else {
        // 如果收费课程，向选课记录表写数据
        xcChooseCourse = addChargeCourse(userId, coursepublish);
    }
    // 判断学生的学习资格
    XcCourseTablesDto xcCourseTablesDto = getLearningStatus(userId, courseId);

    // 构造返回值
    XcChooseCourseDto xcChooseCourseDto = new XcChooseCourseDto();
    BeanUtils.copyProperties(xcChooseCourse, xcChooseCourseDto);
    // 设置学习资格状态
    xcChooseCourseDto.setLearnStatus(xcCourseTablesDto.getLearnStatus());
    return xcChooseCourseDto;
}

添加免费课程,免费课程加入选课记录表、我的课程表

public XcChooseCourse addFreeCourse(String userId, CoursePublish coursepublish) {
        Long courseId = coursepublish.getId();
        // 判断，如果存在免费的选课记录且选课状态为成功，直接返回
        // 创建LambdaQueryWrapper查询对象
        LambdaQueryWrapper<XcChooseCourse> queryWrapper = new LambdaQueryWrapper<XcChooseCourse>()
                // 查询用户ID为userId的记录
                .eq(XcChooseCourse::getUserId, userId)
                // 查询课程ID为courseId的记录
                .eq(XcChooseCourse::getCourseId, courseId)
                // 查询订单类型为免费课程的记录
                .eq(XcChooseCourse::getOrderType, "700001") // 免费课程
                // 查询选课状态为成功的记录
                .eq(XcChooseCourse::getStatus, "701001"); // 选课成功
    
        // 执行查询，获取查询结果
        List<XcChooseCourse> xcChooseCourses = chooseCourseMapper.selectList(queryWrapper);
        // 如果查询结果不为空且存在选课记录，则直接返回第一条选课记录
        if (xcChooseCourses != null && !xcChooseCourses.isEmpty()) {
            return xcChooseCourses.get(0);
        }
    
        // 向选课记录表写数据
        // 创建XcChooseCourse对象
        XcChooseCourse xcChooseCourse = new XcChooseCourse();
        // 设置课程ID
        xcChooseCourse.setCourseId(courseId);
        // 设置用户ID
        xcChooseCourse.setUserId(userId);
        // 设置课程名称
        xcChooseCourse.setCourseName(coursepublish.getName());
        // 设置公司ID
        xcChooseCourse.setCompanyId(coursepublish.getCompanyId());
        // 设置订单类型为免费课程
        xcChooseCourse.setOrderType("700001");
        // 设置创建时间为当前时间
        xcChooseCourse.setCreateDate(LocalDateTime.now());
        // 设置有效天数为365天
        xcChooseCourse.setValidDays(365);
        // 设置课程价格为coursepublish的价格
        xcChooseCourse.setCoursePrice(coursepublish.getPrice());
        // 设置选课状态为成功
        xcChooseCourse.setStatus("701001");
        // 设置有效期开始时间为当前时间
        xcChooseCourse.setValidtimeStart(LocalDateTime.now());
        // 设置有效期结束时间为当前时间加365天
        xcChooseCourse.setValidtimeEnd(LocalDateTime.now().plusDays(365));
    
        // 执行插入操作，返回插入结果
        int insert = chooseCourseMapper.insert(xcChooseCourse);
        // 如果插入失败，则抛出异常
        if (insert <= 0) {
            XueChengPlusException.cast("添加选课记录失败");
        }
    
        // 返回插入成功的选课记录
        return xcChooseCourse;
    }

添加收费课程

public XcChooseCourse addChargeCourse(String userId, CoursePublish coursepublish) {
    Long courseId = coursepublish.getId();
    // 判断，如果存在收费的选课记录且选课状态为待支付，直接返回
    // 创建LambdaQueryWrapper查询对象
    LambdaQueryWrapper<XcChooseCourse> queryWrapper = new LambdaQueryWrapper<XcChooseCourse>()
            // 查询用户ID为userId的记录
            .eq(XcChooseCourse::getUserId, userId)
            // 查询课程ID为courseId的记录
            .eq(XcChooseCourse::getCourseId, courseId)
            // 查询订单类型为免费课程的记录
            .eq(XcChooseCourse::getOrderType, "700002") // 收费课程
            // 查询选课状态为成功的记录
            .eq(XcChooseCourse::getStatus, "701002"); // 待支付

    // 执行查询，获取查询结果
    List<XcChooseCourse> xcChooseCourses = chooseCourseMapper.selectList(queryWrapper);
    // 如果查询结果不为空且存在选课记录，则直接返回第一条选课记录
    if (xcChooseCourses != null && !xcChooseCourses.isEmpty()) {
        return xcChooseCourses.get(0);
    }

    // 向选课记录表写数据
    // 创建XcChooseCourse对象
    XcChooseCourse xcChooseCourse = new XcChooseCourse();
    // 设置课程ID
    xcChooseCourse.setCourseId(courseId);
    // 设置用户ID
    xcChooseCourse.setUserId(userId);
    // 设置课程名称
    xcChooseCourse.setCourseName(coursepublish.getName());
    // 设置公司ID
    xcChooseCourse.setCompanyId(coursepublish.getCompanyId());
    // 设置订单类型为免费课程
    xcChooseCourse.setOrderType("700002"); // 收费课程
    // 设置创建时间为当前时间
    xcChooseCourse.setCreateDate(LocalDateTime.now());
    // 设置有效天数为365天
    xcChooseCourse.setValidDays(365);
    // 设置课程价格为coursepublish的价格
    xcChooseCourse.setCoursePrice(coursepublish.getPrice());
    // 设置选课状态为成功
    xcChooseCourse.setStatus("701002"); // 待支付
    // 设置有效期开始时间为当前时间
    xcChooseCourse.setValidtimeStart(LocalDateTime.now()); // 有效期开始时间
    // 设置有效期结束时间为当前时间加365天
    xcChooseCourse.setValidtimeEnd(LocalDateTime.now().plusDays(365)); // 有效期结束时间

    // 执行插入操作，返回插入结果
    int insert = chooseCourseMapper.insert(xcChooseCourse);
    // 如果插入失败，则抛出异常
    if (insert <= 0) {
        XueChengPlusException.cast("添加选课记录失败");
    }

    // 返回插入成功的选课记录
    return xcChooseCourse;
}

根据课程和用户查询我的课程表中某一门课程

/**
 * @param userId
 * @param courseId
 * @return com.xuecheng.learning.model.po.XcCourseTables
 * @description 根据课程和用户查询我的课程表中某一门课程
 * @author Mr.M
 * @date 2022/10/2 17:07
 */
public XcCourseTables getXcCourseTables(String userId, Long courseId) {
    XcCourseTables xcCourseTables = courseTablesMapper.selectOne(new LambdaQueryWrapper<XcCourseTables>()
            .eq(XcCourseTables::getUserId, userId)
            .eq(XcCourseTables::getCourseId, courseId));
    return xcCourseTables;

}

添加到我的课程表

public XcCourseTables addCourseTables(XcChooseCourse xcChooseCourse) {
    // 选课成功了才可以向我的课程表添加数据
    String status = xcChooseCourse.getStatus();
    if (!"701001".equals(status)) {
        XueChengPlusException.cast("选课未成功，无法添加到我的课程表");
    }
    // 查一下我的课程表有没有记录
    XcCourseTables xcCourseTables = getXcCourseTables(xcChooseCourse.getUserId(), xcChooseCourse.getCourseId());
    if (xcCourseTables != null) {
        return xcCourseTables;
    }
    xcCourseTables = new XcCourseTables();
    BeanUtils.copyProperties(xcChooseCourse, xcCourseTables);
    xcCourseTables.setChooseCourseId(xcChooseCourse.getId());
    xcCourseTables.setCourseType(xcChooseCourse.getOrderType()); // 选课类型
    xcCourseTables.setUpdateDate(LocalDateTime.now());
    int insert = courseTablesMapper.insert(xcCourseTables);
    if (insert <= 0) {
        XueChengPlusException.cast("添加到我的课程表失败");
    }
    return xcCourseTables;
}

获取用户的学习状态

/**
 * 获取用户的学习状态
 *
 * @param userId 用户ID
 * @param courseId 课程ID
 * @return XcCourseTablesDto对象，包含用户的学习状态
 */
@Override
public XcCourseTablesDto getLearningStatus(String userId, Long courseId) {
    XcCourseTablesDto xcCourseTablesDto = new XcCourseTablesDto();
    // 查询我的课程表，如果查询不到说明没有选课
    XcCourseTables xcCourseTables = getXcCourseTables(userId, courseId);
    if (xcCourseTables == null) {
        // 如果没有选课记录，返回学习资格为空
        // "code":"702002","desc":"没有选课或选课后没有支付"
        xcCourseTablesDto.setLearnStatus("702002");
        return xcCourseTablesDto;
    }
    // 如果查到了，判断是否过期，如果过期不能继续学习,没有过期可以继续学习
    boolean before = xcCourseTables.getValidtimeEnd().isBefore(LocalDateTime.now());

    BeanUtils.copyProperties(xcCourseTables, xcCourseTablesDto);
    if (before) {
        // "code":"702003","desc":"己过期周要中请续期或重新支付"
        xcCourseTablesDto.setLearnStatus("702003");
    } else {
        //"code"："702001"，"desc"："正常学习”
        xcCourseTablesDto.setLearnStatus("702001");
    }
    return xcCourseTablesDto;
}

我的课程表

/**
 * 我的课程表
 * @param params 查询条件
 * @return
 */
@Override
public PageResult<XcCourseTables> mycoursestabls(MyCourseTableParams params) {
    // 用户id
    String userId = params.getUserId();
    // 当前页码
    int pageNo = params.getPage();
    // 每页记录数
    int size = params.getSize();
    // 分页
    Page<XcCourseTables> courseTablesPage = new Page<>(pageNo, size);
    // 查询条件
    LambdaQueryWrapper<XcCourseTables> lambdaQueryWrapper = new LambdaQueryWrapper<XcCourseTables>()
            .eq(XcCourseTables::getUserId, userId);
    // 查询数据
    Page<XcCourseTables> result = courseTablesMapper.selectPage(courseTablesPage, lambdaQueryWrapper);
    List<XcCourseTables> records = result.getRecords();
    // 总记录数
    long total = result.getTotal();
    return new PageResult<>(records, total, pageNo, size);
}