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

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

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.xjrsoft.common.exception.MyException;
import com.xjrsoft.module.base.entity.BaseClass;
import com.xjrsoft.module.base.service.IBaseClassService;
import com.xjrsoft.module.textbook.dto.AddTextbookClassWarehouseDto;
import com.xjrsoft.module.textbook.dto.TextbookPageDto;
import com.xjrsoft.module.textbook.entity.*;
import com.xjrsoft.module.textbook.mapper.TextbookClassRelationMapper;
import com.xjrsoft.module.textbook.mapper.TextbookMapper;
import com.xjrsoft.module.textbook.mapper.TextbookSubscriptionRecordMapper;
import com.xjrsoft.module.textbook.service.ITextbookClassWarehouseService;
import com.xjrsoft.module.textbook.service.ITextbookService;
import com.xjrsoft.module.textbook.service.IWfTextbookSubscriptionService;
import com.xjrsoft.module.textbook.vo.*;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * @title: 教材管理
 * @Author szs
 * @Date: 2023-12-25
 * @Version 1.0
 */
@Service
@AllArgsConstructor
public class TextbookServiceImpl extends MPJBaseServiceImpl<TextbookMapper, Textbook> implements ITextbookService {
    private final TextbookMapper textbookTextbookMapper;

    private final TextbookClassRelationMapper textbookTextbookClassRelationMapper;
    private final TextbookSubscriptionRecordMapper textbookTextbookSubscriptionRecordMapper;

    private final IWfTextbookSubscriptionService iWfTextbookSubscriptionService;

    private final IBaseClassService baseClassService;

