学成在线课程审核,发布,下架

 自己加了判断第一次发布MqMessage有没有进行redis.minio等进行保存数据,第二次可以提交审核,审核通过后不允许发布,等待第一次发布MqMessage保存到redis这些后才进行放行。不然MqMessage里面还没保存到redis这些,又来一条本课程的。（这些都是自己想的,如果有问题请见谅,可以给我提意见,谢谢您!）

package com.xuecheng.content.service.impl;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.xuecheng.base.exception.XueChengPlusException;
import com.xuecheng.content.mapper.CourseBaseMapper;
import com.xuecheng.content.mapper.CourseMarketMapper;
import com.xuecheng.content.mapper.CoursePublishMapper;
import com.xuecheng.content.mapper.CoursePublishPreMapper;
import com.xuecheng.content.model.dto.CourseBaseInfoDTO;
import com.xuecheng.content.model.dto.CoursePreviewDTO;
import com.xuecheng.content.model.dto.TeachplanDTO;
import com.xuecheng.content.model.po.*;
import com.xuecheng.content.service.*;
import com.xuecheng.messagesdk.mapper.MqMessageMapper;
import com.xuecheng.messagesdk.model.po.MqMessage;
import com.xuecheng.messagesdk.service.MqMessageService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;

@Service
public class CoursePublishServiceImpl implements CoursePublishService {
    @Autowired
    private CourseBaseInfoService courseBaseInfoService;
    @Autowired
    private TeachPlanService teacherService;
    @Autowired
    private CourseTeacherService courseTeacherService;
    @Autowired
    private CourseBaseMapper courseBaseMapper;
    @Autowired
    private CourseMarketMapper courseMarketMapper;
    @Autowired
    private CoursePublishPreMapper coursePublishPreMapper;
    @Autowired
    private CoursePublishMapper coursePublishMapper;
    @Autowired
    private MqMessageService mqMessageService;
    @Autowired
    private MqMessageMapper mqMessageMapper;

    @Override
    public CoursePreviewDTO getCoursePreviewInfo(Long courseId) {
        CoursePreviewDTO coursePreviewDTO = new CoursePreviewDTO();
        //课程基本信息,营销信息
        CourseBaseInfoDTO courseBaseInfo = courseBaseInfoService.getCourseBaseInfo(courseId);
        //课程计划信息
        List<TeachplanDTO> teachPlanTree = teacherService.findTeachPlanTree(courseId);
        //老师信息
        List<CourseTeacher> courseTeachers = courseTeacherService.selectCourseTeacherInfo(courseId);
        coursePreviewDTO.setCourseBase(courseBaseInfo);
        coursePreviewDTO.setTeachplans(teachPlanTree);
        coursePreviewDTO.setCourseTeachers(courseTeachers);
        return coursePreviewDTO;
    }

    /**
     * 提交课程审核
     * @param companyId
     * @param courseId
     */
    @Transactional
    @Override
    public void commitAudit(Long companyId, Long courseId) {
        CoursePublishPre coursePublishPreStatus = coursePublishPreMapper.selectById(courseId); //这里要拿到coursePublishPreStatus
        if (coursePublishPreStatus != null) { //判断它是不是为空
            String status = coursePublishPreStatus.getStatus(); //拿到预发布表的审核状态
            if ("202004".equals(status)) {//如果是202004(审核通过)就让他发布后再提交审核
                XueChengPlusException.cast("课程审核成功,请点击发布后再提交审核");
            }
        }
        // 检查课程是否已经在审核中
        if (isCourseUnderReview(courseId)) { //如果不是202004(审核通过)就返回课程还在审核不能再提交审核了,等待审核通过后才能提交
            XueChengPlusException.cast("课程还在审核不能再次提交...");
        }
        //约束校验
        CourseBase courseBase = courseBaseMapper.selectById(courseId); //判断course_base里面的课程信息存不存在
        if (courseBase == null) {
            XueChengPlusException.cast("课程不存在");
        }

        // 验证课程基础信息
        CourseBase courseBaseInfo = validateCourseBase(courseId, companyId);

        // 验证课程营销信息
        CourseMarket courseMarket = validateCourseMarket(courseId);

        // 验证课程计划信息
        List<TeachplanDTO> teachPlanTree = validateTeachPlanTree(courseId);

        // 验证课程教师信息
        List<CourseTeacher> courseTeachers = validateCourseTeachers(courseId);

//        课程审核状态
//        [{"code":"202001","desc":"审核未通过"},
//        {"code":"202002","desc":"未提交"},
//        {"code":"202003","desc":"已提交"},
//        {"code":"202004","desc":"审核通过"}]
        // 创建预发布记录并设置相关信息
        CoursePublishPre coursePublishPre = createCoursePublishPre(courseBaseInfo, courseMarket, courseTeachers, teachPlanTree);
        int insert = coursePublishPreMapper.insert(coursePublishPre);
        if (insert <= 0) {
            XueChengPlusException.cast("插入预发布表失败");
        }
        courseBase.setAuditStatus("202003"); //提交审核
        courseBase.setStatus("203001"); //未发布
        int courseBaseUpdate = courseBaseMapper.updateById(courseBase);
        if (courseBaseUpdate <= 0) {
            XueChengPlusException.cast("插入课程内容表失败");
        }
    }

