MemberServiceImpl.java

package com.subsidy.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.subsidy.common.exception.HttpException;
import com.subsidy.dto.administer.VerifyCodeDTO;
import com.subsidy.dto.member.AddMemberDTO;
import com.subsidy.dto.member.ContentMemberDTO;
import com.subsidy.dto.member.GetAllDTO;
import com.subsidy.dto.member.StudyHistoryDTO;
import com.subsidy.mapper.*;
import com.subsidy.model.*;
import com.subsidy.service.MemberService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.subsidy.util.ConstantUtils;
import com.subsidy.util.MathUtil;
import com.subsidy.vo.administer.UserRoleVO;
import com.subsidy.vo.member.*;
import com.subsidy.vo.vod.StudyHistoryVO;
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.lang.reflect.Member;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

/**
 * <p>
 * 学生表 服务实现类
 * </p>
 *
 * @author DengMin
 * @since 2021-10-11
 */
@Service
public class MemberServiceImpl extends ServiceImpl<MemberMapper, MemberDO> implements MemberService {

    @Autowired
    private SmsVerifyCodeMapper smsVerifyCodeMapper;

    @Autowired
    private CourseContentMapper courseContentMapper;

    @Autowired
    private VodPlayHistoryMapper vodPlayHistoryMapper;

    @Autowired
    private CourseDictMapper courseDictMapper;

    @Autowired
    private VodDictMapper vodDictMapper;

    @Autowired
    private FileDictMapper fileDictMapper;

    @Autowired
    private ExerciseDoneResultMapper exerciseDoneResultMapper;

    @Autowired
    private ExerciseDictMapper exerciseDictMapper;

    @Autowired
    private DepartmentDictMapper departmentDictMapper;

    @Autowired
    private ClassMemberMappingMapper classMemberMappingMapper;

    @Autowired
    private ClassDictMapper classDictMapper;

    @Autowired
    private CompanyDictMapper companyDictMapper;

    @Autowired
    private MemberDepartmentMappingMapper memberDepartmentMappingMapper;

    public IPage<GetAllVO> getAll(GetAllDTO getAllDTO) {
        Page pager = new Page(getAllDTO.getPageNum(), getAllDTO.getPageSize());
        IPage iPage = this.baseMapper.getMembers(pager, getAllDTO.getDepartmentId(), getAllDTO.getUserName(), getAllDTO.getStatus());

        List<GetAllVO> getAllVOS = iPage.getRecords();
        for (GetAllVO getAllVO : getAllVOS) {
            List<DepartmentDictDO> departmentDictDOS = this.baseMapper.getDepartments(getAllVO.getId());
            getAllVO.setDepartmentDictDOS(departmentDictDOS);
        }
        return iPage;
    }

    public String deleteMember(MemberDO memberDO) {
        this.baseMapper.deleteById(memberDO.getId());
        return ConstantUtils.DELETE_SUCCESS;
    }

    public String addMember(AddMemberDTO addMemberDTO) {

        Integer count = this.baseMapper.selectCount(new QueryWrapper<MemberDO>()
                .lambda()
                .eq(MemberDO::getTelephone, addMemberDTO.getTelephone()));

        if (count > 0) {
            throw new HttpException(20002);
        }

        Integer count1 = this.baseMapper.selectCount(new QueryWrapper<MemberDO>()
                .lambda()
                .eq(MemberDO::getAccountName, addMemberDTO.getAccountName())
                .eq(MemberDO::getDepartmentId, addMemberDTO.getDepartmentId()));

        if (count1 > 0) {
            throw new HttpException(20002);
        }

        MemberDO memberDO = new MemberDO();
        BeanUtils.copyProperties(addMemberDTO, memberDO);
        memberDO.setPassword("123456");
        memberDO.setStatus("启用");
        this.baseMapper.insert(memberDO);

        //部门
        List<Long> longs = addMemberDTO.getDepartmentIds();
        for (Long lg : longs) {
            MemberDepartmentMappingDO memberDepartmentMappingDO = new MemberDepartmentMappingDO();
            memberDepartmentMappingDO.setMemberId(memberDO.getId());
            memberDepartmentMappingDO.setDepartmentId(lg);
            memberDepartmentMappingMapper.insert(memberDepartmentMappingDO);
        }

        return ConstantUtils.ADD_SUCCESS;
    }

