api/src/main/java/com/xjrsoft/module/textbook/service/impl/TextbookStudentClaimServiceImpl.java

package com.xjrsoft.module.textbook.service.impl;

import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.xjrsoft.common.enums.ClaimTypeEnum;
import com.xjrsoft.common.exception.MyException;
import com.xjrsoft.common.page.ConventPage;
import com.xjrsoft.common.utils.VoToColumnUtil;
import com.xjrsoft.module.base.entity.BaseClass;
import com.xjrsoft.module.base.entity.BaseClassAdminCourse;
import com.xjrsoft.module.base.entity.BaseClassCourse;
import com.xjrsoft.module.base.entity.BaseSemester;
import com.xjrsoft.module.base.mapper.BaseClassAdminCourseMapper;
import com.xjrsoft.module.base.mapper.BaseClassCourseMapper;
import com.xjrsoft.module.base.service.IBaseClassService;
import com.xjrsoft.module.base.service.IBaseSemesterService;
import com.xjrsoft.module.student.entity.BaseStudent;
import com.xjrsoft.module.student.entity.BaseStudentSchoolRoll;
import com.xjrsoft.module.system.entity.DictionaryDetail;
import com.xjrsoft.module.teacher.entity.AttendanceRecord;
import com.xjrsoft.module.teacher.entity.XjrUser;
import com.xjrsoft.module.teacher.mapper.XjrUserMapper;
import com.xjrsoft.module.textbook.dto.*;
import com.xjrsoft.module.textbook.entity.*;
import com.xjrsoft.module.textbook.mapper.TextbookStudentClaimMapper;
import com.xjrsoft.module.textbook.mapper.WfTextbookClaimItemMapper;
import com.xjrsoft.module.textbook.service.ITextbookStudentClaimService;
import com.xjrsoft.module.textbook.vo.*;
import lombok.AllArgsConstructor;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @title: 学生教材认领记录
 * @Author szs
 * @Date: 2023-12-26
 * @Version 1.0
 */
@Service
@AllArgsConstructor
public class TextbookStudentClaimServiceImpl extends MPJBaseServiceImpl<TextbookStudentClaimMapper, TextbookStudentClaim> implements ITextbookStudentClaimService {

    private final XjrUserMapper xjrUserMapper;

    private final TextbookStudentClaimMapper textbookStudentClaimMapper;

    private final IBaseSemesterService baseSemesterService;

    private final IBaseClassService baseClassService;

    private final BaseClassAdminCourseMapper baseClassAdminCourseMapper;

    private final BaseClassCourseMapper baseClassCourseMapper;

    private final WfTextbookClaimItemMapper wfTextbookClaimItemMapper;

    @Override
    public HeadTeaLookClassBookVo headTeaLookClassBook(HeadTeaLookClassBookDto dto) {
        HeadTeaLookClassBookVo result = new HeadTeaLookClassBookVo();

        // 先去申领中找，如果申领中没有数据，那么就到班级课程中找
        MPJLambdaWrapper<WfTextbookClaimItem> wfTextbookClaimItemMPJLambdaWrapper = new MPJLambdaWrapper<>();
        wfTextbookClaimItemMPJLambdaWrapper
                .disableSubLogicDel()
                .selectAs(Textbook::getBookName, HeadTeaLookClassBookCategoryDetailVo::getBookName)
                .selectAs(Textbook::getPrice, HeadTeaLookClassBookCategoryDetailVo::getPrice)
                .selectAs(Textbook::getTextbookType, HeadTeaLookClassBookCategoryDetailVo::getTextbookType)
                .selectAs(WfTextbookClaimItem::getCreateDate, HeadTeaLookClassBookCategoryDetailVo::getClaimTime)
                .select("1 as claim_num")
                .innerJoin(WfTextbookClaim.class, WfTextbookClaim::getId, WfTextbookClaimItem::getWfTextbookClaimId)
                .innerJoin(Textbook.class, Textbook::getId, WfTextbookClaimItem::getTextbookId)
                .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, Textbook::getTextbookType,
                        wrapper -> wrapper
                                .selectAs(DictionaryDetail::getName, HeadTeaLookClassBookCategoryDetailVo::getTextbookTypeCn)
                )
                .eq(WfTextbookClaim::getBaseSemesterId, dto.getBaseSemesterId())
                .eq(WfTextbookClaim::getClassId, dto.getBaseClassId())
                .eq(WfTextbookClaim::getClaimType, ClaimTypeEnum.ClaimClass.getCode())
                ;
        List<HeadTeaLookClassBookCategoryDetailVo> claimResultList = wfTextbookClaimItemMapper.selectJoinList(HeadTeaLookClassBookCategoryDetailVo.class, wfTextbookClaimItemMPJLambdaWrapper);