    private boolean isCourseUnderReview(Long courseId) {
        return coursePublishPreMapper.selectById(courseId) != null;
    }

    private CourseBase validateCourseBase(Long courseId, Long companyId) {
        CourseBaseInfoDTO courseBaseInfo = courseBaseInfoService.getCourseBaseInfo(courseId);
        if (courseBaseInfo == null) {
            XueChengPlusException.cast("提交的课程内容不存在");
        }
        if (!companyId.equals(courseBaseInfo.getCompanyId())) {
            XueChengPlusException.cast("不能提交审核其他机构的课程");
        }
        if(StringUtils.isEmpty(courseBaseInfo.getPic())) {
            XueChengPlusException.cast("提交失败请上传图片");
        }
        return courseBaseInfo;
    }

    private CourseMarket validateCourseMarket(Long courseId) {
        CourseMarket courseMarket = courseMarketMapper.selectById(courseId);
        if (courseMarket == null) {
            XueChengPlusException.cast("课程营销不存在");
        }
        return courseMarket;
    }

    private List<CourseTeacher> validateCourseTeachers(Long courseId) {
        List<CourseTeacher> courseTeachers = courseTeacherService.selectCourseTeacherInfo(courseId);
        if (courseTeachers == null || courseTeachers.isEmpty()) {
            XueChengPlusException.cast("课程师资为空不能审核");
        }
        return courseTeachers;
    }

    private List<TeachplanDTO> validateTeachPlanTree(Long courseId) {
        List<TeachplanDTO> teachPlanTree = teacherService.findTeachPlanTree(courseId);
        if (teachPlanTree == null || teachPlanTree.isEmpty()) {
            XueChengPlusException.cast("课程计划为空不能审核");
        }
        return teachPlanTree;
    }

    private CoursePublishPre createCoursePublishPre(CourseBase courseBase, CourseMarket courseMarket,
                                                    List<CourseTeacher> courseTeachers, List<TeachplanDTO> teachPlanTree) {
        CoursePublishPre coursePublishPre = new CoursePublishPre();
        BeanUtils.copyProperties(courseBase, coursePublishPre);

        coursePublishPre.setStatus("202003");
        coursePublishPre.setTeachplan(JSON.toJSONString(teachPlanTree));
        coursePublishPre.setMarket(JSON.toJSONString(courseMarket));
        coursePublishPre.setTeachers(JSON.toJSONString(courseTeachers));
        coursePublishPre.setCreateDate(LocalDateTime.now());

        return coursePublishPre;
    }
    /**
     * 课程发布
     * @param companyId
     * @param courseId
     */
    @Transactional
    @Override
    public void publish(Long companyId, Long courseId) {
        //更新课程基本表的发布状态
        CourseBase courseBase = courseBaseMapper.selectById(courseId); //获取到course_base的信息
        CoursePublishPre coursePublishPre = coursePublishPreMapper.selectById(courseId); //获取到预发布的信息
        if (coursePublishPre == null) { //如果预发布表对应的课程不存在就让他提交审核再发布,或者有可能还在审核中
            XueChengPlusException.cast("请提交审核后才能发布...");
        }
        String auditStatus = coursePublishPre.getStatus(); //拿到预发布表状态
        if ("202001".equals(auditStatus)) { //如果是202001(未审核通过)
            courseBase.setAuditStatus("202001");//审核没有通过
            courseBaseMapper.updateById(courseBase);//修改course_base为审核不通过
            int i = coursePublishPreMapper.deleteById(courseId); //删除预发布表,因为审核未通过就不用同步到发布表了
            if (i <= 0) {
                XueChengPlusException.cast("删除预发布课程失败");
            }
//            XueChengPlusException.cast("课程未通过审核请修改后提交审核...");
        }
        if (!"202004".equals(auditStatus)) { //如果不是202004就表示课程审核中了
            XueChengPlusException.cast("课程还在审核中...");
        }

        //如果是202004审核完成就保存课程发布信息到发布表
        saveCoursePublish(courseId,coursePublishPre);
        courseBase.setAuditStatus("202004"); //审核通过
        courseBase.setStatus("203002");//已发布
        courseBaseMapper.updateById(courseBase);

        //把发布成功的信息加到消息表后面分布式任务调度要用
        saveCoursePublishMessage(courseId);

        //删除预发布表对应的课程
        int i = coursePublishPreMapper.deleteById(courseId);
        if (i < 0) {
            XueChengPlusException.cast("删除预发布对应课程失败");
        }

    }