    private final ITextbookClassWarehouseService textbookClassWarehouseService;


    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean add(Textbook textbook) {
        textbookTextbookMapper.insert(textbook);
        for (TextbookClassRelation textbookClassRelation : textbook.getTextbookClassRelationList()) {
            textbookClassRelation.setTextbookId(textbook.getId());
            textbookTextbookClassRelationMapper.insert(textbookClassRelation);
        }
        if (textbook.getTextbookSubscriptionRecordList() != null) {
            for (TextbookSubscriptionRecord textbookSubscriptionRecord : textbook.getTextbookSubscriptionRecordList()) {
                textbookSubscriptionRecord.setWfTextbookSubscriptionId(textbook.getId());
                textbookTextbookSubscriptionRecordMapper.insert(textbookSubscriptionRecord);
            }
        }


        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean update(Textbook textbook) {
        textbookTextbookMapper.updateById(textbook);
        //********************************* TextbookClassRelation  增删改  开始 *******************************************/
        {
            // 查出所有子级的id
            List<TextbookClassRelation> textbookClassRelationList = textbookTextbookClassRelationMapper.selectList(Wrappers.lambdaQuery(TextbookClassRelation.class).eq(TextbookClassRelation::getTextbookId, textbook.getId()).select(TextbookClassRelation::getId));
            List<Long> textbookClassRelationIds = textbookClassRelationList.stream().map(TextbookClassRelation::getId).collect(Collectors.toList());
            //原有子表单 没有被删除的主键
            List<Long> textbookClassRelationOldIds = textbook.getTextbookClassRelationList().stream().map(TextbookClassRelation::getId).filter(Objects::nonNull).collect(Collectors.toList());
            //找到需要删除的id
            List<Long> textbookClassRelationRemoveIds = textbookClassRelationIds.stream().filter(item -> !textbookClassRelationOldIds.contains(item)).collect(Collectors.toList());

            for (TextbookClassRelation textbookClassRelation : textbook.getTextbookClassRelationList()) {
                //如果不等于空则修改
                if (textbookClassRelation.getId() != null) {
                    textbookTextbookClassRelationMapper.updateById(textbookClassRelation);
                }
                //如果等于空 则新增
                else {
                    //已经不存在的id 删除
                    textbookClassRelation.setTextbookId(textbook.getId());
                    textbookTextbookClassRelationMapper.insert(textbookClassRelation);
                }
            }
            //已经不存在的id 删除
            if (textbookClassRelationRemoveIds.size() > 0) {
                textbookTextbookClassRelationMapper.deleteBatchIds(textbookClassRelationRemoveIds);
            }
        }
        //********************************* TextbookClassRelation  增删改  结束 *******************************************/

        //********************************* TextbookSubscriptionRecord  增删改  开始 *******************************************/
        {
            // 查出所有子级的id
            List<TextbookSubscriptionRecord> textbookSubscriptionRecordList = textbookTextbookSubscriptionRecordMapper.selectList(Wrappers.lambdaQuery(TextbookSubscriptionRecord.class).eq(TextbookSubscriptionRecord::getWfTextbookSubscriptionId, textbook.getId()).select(TextbookSubscriptionRecord::getId));
            List<Long> textbookSubscriptionRecordIds = textbookSubscriptionRecordList.stream().map(TextbookSubscriptionRecord::getId).collect(Collectors.toList());
            //原有子表单 没有被删除的主键
            if (!textbookSubscriptionRecordIds.isEmpty()) {
                List<Long> textbookSubscriptionRecordOldIds = textbook.getTextbookSubscriptionRecordList().stream().map(TextbookSubscriptionRecord::getId).filter(Objects::nonNull).collect(Collectors.toList());
                //找到需要删除的id
                List<Long> textbookSubscriptionRecordRemoveIds = textbookSubscriptionRecordIds.stream().filter(item -> !textbookSubscriptionRecordOldIds.contains(item)).collect(Collectors.toList());

                for (TextbookSubscriptionRecord textbookSubscriptionRecord : textbook.getTextbookSubscriptionRecordList()) {
                    //如果不等于空则修改
                    if (textbookSubscriptionRecord.getId() != null) {
                        textbookTextbookSubscriptionRecordMapper.updateById(textbookSubscriptionRecord);
                    }
                    //如果等于空 则新增
                    else {
                        //已经不存在的id 删除
                        textbookSubscriptionRecord.setWfTextbookSubscriptionId(textbook.getId());
                        textbookTextbookSubscriptionRecordMapper.insert(textbookSubscriptionRecord);
                    }
                }
                //已经不存在的id 删除
                if (textbookSubscriptionRecordRemoveIds.size() > 0) {
                    textbookTextbookSubscriptionRecordMapper.deleteBatchIds(textbookSubscriptionRecordRemoveIds);
                }
                for (TextbookSubscriptionRecord textbookSubscriptionRecord : textbook.getTextbookSubscriptionRecordList()) {
                    //如果不等于空则修改
                    if (textbookSubscriptionRecord.getId() != null) {
                        textbookTextbookSubscriptionRecordMapper.updateById(textbookSubscriptionRecord);
                    }
                    //如果等于空 则新增
                    else {
                        //已经不存在的id 删除
                        textbookSubscriptionRecord.setWfTextbookSubscriptionId(textbook.getId());
                        textbookTextbookSubscriptionRecordMapper.insert(textbookSubscriptionRecord);
                    }
                }
                //已经不存在的id 删除
                if (textbookSubscriptionRecordRemoveIds.size() > 0) {
                    textbookTextbookSubscriptionRecordMapper.deleteBatchIds(textbookSubscriptionRecordRemoveIds);
                }


            }
            //********************************* TextbookSubscriptionRecord  增删改  结束 *******************************************/

            return true;
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean delete(List<Long> ids) {
        textbookTextbookMapper.deleteBatchIds(ids);
        textbookTextbookClassRelationMapper.delete(Wrappers.lambdaQuery(TextbookClassRelation.class).in(TextbookClassRelation::getTextbookId, ids));
        textbookTextbookSubscriptionRecordMapper.delete(Wrappers.lambdaQuery(TextbookSubscriptionRecord.class).in(TextbookSubscriptionRecord::getWfTextbookSubscriptionId, ids));

        return true;
    }

    @Override
    public Page<TextbookPageVo> getPage(Page<TextbookPageDto> page, TextbookPageDto dto) {
        return textbookTextbookMapper.getPage(page, dto);
    }

    @Override
    public Boolean dataHandle(Long dataId) {
        WfTextbookSubscription wfTextbookSubscription = iWfTextbookSubscriptionService.selectById(dataId);
        if (ObjectUtil.isNotNull(wfTextbookSubscription) && ObjectUtil.isNotNull(wfTextbookSubscription.getWfTextbookSubscriptionItemList()) && wfTextbookSubscription.getWfTextbookSubscriptionItemList().size() > 0) {
            for (WfTextbookSubscriptionItem wfTextbookSubscriptionItem : wfTextbookSubscription.getWfTextbookSubscriptionItemList()) {
                String issn = wfTextbookSubscriptionItem.getIssn();
                Long semesterId = wfTextbookSubscription.getBaseSemesterId();
                Long subjectGroupId = wfTextbookSubscription.getSubjectGroupId();
                LambdaQueryWrapper<Textbook> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper
                        .eq(Textbook::getIssn, issn)
                        .eq(Textbook::getBaseSemesterId, semesterId)
                        .eq(Textbook::getSubjectGroupId, subjectGroupId);
                Long count = this.count(queryWrapper);
                if (count <= 0) {//该书不存在教材管理
                    Textbook textbook = new Textbook();
                    textbook.setIssn(wfTextbookSubscriptionItem.getIssn());
                    textbook.setIsbn(wfTextbookSubscriptionItem.getIsbn());
                    textbook.setBookName(wfTextbookSubscriptionItem.getBookName());
                    textbook.setPublishingHouse(wfTextbookSubscriptionItem.getPublishingHouse());
                    textbook.setEditorInChief(wfTextbookSubscriptionItem.getEditorInChief());
                    textbook.setSubjectGroupId(wfTextbookSubscription.getSubjectGroupId());
                    textbook.setBaseSemesterId(wfTextbookSubscription.getBaseSemesterId());
                    textbook.setCourseSubjectId(wfTextbookSubscriptionItem.getCourseSubjectId());
                    textbook.setVersion(wfTextbookSubscriptionItem.getVersion());
                    textbook.setIsTextbookPlan(wfTextbookSubscriptionItem.getIsTextbookPlan());
                    textbook.setTextbookType(wfTextbookSubscriptionItem.getSubscriptionType());
                    textbook.setAppraisalPrice(wfTextbookSubscriptionItem.getAppraisalPrice());
                    textbookTextbookMapper.insert(textbook);
                    if (ObjectUtil.isNotNull(wfTextbookSubscriptionItem.getClassIds()) && !wfTextbookSubscriptionItem.getClassIds().equals("")) {
                        String classIds = wfTextbookSubscriptionItem.getClassIds();
                        String[] classIdStrs = classIds.split(",");
                        List<Long> classIdList = new ArrayList<>();
                        for (String classIdStr : classIdStrs) {
                            Long classId = Long.parseLong(classIdStr);
                            classIdList.add(classId);
                            TextbookClassRelation textbookClassRelation = new TextbookClassRelation();
                            textbookClassRelation.setTextbookId(textbook.getId());
                            textbookClassRelation.setClassId(classId);
                            textbookTextbookClassRelationMapper.insert(textbookClassRelation);
                        }
                        //查询年级
                        LambdaQueryWrapper<BaseClass> queryWrapper1 = new LambdaQueryWrapper<>();
                        queryWrapper1
                                .in(BaseClass::getId, classIdList)
                                .groupBy(BaseClass::getGradeId);
                        List<BaseClass> baseClassList = baseClassService.list(queryWrapper1);
                        if (ObjectUtil.isNotNull(baseClassList) && baseClassList.size() == 1) {
                            textbook.setGradeId(baseClassList.get(0).getGradeId());
                        }
                    }
                    TextbookSubscriptionRecord textbookSubscriptionRecord = new TextbookSubscriptionRecord();
                    textbookSubscriptionRecord.setWfTextbookSubscriptionId(textbook.getId());
                    textbookSubscriptionRecord.setWfTextbookSubscriptionId(wfTextbookSubscription.getId());
                    textbookTextbookSubscriptionRecordMapper.insert(textbookSubscriptionRecord);
                }
            }
        }
        return true;
    }

    @Override
    public List<TextbookSubscriptionRecordVo> subscriptionList(Long id) {
        List<TextbookSubscriptionRecordVo> recordVos = textbookTextbookMapper.subscriptionList(id);
        for (TextbookSubscriptionRecordVo recordVo : recordVos) {
            if(ObjectUtil.isNull(recordVo) || StrUtil.isEmpty(recordVo.getClassIds())){
                continue;
            }
            String[] split = recordVo.getClassIds().split(",");
            List<String> ids = new ArrayList<>();
            for (String classId : split) {
                ids.add(classId.trim());
            }
            List<TextbookSubscriptionClassVo> classInfo = textbookTextbookMapper.getClassInfo(ids);
            String useClass = "";
            for (int i = 0; i < classInfo.size(); i ++){
                if(i >= 1){
                    useClass += ",";
                }
                TextbookSubscriptionClassVo classVo = classInfo.get(i);
                useClass += classVo.getName();
            }
            recordVo.setUseClass(useClass);
        }
        return recordVos;
    }

    @Override
    public TextbookVo getInfoByissn(String issn) {
        return textbookTextbookMapper.getInfoByissn(issn);
    }

    @Override
    public List<TextbookClassWarehouseListVo> warehouseList(Long id) {
        List<TextbookClassWarehouseListVo> result = textbookTextbookMapper.warehouseList(id);
        if(!result.isEmpty()){
            return result;
        }
        return new ArrayList<>();
    }

    @Override
    public List<TextbookClassRelation> getClassRelation(Long id) {
        List<TextbookClassRelation> classRelation = textbookTextbookMapper.getClassRelation(id);
        if(!classRelation.isEmpty()){
            return classRelation;
        }
        return new ArrayList<>();
    }

    @Override
    public List<TextbookIssueRecordListVo> issueList(Long id) {
        List<TextbookIssueRecordListVo> result = textbookTextbookMapper.issueList(id);
        if(!result.isEmpty()){
            return result;
        }
        return new ArrayList<>();
    }

    @Override
    @Transactional
    public Boolean deliverWarehouse(AddTextbookClassWarehouseDto dto) {
        //根据id获取教材管理记录
        Textbook textbook = this.getById(dto.getTextbookId());
        if (ObjectUtil.isNull(textbook)) {
            throw new MyException("入库失败，该教材不存在");
        }

        //更新总的库存数量
        Textbook updateTextbook = new Textbook();
        updateTextbook.setId(dto.getTextbookId());
        Integer oldStock = ObjectUtil.isNull(textbook.getStock()) ? 0 : textbook.getStock();
        updateTextbook.setStock(oldStock + dto.getWarehouseNumber());
        boolean isSuccess = this.updateById(updateTextbook);

        TextbookClassWarehouse textbookClassWarehouse = BeanUtil.toBean(dto, TextbookClassWarehouse.class);
        isSuccess = textbookClassWarehouseService.save(textbookClassWarehouse);

        return isSuccess;
    }


}