        if(ObjectUtils.isEmpty(claimResultList)){
            MPJLambdaWrapper<BaseClassCourse> baseClassCourseMPJLambdaWrapper = new MPJLambdaWrapper<>();
            baseClassCourseMPJLambdaWrapper
                    .disableSubLogicDel()
                    .selectAs(Textbook::getBookName, HeadTeaLookClassBookCategoryDetailVo::getBookName)
                    .selectAs(Textbook::getPrice, HeadTeaLookClassBookCategoryDetailVo::getPrice)
                    .selectAs(Textbook::getTextbookType, HeadTeaLookClassBookCategoryDetailVo::getTextbookType)
                    .select("1 as claim_num")
                    .innerJoin(BaseClassAdminCourse.class, BaseClassAdminCourse::getId, BaseClassCourse::getClassId)
                    .innerJoin(Textbook.class, Textbook::getId, BaseClassCourse::getTextbookId)
                    .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, Textbook::getTextbookType,
                        wrapper -> wrapper
                                .selectAs(DictionaryDetail::getName, HeadTeaLookClassBookCategoryDetailVo::getTextbookTypeCn)
                    )
                    .eq(BaseClassAdminCourse::getBaseSemesterId, dto.getBaseSemesterId())
                    .eq(BaseClassAdminCourse::getClassId, dto.getBaseClassId())
            ;
            claimResultList = baseClassCourseMapper.selectJoinList(HeadTeaLookClassBookCategoryDetailVo.class, baseClassCourseMPJLambdaWrapper);
        }

        if(ObjectUtils.isNotEmpty(claimResultList)){
            // 处理数据
            // 根据类型分组
            Map<String, List<HeadTeaLookClassBookCategoryDetailVo>> detailByCategoryMap = claimResultList.stream()
                    .filter(detail -> StringUtils.isNotEmpty(detail.getTextbookType())) // Exclude entries where textbookType is null
                    .collect(Collectors.groupingBy(HeadTeaLookClassBookCategoryDetailVo::getTextbookType));

            BigDecimal totalPrice = BigDecimal.ZERO;
            List<HeadTeaLookClassBookCategoryVo> categoryVos = new ArrayList<>();
            BigDecimal categoryTotalPrice;
            HeadTeaLookClassBookCategoryVo headTeaLookClassBookCategoryVo;
            for (Map.Entry<String, List<HeadTeaLookClassBookCategoryDetailVo>> entry : detailByCategoryMap.entrySet()){
                String key = entry.getKey();
                List<HeadTeaLookClassBookCategoryDetailVo> value = entry.getValue();

                if(ObjectUtils.isNotEmpty(value)){
                    headTeaLookClassBookCategoryVo = new HeadTeaLookClassBookCategoryVo();
                    headTeaLookClassBookCategoryVo.setTextbookType(key);
                    headTeaLookClassBookCategoryVo.setTextbookTypeCn(value.get(0).getTextbookTypeCn());
                    headTeaLookClassBookCategoryVo.setCategoryDetailVos(value);

                    categoryTotalPrice = BigDecimal.ZERO;
                    for (HeadTeaLookClassBookCategoryDetailVo vo : value){
                        if(ObjectUtils.isEmpty(vo.getPrice())){
                            vo.setPrice(BigDecimal.ZERO);
                        }
                        categoryTotalPrice = categoryTotalPrice.add(vo.getPrice().multiply(BigDecimal.valueOf(vo.getClaimNum())));
                        totalPrice = totalPrice.add(vo.getPrice().multiply(BigDecimal.valueOf(vo.getClaimNum())));
                    }
                    headTeaLookClassBookCategoryVo.setCategoryTotalPrice(categoryTotalPrice);

                    categoryVos.add(headTeaLookClassBookCategoryVo);
                }

                result.setTotalPrice(totalPrice);
                result.setCategoryVos(categoryVos);
            }
        }
        return result;
    }

    @Override
    public List<HeadTeaLookClassBookSemesterVo> headTeaLookClassBookSemester() {
        Long loginId = StpUtil.getLoginIdAsLong();

        MPJLambdaWrapper<BaseClassAdminCourse> baseClassAdminCourseMPJLambdaWrapper = new MPJLambdaWrapper<>();
        baseClassAdminCourseMPJLambdaWrapper
                .disableSubLogicDel()
                .selectAs(BaseClassAdminCourse::getBaseSemesterId, HeadTeaLookClassBookSemesterVo::getBaseSemesterId)
                .selectAs(BaseSemester::getName, HeadTeaLookClassBookSemesterVo::getBaseSemesterIdCn)
                .selectAs(BaseClassAdminCourse::getClassId, HeadTeaLookClassBookSemesterVo::getBaseClassId)
                .selectAs(BaseClass::getName, HeadTeaLookClassBookSemesterVo::getBaseClassIdCn)
                .innerJoin(BaseClass.class, BaseClass::getId, BaseClassAdminCourse::getClassId)
                .leftJoin(BaseSemester.class, BaseSemester::getId, BaseClassAdminCourse::getBaseSemesterId)
                .eq(BaseClass::getTeacherId, loginId)
                .orderByDesc(BaseSemester::getName)
                ;
        return baseClassAdminCourseMapper.selectJoinList(HeadTeaLookClassBookSemesterVo.class, baseClassAdminCourseMPJLambdaWrapper);
    }

    @Override
    public TextbookClaimStudentConfirmVo getStudentConfirmList(TextbookClaimStudentConfirmDto dto) {
        //获取当前登录学生的信息
        MPJLambdaWrapper<XjrUser> queryUser = new MPJLambdaWrapper<>();
        queryUser.selectAs(XjrUser::getName, TextbookClaimStudentConfirmVo::getStudentName).selectAs(BaseStudent::getStudentId, TextbookClaimStudentConfirmVo::getStudentId).selectAs(BaseClass::getName, TextbookClaimStudentConfirmVo::getClassCN).leftJoin(BaseStudent.class, BaseStudent::getUserId, XjrUser::getId).leftJoin(BaseStudentSchoolRoll.class, BaseStudentSchoolRoll::getUserId, XjrUser::getId).leftJoin(BaseClass.class, BaseClass::getId, BaseStudentSchoolRoll::getClassId).eq(XjrUser::getId, StpUtil.getLoginIdAsLong()).disableSubLogicDel().orderByDesc(AttendanceRecord::getId);
        TextbookClaimStudentConfirmVo textbookClaimStudentConfirmVo = xjrUserMapper.selectJoinOne(TextbookClaimStudentConfirmVo.class, queryUser);
        if (ObjectUtil.isNull(textbookClaimStudentConfirmVo)) {
            throw new MyException("登录信息出错，请重新登录");
        }

        //根据学期id查出学期名称
        BaseSemester baseSemester = baseSemesterService.getById(dto.getBaseSemesterId());
        textbookClaimStudentConfirmVo.setBaseSemesterCN(baseSemester.getName());

        dto.setStudentUserId(StpUtil.getLoginIdAsLong());

        List<TextbookClaimVO> textbookClaimVOList = textbookStudentClaimMapper.getTextbookClaimList(dto);

        textbookClaimStudentConfirmVo.setTextbookClaimVoList(textbookClaimVOList);
        return textbookClaimStudentConfirmVo;
    }

    @Override
    public List<TextbookStudentSemesterVo> getStudentSemesterList() {
        //获取当前学生领取记录的所有学期
        MPJLambdaWrapper<TextbookStudentClaim> qwerySemester = new MPJLambdaWrapper<>();
        qwerySemester
                .distinct()
                .disableSubLogicDel()
                .selectAs(BaseSemester::getName, TextbookStudentSemesterVo::getBaseSemesterIdCN)
                .select(TextbookStudentClaim.class, x -> VoToColumnUtil.fieldsToColumns(TextbookStudentSemesterVo.class).contains(x.getProperty()))
                .innerJoin(BaseSemester.class, BaseSemester::getId, TextbookStudentClaim::getBaseSemesterId)
                .eq(TextbookStudentClaim::getStudentUserId, StpUtil.getLoginIdAsLong());
        List<TextbookStudentSemesterVo> textbookStudentSemesterVoList = this.selectJoinList(TextbookStudentSemesterVo.class, qwerySemester);
        if (ObjectUtil.isNull(textbookStudentSemesterVoList) && textbookStudentSemesterVoList.isEmpty()) {
            return null;
        }

        //为每个学期添加未领取人数
        for (TextbookStudentSemesterVo textbookStudentSemesterVo : textbookStudentSemesterVoList) {
            LambdaQueryWrapper<TextbookStudentClaim> queryWrapperNotClaimNum = new LambdaQueryWrapper<>();
            queryWrapperNotClaimNum
                    .eq(TextbookStudentClaim::getStudentUserId, StpUtil.getLoginIdAsLong())
                    .eq(TextbookStudentClaim::getBaseSemesterId, textbookStudentSemesterVo.getBaseSemesterId())
                    .eq(TextbookStudentClaim::getIsClaim, 0);
            Long notClaimNum = this.count(queryWrapperNotClaimNum);
            textbookStudentSemesterVo.setNotClaimNum(notClaimNum);
        }
        return textbookStudentSemesterVoList;
    }

    @Override
    public IPage<TeacherCheckByclassVo> getTeacherCheckByclassList(TeacherCheckByclassDto dto) {
        //根据当前班主任用户查出所管理的班级Id
        LambdaQueryWrapper<BaseClass> queryWrapperClassId = new LambdaQueryWrapper<>();
        queryWrapperClassId.eq(BaseClass::getTeacherId, StpUtil.getLoginIdAsLong());
        List<BaseClass> baseClassList = baseClassService.list(queryWrapperClassId);
        if (ObjectUtil.isNull(baseClassList) && baseClassList.size() == 0) {
            return null;
        }

        List<Long> classIdList = new ArrayList<>();
        for (BaseClass baseClass : baseClassList) {
            classIdList.add(baseClass.getId());
        }
        dto.setClassIdList(classIdList);

        IPage<TeacherCheckByclassVo> teacherCheckByclassVoList = textbookStudentClaimMapper.getTeacherCheckByclassList(ConventPage.getPage(dto), dto);

        //为每本书添加数据
//        for (TeacherCheckByclassVo t : teacherCheckByclassVoList.getRecords()) {
//            MPJLambdaWrapper<WfTextbookClaim> qweryActualReceivedNum = new MPJLambdaWrapper<>();
//            qweryActualReceivedNum
//                    .disableSubLogicDel()
//                    .selectSum(WfTextbookClaimItem::getIssueNumber, TeacherCheckByclassVo::getActualReceivedNum)
//                    .leftJoin(WfTextbookClaimItem.class, WfTextbookClaimItem::getWfTextbookClaimId, WfTextbookClaim::getId)
//                    .eq(WfTextbookClaim::getClassId, t.getClassId())
//                    .eq(WfTextbookClaimItem::getTextbookId, t.getTextbookId());
//            TeacherCheckByclassVo teacherCheckByclassVo = wfTextbookClaimMapper.selectJoinOne(TeacherCheckByclassVo.class, qweryActualReceivedNum);
//
//            t.setActualReceivedNum(teacherCheckByclassVo.getActualReceivedNum());
//
//            LambdaQueryWrapper<TextbookStudentClaim> queryActualClaimNum = new LambdaQueryWrapper<>();
//            queryActualClaimNum
//                    .eq(TextbookStudentClaim::getClassId, t.getClassId())
//                    .eq(TextbookStudentClaim::getTextbookId, t.getTextbookId())
//                    .eq(TextbookStudentClaim::getIsClaim, 1);
//            Long actualClaimNum = this.count(queryActualClaimNum);
//            t.setActualClaimNum(actualClaimNum);
//        }
        return teacherCheckByclassVoList;
    }

    @Override
    public IPage<TeacherCheckByStuVo> getTeacherCheckByStuList(TeacherCheckByStuDto dto) {
        //根据当前班主任用户查出所管理的班级Id
        LambdaQueryWrapper<BaseClass> queryWrapperClassId = new LambdaQueryWrapper<>();
        queryWrapperClassId.eq(BaseClass::getTeacherId, StpUtil.getLoginIdAsLong());
        List<BaseClass> baseClassList = baseClassService.list(queryWrapperClassId);
        if (ObjectUtil.isNull(baseClassList) && baseClassList.size() == 0) {
            return null;
        }

        List<Long> classIdList = new ArrayList<>();
        for (BaseClass baseClass : baseClassList) {
            classIdList.add(baseClass.getId());
        }
        dto.setClassIdList(classIdList);

        //将班上所有学生进行分组,查询出list集合
        IPage<TeacherCheckByStuVo> teacherCheckByStuVoList = textbookStudentClaimMapper.getTeacherCheckByStuList(ConventPage.getPage(dto), dto);

        //为每个学生添加教材领取记录集合
        //学生id集合
//        List<Long> stuIdList = new ArrayList<>();
//        for (TeacherCheckByStuVo teacherCheckByStuVo : teacherCheckByStuVoList.getRecords()) {
//            stuIdList.add(teacherCheckByStuVo.getStudentUserId());
//        }
//        //一次查出所有学生的所有书籍
//        if(stuIdList.size() > 0){
//            List<TextbookClaimVO> textbookClaimVOList = textbookStudentClaimMapper.getTextbookClaimVOList(stuIdList);
//        }

        for (TeacherCheckByStuVo t : teacherCheckByStuVoList.getRecords()) {
            List<TextbookClaimVO> textbookClaimVOList = textbookStudentClaimMapper.getTextbookClaimVOList(t.getStudentUserId());
            t.setTextbookClaimVOList(textbookClaimVOList);
        }
        return teacherCheckByStuVoList;
    }


    @Override
    @Transactional
    public Boolean updateByIds(List<Long> textbookStudentClaimIds) {
        this.update(new TextbookStudentClaim() {{
            setModifyUserId(StpUtil.getLoginIdAsLong());
            setModifyDate(new Date());
            setIsClaim(1);
        }},Wrappers.<TextbookStudentClaim>query().lambda()
                .in(TextbookStudentClaim::getId, textbookStudentClaimIds));
//        for (Long textbookStudentClaimId : textbookStudentClaimIds) {
//            this.updateById(new TextbookStudentClaim() {{
//                setModifyUserId(StpUtil.getLoginIdAsLong());
//                setModifyDate(new Date());
//                setId(textbookStudentClaimId);
//                setIsClaim(1);
//            }});
//        }
        return true;
    }

    @Override
    public List<TeacherCheckStuClaimVo> getTeacherCheckStuClaimList(TeacherCheckStuClaimDto dto) {
        List<TeacherCheckStuClaimVo> teacherCheckStuClaimVos = textbookStudentClaimMapper.getTeacherCheckStuClaimList(dto);
        return teacherCheckStuClaimVos;
    }

    @Override
    public List<TextbookClaimVO> getTeacherGetStuNoClaimList(Long studentUserId) {
        MPJLambdaWrapper<TextbookStudentClaim> queryTextbookClaimVOList = new MPJLambdaWrapper<>();
        queryTextbookClaimVOList.selectAs(TextbookStudentClaim::getId, TextbookClaimVO::getTextbookStudentClaimId).selectAs(Textbook::getBookName, TextbookClaimVO::getBookName).select(TextbookStudentClaim.class, x -> VoToColumnUtil.fieldsToColumns(TextbookClaimVO.class).contains(x.getProperty())).leftJoin(Textbook.class, Textbook::getId, TextbookStudentClaim::getTextbookId).eq(TextbookStudentClaim::getStudentUserId, studentUserId).disableSubLogicDel();
        List<TextbookClaimVO> textbookClaimVOList = this.selectJoinList(TextbookClaimVO.class, queryTextbookClaimVOList);
        return textbookClaimVOList;
    }
}