    private void saveCoursePublish(Long courseId,CoursePublishPre coursePublishPre) {
        CoursePublish coursePublish = new CoursePublish();
        BeanUtils.copyProperties(coursePublishPre,coursePublish);
        coursePublish.setStatus("203002"); //已发布
        //查询这个courseId存在发布表不,不存在就插入,存在就修改,因为有可能我重新修改课程发布审核通过后,发布表里面的内容也要跟着修改
        CoursePublish coursePublishInfo = coursePublishMapper.selectById(courseId);
        if (coursePublishInfo == null) {
            int insert = coursePublishMapper.insert(coursePublish);
            if (insert <= 0) {
                XueChengPlusException.cast("插入发布表失败");
            }
        }
        else {
            int updateByCoursePublish = coursePublishMapper.updateById(coursePublish);
            if (updateByCoursePublish <= 0) {
                XueChengPlusException.cast("修改本课程发布表失败");
            }
        }
    }

    /**
     * 查看mq消息表里面是不是有对应的数据,有就不让他再次发布防止数据不一致
     * @param courseId
     */
    private void CoursePublishMessage(Long courseId) {
        LambdaQueryWrapper<MqMessage> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(MqMessage::getBusinessKey1,courseId);
        MqMessage mqMessage1 = mqMessageMapper.selectOne(queryWrapper); //这里是判断消息表里面有没有同步到redis等等的课程,因为你还没同步不可能让你再次发布,这会导致数据不一致
        if (mqMessage1!=null) {
            XueChengPlusException.cast("课程正在同步到页面请等待...");
        }
    }

    /**
     * 保存消息表
     * @param courseId
     */
    private void saveCoursePublishMessage(Long courseId) {
        CoursePublishMessage(courseId);
        MqMessage mqMessage = mqMessageService.addMessage("course_publish", String.valueOf(courseId), null, null);
        if(mqMessage == null){
            XueChengPlusException.cast("添加消息记录失败");
        }
    }
    /**
     * 课程下架
     * @param companyId
     * @param courseId
     */
    @Transactional
    @Override
    public void courseOffLine(Long companyId, Long courseId) {
        CourseBase courseBase = courseBaseMapper.selectById(courseId); //查询课程信息存不存在
        if (courseBase == null) {
            XueChengPlusException.cast("课程不存在无法下架");
        }
        courseBase.setStatus("203003"); //更新内容为下架状态
        CoursePublish coursePublish = coursePublishMapper.selectById(courseId);
        if (coursePublish == null) {
            XueChengPlusException.cast("课程没有提交审核,无法下架");
        }
        coursePublish.setStatus("203003"); //更新发布表未下架状态
        CoursePublishMessage(courseId);
        int i = courseBaseMapper.updateById(courseBase);
        if (i <= 0) {
            XueChengPlusException.cast("下架操作失败请联系后台");
        }
        coursePublishMapper.updateById(coursePublish);
    }
}