    public String updateMember(AddMemberDTO addMemberDTO) {

        if (null!= addMemberDTO.getDepartmentIds()){
            Integer count = this.baseMapper.selectCount(new QueryWrapper<MemberDO>()
                    .lambda()
                    .eq(MemberDO::getTelephone, addMemberDTO.getTelephone())
                    .eq(MemberDO::getDepartmentId, addMemberDTO.getDepartmentId())
                    .ne(MemberDO::getId, addMemberDTO.getId()));

            if (count > 0) {
                throw new HttpException(20002);
            }
            Integer count1 = this.baseMapper.selectCount(new QueryWrapper<MemberDO>()
                    .lambda()
                    .eq(MemberDO::getAccountName, addMemberDTO.getAccountName())
                    .eq(MemberDO::getDepartmentId, addMemberDTO.getDepartmentId())
                    .ne(MemberDO::getId, addMemberDTO.getId()));

            if (count1 > 0) {
                throw new HttpException(20002);
            }
        }

        MemberDO memberDO = new MemberDO();
        BeanUtils.copyProperties(addMemberDTO, memberDO);
        this.baseMapper.updateById(memberDO);

        if (null != addMemberDTO.getDepartmentIds()){
            memberDepartmentMappingMapper.delete(new QueryWrapper<MemberDepartmentMappingDO>()
                    .lambda()
                    .eq(MemberDepartmentMappingDO::getMemberId, addMemberDTO.getId()));

            //部门
            List<Long> longs = addMemberDTO.getDepartmentIds();
            for (Long lg : longs) {
                MemberDepartmentMappingDO memberDepartmentMappingDO = new MemberDepartmentMappingDO();
                memberDepartmentMappingDO.setMemberId(memberDO.getId());
                memberDepartmentMappingDO.setDepartmentId(lg);
                memberDepartmentMappingMapper.insert(memberDepartmentMappingDO);
            }
        }

        return ConstantUtils.SET_SUCCESS;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public UserRoleVO login(VerifyCodeDTO verifyCodeDTO) {
        UserRoleVO userRoleVO = new UserRoleVO();
        MemberDO userRoleDO = this.baseMapper.selectOne(new QueryWrapper<MemberDO>()
                .lambda()
                .eq(MemberDO::getTelephone, verifyCodeDTO.getTelephone()));
        if (userRoleDO == null) {
            throw new HttpException(10010);
        }

        if ("冻结".equals(userRoleDO.getStatus())){
            throw new HttpException(10013);
        }

        BeanUtils.copyProperties(userRoleDO, userRoleVO);

        SmsVerifyCodeDO smsCodeDO = smsVerifyCodeMapper.selectOne(new QueryWrapper<SmsVerifyCodeDO>()
                .lambda()
                .eq(SmsVerifyCodeDO::getTelephone, verifyCodeDTO.getTelephone())
                .eq(SmsVerifyCodeDO::getVerifyCode, verifyCodeDTO.getVerifyCode()));
        if (smsCodeDO == null) {
            throw new HttpException(70010);
        }
        return userRoleVO;
    }

    public UserRoleVO passwordLogin(MemberDO memberDO) {
        UserRoleVO userRoleVO = new UserRoleVO();
        MemberDO memberDO1 = this.baseMapper.selectOne(new QueryWrapper<MemberDO>()
                .lambda()
                .eq(MemberDO::getPassword, memberDO.getPassword())
                .eq(MemberDO::getAccountName, memberDO.getAccountName()));
        if (memberDO1 == null) {
            throw new HttpException(10004);
        }

        if ("冻结".equals(memberDO1.getStatus())){
            throw new HttpException(10014);
        }

        BeanUtils.copyProperties(memberDO1, userRoleVO);
        return userRoleVO;
    }

    public String updatePassword(MemberDO memberDO) {
        this.baseMapper.updateById(memberDO);
        return ConstantUtils.SET_SUCCESS;
    }

    public MemberStudyPageVO studyPage(MemberDO memberDO) {

        MemberStudyPageVO memberStudyPageVO = new MemberStudyPageVO();

        List<StudyPageVO> studyPageVOS = this.baseMapper.studyPage(memberDO);

        for (StudyPageVO studyPageVO : studyPageVOS) {

            //查看课程下有几节课
            List<VodDictDO> vodDictDOS = courseContentMapper.getCourseVods(studyPageVO.getId());
            studyPageVO.setTotalVods(vodDictDOS.size());

            int i = 0;

            //该成员完成了几个视频
            for (VodDictDO vodDictDO : vodDictDOS) {
                List<VodPlayHistoryDO> vodPlayHistoryDOS = vodPlayHistoryMapper.selectList(new QueryWrapper<VodPlayHistoryDO>()
                        .lambda()
                        .eq(VodPlayHistoryDO::getMemberId, memberDO.getId())
                        .eq(VodPlayHistoryDO::getVodId, vodDictDO.getId())
                        .orderByDesc(VodPlayHistoryDO::getPlayRecord));

                if (vodPlayHistoryDOS.size() > 0) {
                    if (vodPlayHistoryDOS.get(0).getPlayRecord() > vodDictDO.getVodLength() * 0.8) {
                        i++;
                    }
                }
            }
            studyPageVO.setDoneVods(i);

            //该班级课程下有多少人
            List<ClassMemberMappingDO> classMemberMappingDOS = classMemberMappingMapper.selectList(new QueryWrapper<ClassMemberMappingDO>()
                    .lambda()
                    .eq(ClassMemberMappingDO::getClassId, studyPageVO.getClassId()));
            studyPageVO.setTotalMember(classMemberMappingDOS.size());

            //多少人完成
            int completedCnt = 0;
            for (ClassMemberMappingDO cmmd : classMemberMappingDOS) {

                Boolean flag = true;

                for (VodDictDO vodDictDO : vodDictDOS) {
                    List<VodPlayHistoryDO> vodPlayHistoryDOS = vodPlayHistoryMapper.selectList(new QueryWrapper<VodPlayHistoryDO>()
                            .lambda()
                            .eq(VodPlayHistoryDO::getVodId, vodDictDO.getId())
                            .eq(VodPlayHistoryDO::getMemberId, cmmd.getMemberId())
                            .orderByDesc(VodPlayHistoryDO::getPlayRecord));
                    if (vodPlayHistoryDOS.size() > 0) {
                        if (vodPlayHistoryDOS.get(0).getPlayRecord() < vodDictDO.getVodLength()) {
                            flag = false;
                            //break;
                        }
                    } else {
                        flag = false;
                    }
                }
                if (flag) {
                    completedCnt++;
                }
            }
            studyPageVO.setDoneMember(completedCnt);
        }

        memberStudyPageVO.setStudyPageVOS(studyPageVOS);

        List<DepartmentDictDO> departmentDictDOS = this.baseMapper.getDepartments(memberDO.getId());

        if (departmentDictDOS.size() > 0) {
            CompanyDictDO companyDictDO = companyDictMapper.selectById(departmentDictDOS.get(0).getId());
            if (null != companyDictDO) {
                BeanUtils.copyProperties(companyDictDO, memberStudyPageVO);
            }
        }
        return memberStudyPageVO;
    }

    public ContentVodNewVO contentVod(ContentMemberDTO contentVodDTO) {

        ContentVodNewVO contentVodNewVO = new ContentVodNewVO();

        List<ContentVodVO> contentVodVOS = new ArrayList<>();
        List<CourseContentDO> courseContentDOS = courseContentMapper.selectList(new QueryWrapper<CourseContentDO>()
                .lambda()
                .eq(CourseContentDO::getCourseId, contentVodDTO.getCourseId())
                .orderByAsc(CourseContentDO::getOrderNo));

        for (CourseContentDO courseContentDO : courseContentDOS) {
            ContentVodVO contentVodVO = new ContentVodVO();
            contentVodVO.setContent(courseContentDO.getContent());

            List<MemberVodVO> memberVodVOS = new ArrayList<>();

            //目录下的视频
            List<VodDictDO> vodDictDOS = vodDictMapper.selectList(new QueryWrapper<VodDictDO>()
                    .lambda()
                    .eq(VodDictDO::getContentId, courseContentDO.getId()));
            for (VodDictDO vodDictDO : vodDictDOS) {
                MemberVodVO memberVodVO = new MemberVodVO();
                List<VodPlayHistoryDO> vodPlayHistoryDOS = vodPlayHistoryMapper.selectList(new QueryWrapper<VodPlayHistoryDO>()
                        .lambda()
                        .eq(VodPlayHistoryDO::getMemberId, contentVodDTO.getMemberId())
                        .eq(VodPlayHistoryDO::getVodId, vodDictDO.getId())
                        .orderByDesc(VodPlayHistoryDO::getPlayRecord));

                memberVodVO.setStatus(false);
                if (vodPlayHistoryDOS.size() > 0) {
                    memberVodVO.setPercent(MathUtil.intDivCeil(100 * vodPlayHistoryDOS.get(0).getPlayRecord(), vodDictDO.getVodLength()));
                    if (memberVodVO.getPercent() >= 80) {
                        memberVodVO.setStatus(true);
                    }
                } else {
                    memberVodVO.setPercent(0);
                }
                List<VodPlayHistoryDO> vodPlayHistoryDOS1 = vodPlayHistoryMapper.selectList(new QueryWrapper<VodPlayHistoryDO>()
                        .lambda()
                        .eq(VodPlayHistoryDO::getMemberId, contentVodDTO.getMemberId())
                        .eq(VodPlayHistoryDO::getVodId, vodDictDO.getId())
                        .orderByDesc(VodPlayHistoryDO::getCreateDate));
                if (vodPlayHistoryDOS1.size() > 0) {
                    memberVodVO.setPlayRecord(vodPlayHistoryDOS1.get(0).getPlayRecord());
                }
                memberVodVO.setId(vodDictDO.getId());
                memberVodVO.setVodUrl(vodDictDO.getVodUrl());
                memberVodVO.setTeacherName(vodDictDO.getTeacherName());
                memberVodVO.setVodLength(vodDictDO.getVodLength());
                memberVodVO.setVodName(vodDictDO.getVodName());
                memberVodVOS.add(memberVodVO);
            }
            contentVodVO.setMemberVodVOS(memberVodVOS);
            contentVodVOS.add(contentVodVO);
        }

        contentVodNewVO.setContentVodVOS(contentVodVOS);

        List<VodPlayHistoryDO> vodPlayHistoryDOS = vodPlayHistoryMapper.selectList(new QueryWrapper<VodPlayHistoryDO>()
        .lambda()
        .eq(VodPlayHistoryDO::getClassId,contentVodDTO.getClassId())
        .eq(VodPlayHistoryDO::getMemberId,contentVodDTO.getMemberId())
        .orderByDesc(VodPlayHistoryDO::getCreateDate));
        if (vodPlayHistoryDOS.size()>0){
            VodPlayHistoryDO vodPlayHistoryDO = vodPlayHistoryDOS.get(0);
            VodDictDO vodDictDO = vodDictMapper.selectById(vodPlayHistoryDO.getVodId());
            if (null!=vodDictDO){
                BeanUtils.copyProperties(vodDictDO,contentVodNewVO);
                contentVodNewVO.setPlayRecord(vodPlayHistoryDO.getPlayRecord());
            }
        }
        return contentVodNewVO;
    }

    public List<ContentFilesVO> contentFiles(ContentMemberDTO contentMemberDTO) {

        List<ContentFilesVO> contentFilesVOS = new ArrayList<>();

        List<CourseContentDO> courseContentDOS = courseContentMapper.selectList(new QueryWrapper<CourseContentDO>()
                .lambda()
                .eq(CourseContentDO::getCourseId, contentMemberDTO.getCourseId())
                .orderByAsc(CourseContentDO::getOrderNo));

        for (CourseContentDO courseContentDO : courseContentDOS) {

            ContentFilesVO contentFilesVO = new ContentFilesVO();
            contentFilesVO.setContent(courseContentDO.getContent());

            List<FileDictDO> fileDictDOS = fileDictMapper.selectList(new QueryWrapper<FileDictDO>()
                    .lambda()
                    .eq(FileDictDO::getContentId, courseContentDO.getId()));
            contentFilesVO.setFileDictDOS(fileDictDOS);

            contentFilesVOS.add(contentFilesVO);
        }

        return contentFilesVOS;
    }

    public IPage studyHistory(StudyHistoryDTO studyHistoryDTO) {
        Page pager = new Page(studyHistoryDTO.getPageNum(), studyHistoryDTO.getPageSize());

        IPage iPage = vodPlayHistoryMapper.studyHistory(pager, studyHistoryDTO.getMemberId());

        List<StudyHistoryVO> studyHistoryVOS = iPage.getRecords();

        for (StudyHistoryVO studyHistoryVO : studyHistoryVOS) {
            if (studyHistoryVO.getPercent() >= 80) {
                studyHistoryVO.setStatus(true);
            } else {
                studyHistoryVO.setStatus(false);
            }
        }
        iPage.setRecords(studyHistoryVOS);

        return iPage;
    }

    public GetCourseTestVO getCourseTest(ContentMemberDTO contentMemberDTO) {

        GetCourseTestVO getCourseTestVO = new GetCourseTestVO();

        ClassDictDO classDictDO = classDictMapper.selectById(contentMemberDTO.getClassId());

        CourseDictDO courseDictDO = courseDictMapper.selectById(classDictDO.getCourseId());
        getCourseTestVO.setCourseId(courseDictDO.getId());
        getCourseTestVO.setCourseName(courseDictDO.getCourseName());
        getCourseTestVO.setDeadline(classDictDO.getEndDate());

        ExerciseDoneResultDO exerciseDoneResultDO = exerciseDoneResultMapper.selectOne(new QueryWrapper<ExerciseDoneResultDO>()
                .lambda()
                .eq(ExerciseDoneResultDO::getCourseId, courseDictDO.getId())
                .eq(ExerciseDoneResultDO::getMemberId, contentMemberDTO.getMemberId()));

        if (null != exerciseDoneResultDO) {
            getCourseTestVO.setRightCount(String.valueOf(exerciseDoneResultDO.getRightCounts()));
            getCourseTestVO.setTotalCount(String.valueOf(exerciseDoneResultDO.getTotalCounts()));

            //正确率
            Integer percent = MathUtil.intDivFloorPercent(exerciseDoneResultDO.getRightCounts(),exerciseDoneResultDO.getTotalCounts());
            if(percent>=60){
                getCourseTestVO.setResult("合格");
            }else {
                getCourseTestVO.setResult("不合格");
            }
            getCourseTestVO.setPercent(String.valueOf(percent));
        } else {
            getCourseTestVO.setRightCount("-");
            //该课程下有多少习题
            Integer count = exerciseDictMapper.selectCount(new QueryWrapper<ExerciseDictDO>()
                    .lambda()
                    .eq(ExerciseDictDO::getCourseId, courseDictDO.getId()));
            getCourseTestVO.setTotalCount(String.valueOf(count));
            getCourseTestVO.setPercent("-");
            getCourseTestVO.setResult("不合格");
        }
        return getCourseTestVO;
    }

    public GetStudyInfoVO getStudyInfo(MemberDO memberDO) {

        GetStudyInfoVO getStudyInfoVO = new GetStudyInfoVO();

        MemberDO memberDO1 = this.baseMapper.selectById(memberDO.getId());

        //第几天
        long diff = Duration.between(LocalDateTime.now(), memberDO1.getCreateDate()).toDays();
        getStudyInfoVO.setDiff(diff);

        //已学课程
        List<ClassMemberMappingDO> classMemberMappingDOS = classMemberMappingMapper.selectList(new QueryWrapper<ClassMemberMappingDO>()
                .lambda()
                .eq(ClassMemberMappingDO::getMemberId, memberDO.getId()));
        /**
         * 遍历课程，里面的视频都看过80% 则表示已学完
         */
        int i = 0; //已学课程
        for (ClassMemberMappingDO classMemberMappingDO : classMemberMappingDOS) {
            List<VodDictDO> vodDictDOS = classDictMapper.getClassVods(classMemberMappingDO.getClassId());
            for (VodDictDO vodDictDO : vodDictDOS) {
                List<VodPlayHistoryDO> vodPlayHistoryDOS = vodPlayHistoryMapper.selectList(new QueryWrapper<VodPlayHistoryDO>()
                        .lambda()
                        .eq(VodPlayHistoryDO::getMemberId, memberDO.getId())
                        .eq(VodPlayHistoryDO::getVodId, vodDictDO.getId())
                        .orderByDesc(VodPlayHistoryDO::getPlayRecord));
                if (vodPlayHistoryDOS.size() > 0) {
                    if (vodPlayHistoryDOS.get(0).getPlayRecord() < vodDictDO.getVodLength() * 0.8) {
                        break;
                    }
                }
            }
            i++;
        }
        getStudyInfoVO.setStudyCourse(i);

        //累计学习时长
        int studyLength = 0;
        List<VodPlayHistoryDO> vodPlayHistoryDOS = vodPlayHistoryMapper.selectList(new QueryWrapper<VodPlayHistoryDO>()
                .lambda()
                .eq(VodPlayHistoryDO::getMemberId, memberDO.getId()));

        for (VodPlayHistoryDO vodPlayHistoryDO : vodPlayHistoryDOS) {
            studyLength += vodPlayHistoryDO.getPlayLength();
        }
        getStudyInfoVO.setStudyLength(studyLength);

        return getStudyInfoVO;
    }

}