kcim-cost/src/main/java/com/imed/costaccount/service/impl/ResponsibilityServiceImpl.java

package com.imed.costaccount.service.impl;

import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.imed.costaccount.common.exception.CostException;
import com.imed.costaccount.constants.NumberConstant;
import com.imed.costaccount.enums.ErrorCodeEnum;
import com.imed.costaccount.mapper.ResponsibilityMapper;
import com.imed.costaccount.model.Responsibility;
import com.imed.costaccount.model.User;
import com.imed.costaccount.model.dto.ResponsibilityEditDTO;
import com.imed.costaccount.model.dto.ResponsibilitySaveDTO;
import com.imed.costaccount.model.vo.*;
import com.imed.costaccount.service.ResponsibilityService;
import com.imed.costaccount.utils.BeanUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.stream.Collectors;

@Slf4j
@Service("responsibilityService")
public class ResponsibilityServiceImpl extends ServiceImpl<ResponsibilityMapper, Responsibility> implements ResponsibilityService {


    private final CostShareLevelServiceImpl costShareLevelService;

    public ResponsibilityServiceImpl(CostShareLevelServiceImpl costShareLevelService) {
        this.costShareLevelService = costShareLevelService;
    }

    /**
     * 责任中心列表不分页
     *
     * @param user
     * @return
     */
    @Override
    public List<CostResponsibilityVO> getList(User user) {
        // 1. 获取所有的列表然后组装
        List<Responsibility> list = this.list(
                new LambdaQueryWrapper<Responsibility>()
                        .eq(Responsibility::getHospId, user.getHospId())
        );
        if (CollUtil.isEmpty(list)) {
            return Collections.emptyList();
        }
        // 拷贝组合
        List<CostResponsibilityVO> costResponsibilityVOS = BeanUtil.convertList(list, CostResponsibilityVO.class);
        List<CostResponsibilityVO> parentCostResponsibility = costResponsibilityVOS.stream()
                .filter(i -> i.getResponsibilityLevel().equals(1)).collect(Collectors.toList());

        parentCostResponsibility.forEach(i -> costResponsibilityVOS.forEach(j -> {
            if (j.getParentId().equals(i.getId())) {
                if (i.getResponsibilityLevel() == 1) {
                    i.setShareLevel(null);
                }
                List<CostResponsibilityVO> child = i.getChild();
                if (CollUtil.isEmpty(child)) {
                    child = new ArrayList<>();
                }
                child.add(j);
                i.setChild(child);
            }
        }));
        return parentCostResponsibility;
    }


