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.util.RedisUtil;
import com.subsidy.vo.administer.UserRoleVO;
import com.subsidy.vo.course.QueryCoursesVO;
import com.subsidy.vo.member.*;
import com.subsidy.vo.paper.QueryPapersVO;
import com.subsidy.vo.vod.StudyHistoryVO;
import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
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 VodDictMapper vodDictMapper;

    @Autowired
    private FileDictMapper fileDictMapper;

    @Autowired
    private ExerciseDoneResultMapper exerciseDoneResultMapper;

    @Autowired
    private ClassMemberMappingMapper classMemberMappingMapper;

    @Autowired
    private PaperDictMapper paperDictMapper;

    @Autowired
    private ClassDictMapper classDictMapper;

    @Autowired
    private CompanyDictMapper companyDictMapper;

    @Autowired
    private MemberDepartmentMappingMapper memberDepartmentMappingMapper;

    @Autowired
    private ClassHourDictMapper classHourDictMapper;

    @Autowired
    private OprMemDictMapper oprMemDictMapper;

    @Autowired
    private RedisUtil redisUtil;

    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())) {
            OprMemDictDO oprMemDictDO = new OprMemDictDO();
            oprMemDictDO.setUserId(memberDO.getId());
            oprMemDictDO.setOprType("登录");
            oprMemDictDO.setResult(0);
            oprMemDictMapper.insert(oprMemDictDO);
            throw new HttpException(10013);
        }

        //是否登陆过   1：是 0：否
        if (0 == memberDO.getFirstLogin()) {
            memberDO.setFirstLogin(1);
            this.baseMapper.updateById(memberDO);
        }
        BeanUtils.copyProperties(memberDO, userRoleVO);

        String code = redisUtil.get("subsidySmsCode_"+verifyCodeDTO.getTelephone()).toString();

        //SmsVerifyCodeDO smsCodeDO = smsVerifyCodeMapper.selectOne(new QueryWrapper<SmsVerifyCodeDO>()
        //        .lambda()
        //        .eq(SmsVerifyCodeDO::getTelephone, verifyCodeDTO.getTelephone())
        //        .eq(SmsVerifyCodeDO::getVerifyCode, verifyCodeDTO.getVerifyCode())
        //        .gt(SmsVerifyCodeDO::getCreateDate, LocalDateTime.now().minusMinutes(30L)));
        if (code == null || !verifyCodeDTO.getVerifyCode().equals(code) ) {
            OprMemDictDO oprMemDictDO = new OprMemDictDO();
            oprMemDictDO.setUserId(memberDO.getId());
            oprMemDictDO.setOprType("登录");
            oprMemDictDO.setResult(0);
            oprMemDictMapper.insert(oprMemDictDO);
            throw new HttpException(70010);
        }
        OprMemDictDO oprMemDictDO = new OprMemDictDO();
        oprMemDictDO.setUserId(memberDO.getId());
        oprMemDictDO.setOprType("登录");
        oprMemDictDO.setResult(1);
        oprMemDictMapper.insert(oprMemDictDO);

        //将学员信息写到redis
        redisUtil.set("subsidyMember_"+memberDO.getCompanyId()+":"+memberDO.getAccountName(),memberDO);
        return userRoleVO;
    }

    public MemberDO passwordLogin(PasswordLoginDTO passwordLoginDTO) {
        //UserRoleVO userRoleVO = this.baseMapper.passwordLogin(passwordLoginDTO);
        /**
         * 先从redis里查
         */
        MemberDO memberDO = (MemberDO) redisUtil.get("subsidyMember_"+passwordLoginDTO.getCompanyId()+":"+passwordLoginDTO.getAccountName());
        if (null==memberDO){
            /**
             * redis里没有，从数据库里查
             */
            memberDO = this.baseMapper.selectOne(new QueryWrapper<MemberDO>()
            .lambda()
            .eq(MemberDO::getCompanyId,passwordLoginDTO.getCompanyId())
            .eq(MemberDO::getAccountName,passwordLoginDTO.getAccountName()));
        }
        if (memberDO == null) {
            throw new HttpException(10017);
        }
        if (!memberDO.getPassword().equals(passwordLoginDTO.getPassword())) {
            OprMemDictDO oprMemDictDO = new OprMemDictDO();
            oprMemDictDO.setUserId(memberDO.getId());
            oprMemDictDO.setOprType("登录");
            oprMemDictDO.setResult(0);
            oprMemDictMapper.insert(oprMemDictDO);
            throw new HttpException(10016);
        }

        if (0 == memberDO.getFirstLogin()) {
            OprMemDictDO oprMemDictDO = new OprMemDictDO();
            oprMemDictDO.setUserId(memberDO.getId());
            oprMemDictDO.setOprType("登录");
            oprMemDictDO.setResult(0);
            oprMemDictMapper.insert(oprMemDictDO);
            throw new HttpException(10015);
        }

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

        OprMemDictDO oprMemDictDO = new OprMemDictDO();
        oprMemDictDO.setUserId(memberDO.getId());
        oprMemDictDO.setOprType("登录");
        oprMemDictDO.setResult(1);
        oprMemDictMapper.insert(oprMemDictDO);
        return memberDO;
    }

    public String updatePassword(MemberDO memberDO) {
        this.baseMapper.updateById(memberDO);
        MemberDO memberDO1 = this.baseMapper.selectById(memberDO.getId());
        redisUtil.set("subsidyMember_"+memberDO1.getCompanyId()+":"+memberDO.getAccountName(),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 List<QueryPapersVO> getCourseTest(ContentMemberDTO contentMemberDTO) {

        //查看该班级下的测试卷子(有效卷子)
        ClassDictDO classDictDO = classDictMapper.selectById(contentMemberDTO.getClassId());
        List<QueryPapersVO> queryPapersVOS = paperDictMapper.queryPapers(contentMemberDTO.getCourseId(), null, 1);
        for (QueryPapersVO queryPapersVO : queryPapersVOS) {
            //多少人已完成
            Integer cnt = paperDictMapper.completeCount(queryPapersVO.getId());
            queryPapersVO.setCompleteCnt(cnt);
            //自己成绩
            List<ExerciseDoneResultDO> exerciseDoneResultDOS = exerciseDoneResultMapper.selectList(new QueryWrapper<ExerciseDoneResultDO>()
                    .lambda()
                    .eq(ExerciseDoneResultDO::getMemberId, contentMemberDTO.getMemberId())
                    .eq(ExerciseDoneResultDO::getPaperId, queryPapersVO.getId())
                    .orderByDesc(ExerciseDoneResultDO::getScore));

            if (exerciseDoneResultDOS.size() > 0) {
                queryPapersVO.setRightCounts(exerciseDoneResultDOS.get(0).getRightCounts());
                queryPapersVO.setTotalCount(exerciseDoneResultDOS.get(0).getTotalCounts());
                queryPapersVO.setResult(exerciseDoneResultDOS.get(0).getResult());
            } else {
                queryPapersVO.setResult("待完成");
            }

            //截止时间
            queryPapersVO.setEndDate(classDictDO.getEndDate());
        }
        return queryPapersVOS;
    }

    public List<ExerciseDoneResultDO> getPaperDoneDetail(ExerciseDoneResultDO exerciseDoneResultDO) {
        return exerciseDoneResultMapper.selectList(new QueryWrapper<ExerciseDoneResultDO>()
                .lambda()
                .eq(ExerciseDoneResultDO::getMemberId, exerciseDoneResultDO.getMemberId())
                .eq(ExerciseDoneResultDO::getPaperId, exerciseDoneResultDO.getPaperId()));
    }

    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;
    }

    public ExerciseDoneResultDO getDoneResult(ExerciseDoneResultDO exerciseDoneResultDO) {
        return exerciseDoneResultMapper.selectById(exerciseDoneResultDO.getId());
    }

    public String checkTimes(ExerciseDoneResultDO exerciseDoneResultDO) {


        ClassHourDictDO classHourDictDO = classHourDictMapper.getClassHourDictInfo(exerciseDoneResultDO.getClassId());

        if (null != classHourDictDO) {
            Integer status = classHourDictDO.getRepeatStatus();
            if (1 == status) {
                int cnt = classHourDictDO.getRepeatTime();

                //查看这个人这个卷子做了几次
                Integer count = exerciseDoneResultMapper.selectCount(new QueryWrapper<ExerciseDoneResultDO>()
                        .lambda()
                        .eq(ExerciseDoneResultDO::getMemberId, exerciseDoneResultDO.getMemberId())
                        .eq(ExerciseDoneResultDO::getPaperId, exerciseDoneResultDO.getPaperId()));

                if (cnt <= count) {
                    throw new HttpException(60001);
                }
            }
        }
        return ConstantUtils.CHECK_STATUS;
    }

    public void importRedis() {
        List<MemberDO> memberDOS = this.baseMapper.selectList(null);
        for (MemberDO memberDO : memberDOS) {
            redisUtil.set("subsidyMember_"+memberDO.getCompanyId()+":"+memberDO.getAccountName(),memberDO);
        }
    }

}