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

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

import cn.dev33.satoken.stp.StpUtil;
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.enums.DeleteMark;
import com.xjrsoft.common.enums.IssueModeEnum;
import com.xjrsoft.common.enums.RoleEnum;
import com.xjrsoft.common.exception.MyException;
import com.xjrsoft.common.page.ConventPage;
import com.xjrsoft.common.utils.SortCodeUtil;
import com.xjrsoft.common.utils.VoToColumnUtil;
import com.xjrsoft.module.base.entity.BaseClass;
import com.xjrsoft.module.system.entity.DictionaryDetail;
import com.xjrsoft.module.teacher.entity.XjrUser;
import com.xjrsoft.module.teacher.mapper.XjrUserMapper;
import com.xjrsoft.module.textbook.dto.ConfirmDistributeDto;
import com.xjrsoft.module.textbook.dto.DistributePageDto;
import com.xjrsoft.module.textbook.dto.WfTextbookClaimPageDto;
import com.xjrsoft.module.textbook.entity.*;
import com.xjrsoft.module.textbook.mapper.*;
import com.xjrsoft.module.textbook.service.IWfTextbookClaimService;
import com.xjrsoft.module.textbook.vo.*;
import com.xjrsoft.module.workflow.entity.WorkflowFormRelation;
import com.xjrsoft.module.workflow.mapper.WorkflowFormRelationMapper;
import lombok.AllArgsConstructor;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.camunda.bpm.engine.history.HistoricProcessInstance;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @title: 教材申领
 * @Author szs
 * @Date: 2023-12-26
 * @Version 1.0
 */
@Service
@AllArgsConstructor
public class WfTextbookClaimServiceImpl extends MPJBaseServiceImpl<WfTextbookClaimMapper, WfTextbookClaim> implements IWfTextbookClaimService {
    private final WfTextbookClaimMapper wfTextbookClaimWfTextbookClaimMapper;

    private final WfTextbookClaimItemMapper wfTextbookClaimWfTextbookClaimItemMapper;

    private final XjrUserMapper xjrUserMapper;

    private final TextbookMapper textbookMapper;

    private final TextbookSubscriptionItemMapper textbookSubscriptionItemMapper;

    private final TextbookIssueRecordMapper textbookIssueRecordMapper;

    private final TextbookClaimUserMapper textbookClaimUserMapper;

    private final ClaimItemSubscriptionItemMapper claimItemSubscriptionItemMapper;

    private final WorkflowFormRelationMapper workflowFormRelationMapper;
    private final TextbookWarehouseRecordMapper textbookWarehouseRecordMapper;

    @Override
    public IPage<DistributePageVo> distributePageVo(DistributePageDto dto) {
        MPJLambdaWrapper<WfTextbookClaim> wfTextbookClaimMPJLambdaWrapper = new MPJLambdaWrapper<>();
        wfTextbookClaimMPJLambdaWrapper
                .disableSubLogicDel()
                .select(WfTextbookClaim::getId)
                .select(WfTextbookClaim.class,x -> VoToColumnUtil.fieldsToColumns(DistributePageVo.class).contains(x.getProperty()))
                .innerJoin(WorkflowFormRelation.class, WorkflowFormRelation::getFormKeyValue, WfTextbookClaim::getId)
                .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, WfTextbookClaim::getClaimType,
                        wrapper -> wrapper
                                .selectAs(DictionaryDetail::getName, DistributePageVo::getClaimTypeCn)
                )
                .leftJoin(XjrUser.class, XjrUser::getId, WfTextbookClaim::getApplicantUserId,
                        wrapper -> wrapper
                                .selectAs(XjrUser::getName, DistributePageVo::getApplicantUserIdCn)
                )
                .leftJoin(BaseClass.class, BaseClass::getId, WfTextbookClaim::getClassId,
                        wrapper -> wrapper
                                .selectAs(BaseClass::getName, DistributePageVo::getClassIdCn)
                )
                .eq(WorkflowFormRelation::getCurrentState, HistoricProcessInstance.STATE_COMPLETED)
                .eq(WfTextbookClaim::getBaseSemesterId, dto.getBaseSemesterId())
                .eq(StringUtils.isNotEmpty(dto.getClaimType()), WfTextbookClaim::getClaimType, dto.getClaimType())
                .eq(ObjectUtils.isNotEmpty(dto.getDistributeStatus()), WfTextbookClaim::getStatus, dto.getDistributeStatus())
                .ne(ObjectUtils.isEmpty(dto.getDistributeStatus()), WfTextbookClaim::getStatus, 1)
                .and(StringUtils.isNotEmpty(dto.getName()),
                        wrapper -> wrapper
                                .like(XjrUser::getName, dto.getName())
                                .or()
                                .like(BaseClass::getName, dto.getName())
                        )
        ;
        IPage<DistributePageVo> page = this.selectJoinListPage(ConventPage.getPage(dto), DistributePageVo.class, wfTextbookClaimMPJLambdaWrapper);