    /**
     * 新增责任中心
     *
     * @param responsibilitySaveDTO {@link ResponsibilitySaveDTO }
     * @param user
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void addResponsibilityCenter(ResponsibilitySaveDTO responsibilitySaveDTO, User user) {
        // 如果是一级分类parentId为0
        Integer id = responsibilitySaveDTO.getId();
        if (Objects.isNull(id)) {
            id = 0;
        }
        checkCode(responsibilitySaveDTO.getResponsibilityCode(), user.getHospId());

        Responsibility center = BeanUtil.convertObj(responsibilitySaveDTO, Responsibility.class);
        center.setCreateTime(System.currentTimeMillis()).setId(null).setParentId(id).setHospId(user.getHospId()).setResponsibilityLevel(2);
        if (id == 0) {
            center.setResponsibilityLevel(1);
        }

        // 如果是汇总中心，那么不存在分摊级别
        Integer isGatherCenter = responsibilitySaveDTO.getIsGatherCenter();
        if (isGatherCenter == 1) {
            center.setShareLevel(0);
            center.setShareName("");
        }
        // 父节点不允许为非汇总中心
        Responsibility byId = this.getById(id);
        if (Objects.nonNull(byId) && (byId.getIsGatherCenter() == 2)) {
            throw new CostException(500, "非汇总中心不允许添加");
        }

        this.save(center);
    }

    private void checkCode(String code, Integer hospId) {
        // 校验责任代码唯一性
        Responsibility one = this.getOne(
                new LambdaQueryWrapper<Responsibility>().select(Responsibility::getId)
                        .eq(Responsibility::getResponsibilityCode, code)
                        .eq(Responsibility::getHospId, hospId).last("limit 1")
        );
        if (Objects.nonNull(one)) {
            throw new CostException(ErrorCodeEnum.RESPONSIBILITY_CODE_EXIST);
        }
    }


    /**
     * 编辑责任中心
     *
     * @param responsibilityEditDTO {@link ResponsibilityEditDTO}
     * @param user
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void editResponsibility(ResponsibilityEditDTO responsibilityEditDTO, User user) {
        Integer id = responsibilityEditDTO.getId();
        Responsibility center = this.getById(id);
        if (Objects.isNull(center)) {
            throw new CostException(ErrorCodeEnum.DATA_NOT_EXIST);
        }
        // 如果修改父节点节点（只有两层的情况）
        if (center.getResponsibilityLevel() == 1) {
            this.updateParent(responsibilityEditDTO, center, user.getHospId());
            return;
        }

        this.updateCurrent(responsibilityEditDTO, center, user.getHospId());
    }

    /**
     * 修的是父节点
     *
     * @param dto
     * @param responsibility
     * @param hospId
     */
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void updateParent(ResponsibilityEditDTO dto, Responsibility responsibility, Integer hospId) {

        // 删除原有的父节点数据
        Integer id = dto.getId();
        this.removeById(id);
        List<Responsibility> child = this.list(new QueryWrapper<Responsibility>().lambda().eq(Responsibility::getParentId, id));
        // 如果修改是否汇总中心 从是 -》 否那么子节点直接删除
        if (responsibility.getIsGatherCenter() == 1 && dto.getIsGatherCenter() == 2) {
            this.removeByIds(child.stream().map(Responsibility::getId).collect(Collectors.toList()));
            return;
        }

        this.checkCode(dto.getResponsibilityCode(), hospId);
        // 新增父节点数据
        Responsibility newResponsibility = BeanUtil.convertObj(dto, Responsibility.class);
        newResponsibility.setId(null).setHospId(responsibility.getHospId()).setCreateTime(new Date().getTime()).setResponsibilityLevel(1);
        this.save(newResponsibility);

        // 将原来所有父节点下数据关联到新的父节点下
        child.forEach(i -> i.setParentId(newResponsibility.getId()));
        this.updateBatchById(child);

    }

    /**
     * 修改当前的节点
     *
     * @param dto
     * @param responsibility
     * @param hospId
     */
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void updateCurrent(ResponsibilityEditDTO dto, Responsibility responsibility, Integer hospId) {
        // 删除原有的父节点数据
        Integer id = dto.getId();
        this.removeById(id);

        this.checkCode(dto.getResponsibilityCode(), hospId);

        Responsibility newResponsibility = BeanUtil.convertObj(dto, Responsibility.class);
        newResponsibility.setId(null)
                .setHospId(responsibility.getHospId())
                .setCreateTime(System.currentTimeMillis())
                .setParentId(dto.getParentId())
                .setResponsibilityLevel(2);
        // 暂时先这样处理
        if (dto.getIsGatherCenter() == 1) {
            newResponsibility.setShareId(null)
                    .setShareLevel(0)
                    .setShareName(null)
                    .setParentId(0)
                    .setResponsibilityLevel(1);
        }
        this.save(newResponsibility);
    }


    /**
     * 删除责任中心
     *
     * @param id
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void deleteCenter(Integer id) {
        Responsibility center = this.getById(id);
        if (Objects.isNull(center)) {
            throw new CostException(ErrorCodeEnum.DATA_NOT_EXIST);
        }
        Integer parentId = center.getParentId();
        if (parentId == 0) {
            this.deleteAllSonCenter(id);
            return;
        }
        this.removeById(id);
    }

    /**
     * 删除父节点以及所有子节点责任中心
     *
     * @param id
     */
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void deleteAllSonCenter(Integer id) {
        this.removeById(id);
        this.remove(new LambdaQueryWrapper<Responsibility>().eq(Responsibility::getParentId, id));
    }

