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.*;
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());

        classMemberMappingMapper.delete(new QueryWrapper<ClassMemberMappingDO>()
                .lambda()
                .eq(ClassMemberMappingDO::getMemberId, memberDO.getId()));

        memberDepartmentMappingMapper.delete(new QueryWrapper<MemberDepartmentMappingDO>()
                .lambda()
                .eq(MemberDepartmentMappingDO::getMemberId, 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);
        }

        //部门
        List<Long> longs = addMemberDTO.getDepartmentIds();

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

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


        MemberDO memberDO = new MemberDO();
        BeanUtils.copyProperties(addMemberDTO, memberDO);
        memberDO.setPassword("123456");
        memberDO.setStatus("启用");
        memberDO.setFirstLogin(0);
        //公司赋值
        memberDO.setCompanyId(addMemberDTO.getCompanyId());
        this.baseMapper.insert(memberDO);


        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())
                    .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::getCompanyId,addMemberDTO.getCompanyId())
                    .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 memberDO = this.baseMapper.selectOne(new QueryWrapper<MemberDO>()
                .lambda()
                .eq(MemberDO::getTelephone, verifyCodeDTO.getTelephone()));
        if (memberDO == null) {
            throw new HttpException(10010);
        }

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

        //是否登陆过   1：是 0：否
        if (0 == memberDO.getFirstLogin()) {
            memberDO.setFirstLogin(1);
            this.baseMapper.updateById(memberDO);
        }
        BeanUtils.copyProperties(memberDO, 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(PasswordLoginDTO passwordLoginDTO) {
        UserRoleVO userRoleVO = this.baseMapper.passwordLogin(passwordLoginDTO);
        if (userRoleVO == null) {
            throw new HttpException(10004);
        }
        if ("冻结".equals(userRoleVO.getStatus())) {
            throw new HttpException(10014);
        }
        if (0 == userRoleVO.getFirstLogin()) {
            throw new HttpException(10015);
        }
        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) {
                    int length = MathUtil.intDivCeil(100 * vodPlayHistoryDOS.get(0).getPlayRecord(), vodDictDO.getVodLength());
                    if (length >= 100) {
                        memberVodVO.setPercent(100);
                    } else {
                        memberVodVO.setPercent(length);
                    }
                    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::getClassId, classDictDO.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(memberDO1.getCreateDate(), LocalDateTime.now()).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;
    }

}