        List<DistributePageVo> distributePageVos = page.getRecords();
        // 处理申领总数量和已经发放总数量
        if(ObjectUtils.isNotEmpty(distributePageVos)){
            List<Long> textbookClaimIds = distributePageVos.stream()
                    .map(DistributePageVo::getId)
                    .collect(Collectors.toList());
            Map<Long, WfTextbookClaimItem> applicantTatolNumberMap = new HashMap<>();
            WfTextbookClaimItem wfTextbookClaimItem;
            if(ObjectUtils.isNotEmpty(distributePageVos)){
                MPJLambdaWrapper<WfTextbookClaimItem> wfTextbookClaimItemLambdaQueryWrapper = new MPJLambdaWrapper<>();
                wfTextbookClaimItemLambdaQueryWrapper
                        .selectAs(WfTextbookClaimItem::getWfTextbookClaimId, WfTextbookClaimItem::getWfTextbookClaimId)
                        .selectSum(WfTextbookClaimItem::getApplicantNumber, WfTextbookClaimItem::getApplicantNumber)
                        .selectSum(WfTextbookClaimItem::getIssueNumber, WfTextbookClaimItem::getIssueNumber)
                        .in(WfTextbookClaimItem::getWfTextbookClaimId, textbookClaimIds)
                        .groupBy(WfTextbookClaimItem::getWfTextbookClaimId)
                ;
                List<WfTextbookClaimItem> wfTextbookClaimItemList = wfTextbookClaimWfTextbookClaimItemMapper.selectJoinList(WfTextbookClaimItem.class, wfTextbookClaimItemLambdaQueryWrapper);
                if(ObjectUtils.isNotEmpty(wfTextbookClaimItemList)){
                    applicantTatolNumberMap = wfTextbookClaimItemList.stream()
                            .collect(Collectors.toMap(WfTextbookClaimItem::getWfTextbookClaimId, w -> w, (w1, w2) -> w1));
                }
            }
            if(ObjectUtils.isNotEmpty(applicantTatolNumberMap)){
                for(DistributePageVo distributePageVo : page.getRecords()){
                    wfTextbookClaimItem = applicantTatolNumberMap.get(distributePageVo.getId());
                    if(ObjectUtils.isNotEmpty(wfTextbookClaimItem)){
                        distributePageVo.setApplicantTatolNumber(wfTextbookClaimItem.getApplicantNumber());
                        distributePageVo.setIssueTatolNumber(wfTextbookClaimItem.getIssueNumber());
                    }
                }
            }
        }
        return page;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean add(WfTextbookClaim wfTextbookClaim) {
        wfTextbookClaimWfTextbookClaimMapper.insert(wfTextbookClaim);
        for (WfTextbookClaimItem wfTextbookClaimItem : wfTextbookClaim.getWfTextbookClaimItemList()) {
            wfTextbookClaimItem.setWfTextbookClaimId(wfTextbookClaim.getId());
            wfTextbookClaimWfTextbookClaimItemMapper.insert(wfTextbookClaimItem);
        }
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean update(WfTextbookClaim wfTextbookClaim) {
        wfTextbookClaimWfTextbookClaimMapper.updateById(wfTextbookClaim);
        //********************************* WfTextbookClaimItem  增删改  开始 *******************************************/
        {
            // 查出所有子级的id
            List<WfTextbookClaimItem> wfTextbookClaimItemList = wfTextbookClaimWfTextbookClaimItemMapper.selectList(Wrappers.lambdaQuery(WfTextbookClaimItem.class).eq(WfTextbookClaimItem::getWfTextbookClaimId, wfTextbookClaim.getId()).select(WfTextbookClaimItem::getId));
            List<Long> wfTextbookClaimItemIds = wfTextbookClaimItemList.stream().map(WfTextbookClaimItem::getId).collect(Collectors.toList());
            //原有子表单 没有被删除的主键
            List<Long> wfTextbookClaimItemOldIds = wfTextbookClaim.getWfTextbookClaimItemList().stream().map(WfTextbookClaimItem::getId).filter(Objects::nonNull).collect(Collectors.toList());
            //找到需要删除的id
            List<Long> wfTextbookClaimItemRemoveIds = wfTextbookClaimItemIds.stream().filter(item -> !wfTextbookClaimItemOldIds.contains(item)).collect(Collectors.toList());

            for (WfTextbookClaimItem wfTextbookClaimItem : wfTextbookClaim.getWfTextbookClaimItemList()) {
                //如果不等于空则修改
                if (wfTextbookClaimItem.getId() != null) {
                    wfTextbookClaimWfTextbookClaimItemMapper.updateById(wfTextbookClaimItem);
                }
                //如果等于空 则新增
                else {
                    //已经不存在的id 删除
                    wfTextbookClaimItem.setWfTextbookClaimId(wfTextbookClaim.getId());
                    wfTextbookClaimWfTextbookClaimItemMapper.insert(wfTextbookClaimItem);
                }
            }
            //已经不存在的id 删除
            if (wfTextbookClaimItemRemoveIds.size() > 0) {
                wfTextbookClaimWfTextbookClaimItemMapper.deleteBatchIds(wfTextbookClaimItemRemoveIds);
            }
        }
        //********************************* WfTextbookClaimItem  增删改  结束 *******************************************/

        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean delete(List<Long> ids) {
        wfTextbookClaimWfTextbookClaimMapper.deleteBatchIds(ids);
        wfTextbookClaimWfTextbookClaimItemMapper.delete(Wrappers.lambdaQuery(WfTextbookClaimItem.class).in(WfTextbookClaimItem::getWfTextbookClaimId, ids));

        return true;
    }

    @Override
    public IPage<WfTextbookClaimPageVo> getPage(WfTextbookClaimPageDto dto) {

        dto.setUserId(StpUtil.getLoginIdAsLong());
        IPage<WfTextbookClaimPageVo> page = wfTextbookClaimWfTextbookClaimMapper.getPage(ConventPage.getPage(dto), dto);

        for (WfTextbookClaimPageVo wfTextbookClaimPageVo : page.getRecords()) {
            //拆分代领取人
            String receiveUserIdStr = wfTextbookClaimPageVo.getReceiveUserId();
            if (ObjectUtils.isNotEmpty(receiveUserIdStr) && !receiveUserIdStr.isEmpty()) {
                String[] receiveUserIdStrs = receiveUserIdStr.split(",");
                List<Long> receiveUserIdList = new ArrayList<>();
                for (String str : receiveUserIdStrs) {
                    receiveUserIdList.add(Long.parseLong(str));
                }
                LambdaQueryWrapper<XjrUser> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper
                        .in(XjrUser::getId, receiveUserIdList);
                List<XjrUser> xjrUserList = xjrUserMapper.selectList(queryWrapper);
                if (ObjectUtils.isNotEmpty(xjrUserList) && !xjrUserList.isEmpty()) {
                    StringBuilder sb = new StringBuilder();
                    for (int i = 0; i < xjrUserList.size(); i++) {
                        if(i == 0){
                            sb.append(xjrUserList.get(i).getName());
                        }else{
                            sb.append(",").append(xjrUserList.get(i).getName());
                        }
                    }
                    wfTextbookClaimPageVo.setReceiveUserIdCN(sb.toString());
                }
            }
            //加上申领项
            List<WfTextbookClaimItemVo> wfTextbookClaimItemVoList = wfTextbookClaimWfTextbookClaimItemMapper.getListByWfTextbookClaimId(Long.parseLong(wfTextbookClaimPageVo.getId()));

            if (ObjectUtils.isNotEmpty(wfTextbookClaimItemVoList) && !wfTextbookClaimItemVoList.isEmpty()) {
                wfTextbookClaimPageVo.setWfTextbookClaimItemList(wfTextbookClaimItemVoList);
            }
        }
        return page;
    }

    @Override
    public WfTextbookClaimVo infoDistribute(Long id) {
        WfTextbookClaimVo wfTextbookClaimVo = wfTextbookClaimWfTextbookClaimMapper.infoDistribute(id);
        if (ObjectUtils.isNotEmpty(wfTextbookClaimVo)) {
            //拆分代领人
            String receiveUserIdStr = wfTextbookClaimVo.getReceiveUserId();
            if (ObjectUtils.isNotEmpty(receiveUserIdStr) && !receiveUserIdStr.equals("")) {
                String[] receiveUserIdStrs = receiveUserIdStr.split(",");
                List<Long> receiveUserIdList = new ArrayList<>();
                for (String str : receiveUserIdStrs) {
                    receiveUserIdList.add(Long.parseLong(str));
                }
                LambdaQueryWrapper<XjrUser> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper
                        .in(XjrUser::getId, receiveUserIdList);
                List<XjrUser> xjrUserList = xjrUserMapper.selectList(queryWrapper);
                if (ObjectUtils.isNotEmpty(xjrUserList) && !xjrUserList.isEmpty()) {
                    StringBuilder sb = new StringBuilder();
                    for (XjrUser xjrUser : xjrUserList) {
                        sb.append(",").append(xjrUser.getName());
                    }
                    wfTextbookClaimVo.setReceiveUserIdCN(sb.toString());
                }
            }
            //加上申领项
            List<WfTextbookClaimItemVo> wfTextbookClaimItemVoList = wfTextbookClaimWfTextbookClaimItemMapper.getListByWfTextbookClaimId(Long.parseLong(wfTextbookClaimVo.getId()));

            if (ObjectUtils.isNotEmpty(wfTextbookClaimItemVoList) && wfTextbookClaimItemVoList.size() > 0) {
                wfTextbookClaimVo.setWfTextbookClaimItemList(wfTextbookClaimItemVoList);
            }
        }
        return wfTextbookClaimVo;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean confirmDistribute(ConfirmDistributeDto dto) {
        WfTextbookClaim wfTextbookClaim = this.getByIdDeep(dto.getTextbookClaimId());
        List<WfTextbookClaimItem> wfTextbookClaimItemList = wfTextbookClaim.getWfTextbookClaimItemList();

        // 获取所有入库记录
        List<TextbookWarehouseRecord> textbookWarehouseRecordList = textbookWarehouseRecordMapper.selectList(
            Wrappers.lambdaQuery(TextbookWarehouseRecord.class)
                    .eq(TextbookWarehouseRecord::getDeleteMark, DeleteMark.NODELETE.getCode())
        );

        Map<Long, TextbookWarehouseRecord> textbookWarehouseRecordMap = textbookWarehouseRecordList.stream()
                .collect(Collectors.toMap(TextbookWarehouseRecord::getId, t -> t, (t1,t2) -> t1));

        if (ObjectUtils.isEmpty(wfTextbookClaim)
                || ObjectUtils.isEmpty(dto.getTextbookClaimItemList())
                || dto.getTextbookClaimItemList().isEmpty()
                || wfTextbookClaimItemList.isEmpty()
        ) {
            throw new MyException("未找到申领数据");
        }

        Map<Long, WfTextbookClaimItem> wfTextbookClaimItemMap = wfTextbookClaimItemList.stream()
                .collect(Collectors.toMap(WfTextbookClaimItem::getId, w -> w, (w1, w2) -> w1));

        // 处理出库单号
        StringBuilder sb = new StringBuilder();
        sb.append("CK");
        LocalDateTime now = LocalDateTime.now();
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");
        String nowStr = now.format(dateTimeFormatter);
        sb.append(nowStr);
        int oldOrderInteger = 0;
        int oldOrderLastInteger = 0;


        //操作每一个申领项
        for (ConfirmDistributeDto.TextbookClaimItem textbookClaimItem : dto.getTextbookClaimItemList()) {
//            WfTextbookClaimItem wfTextbookClaimItem = wfTextbookClaimWfTextbookClaimItemMapper.selectById(textbookClaimItem.getTextbookClaimItemId());
            WfTextbookClaimItem wfTextbookClaimItem = wfTextbookClaimItemMap.get(textbookClaimItem.getTextbookClaimItemId());

            if (ObjectUtils.isEmpty(wfTextbookClaimItem)) {
                throw new MyException("未找到申领项详细数据");
            }

            //判断总发放数量是否超出该申请项的申请数量
            int issueNumber = ObjectUtils.isEmpty(wfTextbookClaimItem.getIssueNumber()) ? 0 : wfTextbookClaimItem.getIssueNumber();//已发放
            int applicantNumber = ObjectUtils.isEmpty(wfTextbookClaimItem.getApplicantNumber()) ? 0 : wfTextbookClaimItem.getApplicantNumber();//申领总数量
            int confirmNumber = ObjectUtils.isEmpty(textbookClaimItem.getConfirmTotalNumber()) ? 0 : textbookClaimItem.getConfirmTotalNumber();//本次发放
            if (issueNumber + confirmNumber > applicantNumber) {
                throw new MyException(textbookClaimItem.getTextbookIdCn() + "发放总数量超出申领数量");
            }

            TextbookIssueRecord textbookIssueRecord;
            for (ConfirmDistributeDto.TextbookWarehouseRecords textbookWarehouseRecords : textbookClaimItem.getTextbookWarehouseRecords()){
                TextbookWarehouseRecord textbookWarehouseRecord = textbookWarehouseRecordMap.get(textbookWarehouseRecords.getTextbookWarehouseRecordId());
                if (ObjectUtils.isEmpty(textbookWarehouseRecord)) {
                    throw new MyException("未找到入库详细数据");
                }

                //更新教材入库中的的库存数量
                textbookWarehouseRecordMapper.updateById(new TextbookWarehouseRecord() {{
                    setModifyUserId(StpUtil.getLoginIdAsLong());
                    setModifyDate(new Date());
                    setId(textbookWarehouseRecord.getId());
                    setIssuedNumber(ObjectUtils.isEmpty(textbookWarehouseRecord.getIssuedNumber()) ? 0 : textbookWarehouseRecord.getIssuedNumber()
                             + confirmNumber);
                    setRemainNumber(ObjectUtils.isEmpty(textbookWarehouseRecord.getRemainNumber()) ? 0 : textbookWarehouseRecord.getRemainNumber()
                            - confirmNumber
                    );
                }});

                oldOrderInteger += 1;
                String newOrder = String.format("%03d", oldOrderInteger); // 补零并格式化为三位数
                String oldPrex = sb + newOrder + "-";
                //增加出库记录
                textbookIssueRecord = new TextbookIssueRecord();
                textbookIssueRecord.setBaseSemesterId(wfTextbookClaim.getBaseSemesterId());

                // 处理出库单号
                // 根据当前申领项主键id和入库主键id查找时候已经有了出库记录
                LambdaQueryWrapper<TextbookIssueRecord> maxOrderNumberLambdaQueryWrapper = new LambdaQueryWrapper<>();
                maxOrderNumberLambdaQueryWrapper
                        .eq(TextbookIssueRecord::getDataItemId, wfTextbookClaimItem.getId())
                        .eq(TextbookIssueRecord::getTextbookWarehouseRecordId, textbookWarehouseRecord.getId())
                        .eq(TextbookIssueRecord::getDeleteMark, DeleteMark.NODELETE.getCode())
                        .orderByDesc(TextbookIssueRecord::getOrderNumber)
                        .last("limit 1")
                ;
                TextbookIssueRecord maxOrderNumber = textbookIssueRecordMapper.selectOne(maxOrderNumberLambdaQueryWrapper);
                if(ObjectUtils.isNotEmpty(maxOrderNumber)
                        && ObjectUtils.isNotEmpty(maxOrderNumber.getOrderNumber())
                ){
                    String oldOrderNumber = maxOrderNumber.getOrderNumber();
                    oldPrex = oldOrderNumber.substring(0, oldOrderNumber.length() - 3);
                    oldOrderInteger -= 1;
                    String oldOrder = oldOrderNumber.substring(oldOrderNumber.length() - 3);
                    oldOrderLastInteger = Integer.parseInt(oldOrder);
                }
                oldOrderLastInteger += 1;
                String newLastOrder = String.format("%03d", oldOrderLastInteger); // 补零并格式化为三位数

                textbookIssueRecord.setOrderNumber(oldPrex + newLastOrder);
                if (ObjectUtils.isNotEmpty(wfTextbookClaim.getClaimType())
                        && wfTextbookClaim.getClaimType().equals(ClaimTypeEnum.ClaimStudent.getCode())
                        && wfTextbookClaim.getClaimType().equals(ClaimTypeEnum.ClaimClass.getCode())
                ) {
                    textbookIssueRecord.setIssueMode(IssueModeEnum.Imtudent.getCode());
                }
                if (ObjectUtils.isNotEmpty(wfTextbookClaim.getClaimType())
                        && wfTextbookClaim.getClaimType().equals(ClaimTypeEnum.ClaimTeacher.getCode())
                ) {
                    textbookIssueRecord.setIssueMode(IssueModeEnum.ImTeacher.getCode());
                }
                textbookIssueRecord.setDataId(wfTextbookClaim.getId());
                textbookIssueRecord.setDataItemId(wfTextbookClaimItem.getId());
                textbookIssueRecord.setTextbookId(wfTextbookClaimItem.getTextbookId());
                textbookIssueRecord.setIssueNumber(confirmNumber);
                textbookIssueRecord.setRecedeNumber(0);
                textbookIssueRecord.setActualIssueNumber(confirmNumber);
                textbookIssueRecord.setActualTotalPrice(textbookWarehouseRecord.getSubtotal().multiply(BigDecimal.valueOf(confirmNumber)));
                if(ObjectUtils.isNotEmpty(dto.getReceiveUserId())){
                    textbookIssueRecord.setReceiveUserId(dto.getReceiveUserId());
                }else {
                    textbookIssueRecord.setReceiveUserId(StpUtil.getLoginIdAsLong());
                }
                textbookIssueRecord.setIssueUserId(StpUtil.getLoginIdAsLong());
                textbookIssueRecord.setCreateDate(new Date());;
                textbookIssueRecord.setRemark(dto.getRemark());
                int sortCode = SortCodeUtil.getMaxSortCode(textbookIssueRecordMapper, TextbookIssueRecord.class, "sort_code");
                textbookIssueRecord.setSortCode(sortCode + 1);

                textbookIssueRecordMapper.insert(textbookIssueRecord);
            }

            //更新申领项中的已经发放数量
            wfTextbookClaimWfTextbookClaimItemMapper.updateById(new WfTextbookClaimItem() {{
                setModifyUserId(StpUtil.getLoginIdAsLong());
                setModifyDate(new Date());
                setId(wfTextbookClaimItem.getId());
                setIssueNumber(issueNumber + confirmNumber);
            }});

            // 当申领类型为学生的时候,为班级每个学生生成领取（确认信息）认领记录
//            if (ObjectUtil.isNotNull(wfTextbookClaim.getClaimType()) && wfTextbookClaim.getClaimType().equals(ClaimTypeEnum.ClaimStudent.getCode())) {
//                //查出班上的所有学生id
//                List<Long> userIdList = xjrUserMapper.getUserIdByClassId(wfTextbookClaim.getClassId());
//
//                if (ObjectUtil.isNull(userIdList) && userIdList.size() == 0) {
//                    throw new MyException("申领班级有误，请核实");
//                }
//                //验证当前领取教材是否已经生成领取记录
//                LambdaQueryWrapper<TextbookStudentClaim> queryWrapperRecord = new LambdaQueryWrapper<>();
//                queryWrapperRecord
//                        .eq(TextbookStudentClaim::getTextbookId, wfTextbookClaimItem.getTextbookId())
//                        .eq(TextbookStudentClaim::getClassId, wfTextbookClaim.getClassId());
//                Long count = textbookStudentClaimMapper.selectCount(queryWrapperRecord);
//                //为0的时候表示该班级该书没有生成领取记录
//                if(count <= 0){
//                    for (Long userId : userIdList) {
//                        textbookStudentClaimMapper.insert(new TextbookStudentClaim() {{
//                            setCreateUserId(StpUtil.getLoginIdAsLong());
//                            setCreateDate(new Date());
//                            setStudentUserId(userId);
//                            setBaseSemesterId(wfTextbookClaim.getBaseSemesterId());
//                            setClassId(wfTextbookClaim.getClassId());
//                            setTextbookId(wfTextbookClaimItem.getTextbookId());
//                        }});
//                    }
//                }
//            }
        }
        return true;
    }

    @Override
    @Transactional
    public Boolean dataHandleAddClaimUserNode(Long id) {
        WfTextbookClaim wfTextbookClaim = this.getById(id);

        // 根据数据id找到所在流程得状态
        WorkflowFormRelation workflowFormRelation = workflowFormRelationMapper.selectOne(
                Wrappers.lambdaQuery(WorkflowFormRelation.class)
                        .eq(WorkflowFormRelation::getFormKeyValue, id)
        );

        if (ObjectUtils.isNotEmpty(wfTextbookClaim)
                && ObjectUtils.isNotEmpty(wfTextbookClaim.getClaimType())
                && ObjectUtils.isNotEmpty(workflowFormRelation)
                && HistoricProcessInstance.STATE_COMPLETED.equals(workflowFormRelation.getCurrentState())
        ) {
            //所有需要添加的可领取人ID
            List<TextbookClaimUser> textbookClaimUserList = new ArrayList<>();

            List<String> roleList = StpUtil.getRoleList();

            //申领人自己可以领取
            textbookClaimUserList.add(new TextbookClaimUser() {{
                setCreateDate(new Date());
                setWfTextbookClaimId(wfTextbookClaim.getId());
                setUserId(wfTextbookClaim.getApplicantUserId());
                if(roleList.contains(RoleEnum.TEACHER.getCode().toString())){
                    setUserType(2);
                }
                if(roleList.contains(RoleEnum.STUDENT.getCode().toString())){
                    setUserType(1);
                }
            }});

            //申领类型是班级申领,学生代表可领取
            if (ClaimTypeEnum.ClaimClass.getCode().equals(wfTextbookClaim.getClaimType())
                    && !Objects.equals(wfTextbookClaim.getApplicantUserId(), wfTextbookClaim.getStudentUserId())
            ) {
                textbookClaimUserList.add(new TextbookClaimUser() {{
                    setCreateDate(new Date());
                    setWfTextbookClaimId(wfTextbookClaim.getId());
                    setUserId(wfTextbookClaim.getStudentUserId());
                    setUserType(1);
                }});
            }

            //申领类型是教师申领，领取人可领取
            if (ClaimTypeEnum.ClaimTeacher.getCode().equals(wfTextbookClaim.getClaimType())
                    && ObjectUtils.isNotEmpty(wfTextbookClaim.getApplicantUserId())
                    && ObjectUtils.isNotEmpty(wfTextbookClaim.getClaimUserId())
                    && !wfTextbookClaim.getApplicantUserId().equals(wfTextbookClaim.getClaimUserId())
            ) {
                textbookClaimUserList.add(new TextbookClaimUser() {{
                    setCreateDate(new Date());
                    setWfTextbookClaimId(wfTextbookClaim.getId());
                    setUserId(wfTextbookClaim.getClaimUserId());
                    setUserType(2);
                }});
            }

            for (TextbookClaimUser textbookClaimUser : textbookClaimUserList) {
                textbookClaimUserMapper.insert(textbookClaimUser);
            }
        }
        return true;
    }

}