    /**
     * 获取部门树列表
     *
     * @param user
     * @return
     */
    @Override
    public List<CenterDepartmentVO> getParentSon(User user) {
        // 1. 获取所有的列表然后组装
        List<Responsibility> parentList = this.list(
                new LambdaQueryWrapper<Responsibility>()
                        .eq(Responsibility::getHospId, user.getHospId())
                        .eq(Responsibility::getParentId, 0)
        );
        if (CollUtil.isEmpty(parentList)) {
            throw new CostException(ErrorCodeEnum.DATA_NOT_EXIST);
        }
        List<Responsibility> sonList = this.list(
                new LambdaQueryWrapper<Responsibility>()
                        .eq(Responsibility::getHospId, user.getHospId())
                        .ne(Responsibility::getParentId, 0)
        );
        List<CenterDepartmentVO> list = new ArrayList<>();
        // 拷贝组合
        for (Responsibility parent : parentList) {
            CenterDepartmentVO centerDepartmentVO = new CenterDepartmentVO();
            centerDepartmentVO.setResponsibilityId(parent.getId());
            centerDepartmentVO.setResponsibilityName(parent.getResponsibilityName());
            centerDepartmentVO.setIsParent(true);
            for (Responsibility son : sonList) {
                CenterDepartmentVO sonVO = new CenterDepartmentVO();
                if (parent.getId().equals(son.getParentId())) {
                    sonVO.setResponsibilityId(son.getId());
                    sonVO.setResponsibilityName(son.getResponsibilityName());
                    sonVO.setIsParent(false);
                    List<CenterDepartmentVO> child = centerDepartmentVO.getChild();
                    if (CollUtil.isEmpty(child)) {
                        child = new ArrayList<>();
                    }
                    child.add(sonVO);
                    centerDepartmentVO.setChild(child);
                }
            }
            list.add(centerDepartmentVO);
        }
        return list;
    }


    @Override
    public List<CommonVO> getParentList(User user) {
        List<Responsibility> list = this.list(
                new LambdaQueryWrapper<Responsibility>().select(Responsibility::getId, Responsibility::getResponsibilityName)
                        .eq(Responsibility::getResponsibilityLevel, 1)
                        .eq(Responsibility::getHospId, user.getHospId())
        );
        return list.stream().map(i -> {
            CommonVO commonVO = new CommonVO();
            commonVO.setId(i.getId());
            commonVO.setName(i.getResponsibilityName());
            return commonVO;
        }).collect(Collectors.toList());
    }

    /**
     * 获取可不是汇总中心列表
     *
     * @param hospId
     * @return
     */
    @Override
    public List<CostResponsibilityLevelVO> getLevelTwo(Integer hospId) {
        List<Responsibility> responsibilities = baseMapper.selectList(new QueryWrapper<Responsibility>().lambda()
                .eq(Responsibility::getHospId, hospId)
                .eq(Responsibility::getIsGatherCenter, NumberConstant.TWO));
        List<CostResponsibilityLevelVO> costResponsibilityLevelVOS = BeanUtil.convertList(responsibilities, CostResponsibilityLevelVO.class);
        List<CostShareLevelVO> costShareLevelServiceAll = costShareLevelService.getAll(hospId);
        Map<Integer, List<CostShareLevelVO>> listMap = costShareLevelServiceAll.stream().collect(Collectors.groupingBy(CostShareLevelVO::getId));
        // 设置责任中心的计算方式
        costResponsibilityLevelVOS.forEach(i -> {
            i.setResponsibilityId(i.getId());
            Integer shareLevel = i.getShareLevel();
            List<CostShareLevelVO> costShareLevelVOList = listMap.get(shareLevel);
            if (!CollectionUtils.isEmpty(costShareLevelVOList)) {
                i.setCalcType(costShareLevelVOList.get(0).getCalcType());
            }
        });
        return costResponsibilityLevelVOS;
    }
}