gunshi-project-ss/src/main/java/com/gunshi/project/ss/service/DocCenterService.java

package com.gunshi.project.ss.service;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.gunshi.project.ss.entity.so.DocCenterPageSo;
import com.gunshi.project.ss.mapper.DocCenterMapper;
import com.gunshi.project.ss.model.DocCategory;
import com.gunshi.project.ss.model.DocCenter;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.mapper.SysUserMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

@Service
@Slf4j
@Transactional(rollbackFor = Exception.class)
public class DocCenterService  extends ServiceImpl<DocCenterMapper, DocCenter> {

    @Autowired
    private DocCategoryService docCategoryService;

    @Autowired
    private SysUserMapper sysUserMapper;

    @Autowired
    private DocOperateLogService docOperateLogService;

    public Page<DocCenter> pageInfo(DocCenterPageSo pageSo){
        LambdaQueryWrapper<DocCenter> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(DocCenter::getDocCategoryId,pageSo.getDocCategoryId());
        if(StringUtils.isNotEmpty(pageSo.getDocName())){
            queryWrapper.like(DocCenter::getDocName,pageSo.getDocName());
        }
        if(pageSo.getSecretLevel() != null){
            queryWrapper.eq(DocCenter::getSecretLevel,pageSo.getSecretLevel());
        }
        queryWrapper.orderByDesc(DocCenter::getCreateTime);
        Page<DocCenter> docCenterPage = this.baseMapper.selectPage(pageSo.getPageSo().toPage(), queryWrapper);
        for (DocCenter record : docCenterPage.getRecords()) {
            if(record.getUserId() != null){
                SysUser sysUser = sysUserMapper.selectUserById(record.getUserId());
                if(sysUser != null){
                    record.setUserName(sysUser.getNickName());
                }
            }
            List<DocCategory> categoryPathRecursive = docCategoryService.findCategoryPathRecursive(record.getDocCategoryId());
            List<String> categoryCodes = new ArrayList<>();
            for (DocCategory docCategory : categoryPathRecursive) {
                categoryCodes.add(docCategory.getCategoryCode());
            }
            categoryCodes.add(record.getDocNumber());
            record.setCategoryCodes(categoryCodes);
        }
        return docCenterPage;
    }

    public boolean saveData(DocCenter docCenter) {
        if(StringUtils.isBlank(docCenter.getBusinessName())){
            throw new IllegalArgumentException("请传业务名称");
        }
        Long count = lambdaQuery().eq(DocCenter::getDocCategoryId, docCenter.getDocCategoryId()).count();
        count++;
        // 将 count 转换为字符串，前面补0，保持至少4位数字
        String countStr = String.format("%04d", count);
        docCenter.setDocNumber(countStr);
        LocalDateTime now = LocalDateTime.now();
        docCenter.setCreateTime(now);
        if(docCenter.getReplaceId() !=  null){
            //如果替换档案ID不为null，废弃原档案
            DocCenter one = lambdaQuery().eq(DocCenter::getId, docCenter.getReplaceId()).one();
            if(one == null){
                throw new IllegalArgumentException("对不起，被替换的档案ID不存在");
            }
            //获取同一组有多少个版本
            List<DocCenter> list = lambdaQuery().eq(DocCenter::getGroupId, one.getGroupId())
                    .orderByDesc(DocCenter::getDocVersion)
                    .list();
            //设置分组id
            docCenter.setGroupId(one.getGroupId());
            docCenter.setDocVersion(new BigDecimal(list.size()).add(BigDecimal.ONE));
            //设置状态为已废除
            one.setIsAbolish(1);
            //设置废止时间（为替换档案的新增时间）
            one.setAbolishTime(now);
            updateById(one);
        }else{
            docCenter.setGroupId(IdWorker.getId());
            docCenter.setDocVersion(BigDecimal.ONE);
            docCenter.setIsAbolish(0);
            docCenter.setAbolishTime(null);
        }
        boolean save = this.save(docCenter);
        docOperateLogService.saveLog(docCenter,1);
        return save;
    }

    public DocCenter deleteById(Integer id) {
        DocCenter center = this.baseMapper.selectById(id);
        if(center == null) return null;
        //根据组id查询版本号比他大的数据,然后这些数据的版本全部降1
        List<DocCenter> versionGe = lambdaQuery().eq(DocCenter::getGroupId, center.getGroupId())
                .ge(DocCenter::getDocVersion,center.getDocVersion().add(BigDecimal.ONE))
                .orderByAsc(DocCenter::getDocVersion)
                .list();
        for (DocCenter docCenter : versionGe) {
            docCenter.setDocVersion( docCenter.getDocVersion().subtract(BigDecimal.ONE) );
        }
        //如果删除的版本为第一版
        if(center.getDocVersion().compareTo(BigDecimal.ONE) == 0 && versionGe.size() > 0){
            //那么第二版的替换版本设置为空
            DocCenter second = versionGe.get(0);
            second.setReplaceId(null);
        }
        //查询版本比它小的数据
        List<DocCenter> versionLe = lambdaQuery().eq(DocCenter::getGroupId, center.getGroupId())
                .le(DocCenter::getDocVersion, center.getDocVersion().subtract(BigDecimal.ONE))
                .orderByDesc(DocCenter::getDocVersion).list();
        //如果是中间版本
        if(versionLe.size() > 0 && versionGe.size() > 0){
            //第一个必它大的版本
            DocCenter versionBig1 = versionGe.get(0);
            //第一个比它小的版本
            DocCenter versionSmall1 = versionLe.get(0);
            versionBig1.setReplaceId(versionSmall1.getId());
        } else if(versionLe.size() > 0){
            //如果删除的是最新的版本的数据
            DocCenter versionSmall1 = versionLe.get(0);
            versionSmall1.setIsAbolish(0);
            versionSmall1.setAbolishTime(null);
        }
        removeById(id);
        if(versionGe.size() > 0){
            updateBatchById(versionGe);
        }
        if(versionLe.size() > 0){
            updateBatchById(versionLe);
        }
        docOperateLogService.saveLog(center,3);
        return center;
    }

    public boolean updateData(DocCenter docCenter) {
        DocCenter one = lambdaQuery().eq(DocCenter::getId, docCenter.getId()).one();
        if(one == null){
            return false;
        }
        //获取替换id
        LocalDateTime now = LocalDateTime.now();
        if(docCenter.getReplaceId() !=  null){
            //如果替换档案ID不为null，废弃原档案
            DocCenter replaceOne = lambdaQuery().eq(DocCenter::getId, docCenter.getReplaceId()).one();
            if(replaceOne == null){
                throw new IllegalArgumentException("对不起，被替换的档案ID不存在");
            }
            //获取同一组有多少个版本
            List<DocCenter> list = lambdaQuery().eq(DocCenter::getGroupId, replaceOne.getGroupId())
                    .orderByDesc(DocCenter::getDocVersion)
                    .list();
            //设置分组id
            docCenter.setGroupId(replaceOne.getGroupId());
            docCenter.setDocVersion(new BigDecimal(list.size()).add(BigDecimal.ONE));
            //设置状态为已废除
            replaceOne.setIsAbolish(1);
            //设置废止时间（为替换档案的新增时间）
            replaceOne.setAbolishTime(now);
            updateById(replaceOne);
        }
        boolean flag = updateById(docCenter);
        docOperateLogService.saveLog(docCenter,2);
        return flag;
    }
}