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.common.util.BeanUtil;
import com.imed.costaccount.constants.NumberConstant;
import com.imed.costaccount.common.enums.ErrorCodeEnum;
import com.imed.costaccount.mapper.ResponsibilityDepartmentMapper;
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 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;

import static com.imed.costaccount.common.constants.Constant.LIMIT;

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


    private final CostShareLevelServiceImpl costShareLevelService;
    private final ResponsibilityDepartmentMapper responsibilityDepartMapper;

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

    /**
     * 责任中心列表不分页
     *
     * @param user
     * @return
     */
    @Override
    public List<CostResponsibilityVO> getList(User user) {
        // 1. 获取所有的列表然后组装
        List<CostResponsibilityVO> costResponsibilityVOS = this.getCostResponsibilityVO(user);
        return costResponsibilityVOS.stream().filter(i -> i.getParentId() == 0)
                .peek(i -> i.setChild(this.getResponsibilityChildren(i, costResponsibilityVOS)))
                .collect(Collectors.toList());
//        List<CostResponsibilityVO> parentCostResponsibility = costResponsibilityVOS.stream()
//                .filter(i -> i.getParentId() == 0).collect(Collectors.toList());
//        // 多层结构
//        List<CostResponsibilityVO> all = new ArrayList<>();
//        // todo 试试多线程实现方式
//        for (CostResponsibilityVO parent : parentCostResponsibility) {
//            List<CostResponsibilityVO> children = this.getResponsibilityChildren(parent, costResponsibilityVOS);
//            all.addAll(children);
//        }
//        return all;
    }

    private List<CostResponsibilityVO> getCostResponsibilityVO(User user) {
        List<Responsibility> list = this.list(
                new LambdaQueryWrapper<Responsibility>()
                        .eq(Responsibility::getHospId, user.getHospId())
                        .orderByDesc(Responsibility::getCreateTime)
        );
        if (CollUtil.isEmpty(list)) {
            return Collections.emptyList();
        }
        // 拷贝组合
        List<CostResponsibilityVO> costResponsibilityVOS = BeanUtil.convertList(list, CostResponsibilityVO.class);
        return costResponsibilityVOS;
    }

    /**
     * 获取子层级
     *
     * @param parent                当前的
     * @param costResponsibilityVOS 所有的
     * @return
     */
    private List<CostResponsibilityVO> getResponsibilityChildren(CostResponsibilityVO parent, List<CostResponsibilityVO> costResponsibilityVOS) {
        return costResponsibilityVOS.stream().filter(o -> o.getParentId().equals(parent.getId()))
                .peek(o -> o.setChild(this.getResponsibilityChildren(o, costResponsibilityVOS)))
                .collect(Collectors.toList());
//        List<CostResponsibilityVO> list = new LinkedList<>();
//        list.add(parent);
//        for (CostResponsibilityVO costResponsibilityVO : costResponsibilityVOS) {
//            if (parent.getId().equals(costResponsibilityVO.getParentId())) {
//                List<CostResponsibilityVO> child = parent.getChild();
//                if (CollUtil.isEmpty(child)) {
//                    child = new ArrayList<>();
//                }
//                child.add(costResponsibilityVO);
//                parent.setChild(child);
//                this.getResponsibilityChildren(costResponsibilityVO, costResponsibilityVOS);
//            }
//        }
//        return list;
    }


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

        Responsibility center = BeanUtil.convertObj(responsibilitySaveDTO, Responsibility.class);
        center.setCreateTime(System.currentTimeMillis()).setId(null).setParentId(id).setHospId(user.getHospId());

        // 如果是汇总中心，那么不存在分摊级别
        Integer isGatherCenter = responsibilitySaveDTO.getIsGatherCenter();
        if (isGatherCenter == 1) {
            center.setShareLevel(0);
            center.setShareName("");
        }

        // 只允许存在一个默认中心
        if (responsibilitySaveDTO.getIsDefault() == 1) {
            this.checkIsDefault(user.getHospId());
        }
        this.save(center);
    }

    private void checkIsDefault(Long hospId) {
        Responsibility one = this.getOne(
                new LambdaQueryWrapper<Responsibility>()
                        .eq(Responsibility::getHospId, hospId)
                        .eq(Responsibility::getIsDefault, 1)
                        .last(LIMIT)
        );
        if (Objects.nonNull(one)) {
            throw new CostException("责任中心只能拥有一个默认责任中心");
        }
    }

    private void checkCode(String code, Long 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) {
        Long id = responsibilityEditDTO.getId();
        Responsibility center = this.getById(id);
        if (Objects.isNull(center)) {
            throw new CostException(ErrorCodeEnum.DATA_NOT_EXIST);
        }

        // 判断是否有子节点
        List<Responsibility> list = this.list(
                new LambdaQueryWrapper<Responsibility>()
                        .eq(Responsibility::getHospId, user.getHospId())
                        .eq(Responsibility::getParentId, id)
        );
        // 如果不存在子节点 ，修改它本身
        if (list.isEmpty()) {
            this.updateCurResp(center, responsibilityEditDTO, user);
            return;
        }

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


    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public void updateCurResp(Responsibility center, ResponsibilityEditDTO dto, User user) {
        // 删除
        Long id = dto.getId();
        this.removeById(id);
        // 校验code
        this.checkCode(dto.getResponsibilityCode(), user.getHospId());

        Responsibility newResponsibility = BeanUtil.convertObj(dto, Responsibility.class);
        newResponsibility.setId(null)
                .setHospId(user.getHospId())
                .setCreateTime(System.currentTimeMillis())
                .setParentId(dto.getParentId());
        // 如果变成了汇总中心 不存在分摊层级名称等
        if (dto.getIsGatherCenter() == 1) {
            newResponsibility.setShareId(null)
                    .setShareLevel(0)
                    .setShareName(null);
        }
        if (dto.getParentId() == 0) {
            // 永远为2的情况
            newResponsibility.setIsGatherCenter(2);
        }
        // 校验默认
        if (dto.getIsDefault() == 1) {
            this.checkIsDefault(user.getHospId());
        }

        this.save(newResponsibility);
    }

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

        // 删除原有的父节点数据
        Long 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(System.currentTimeMillis());

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

        this.save(newResponsibility);

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

    }

    /**
     * 修改当前的节点
     *
     * @param dto
     * @param responsibility
     * @param hospId
     */
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void updateCurrent(ResponsibilityEditDTO dto, Responsibility responsibility, Long hospId) {
        // 删除原有的父节点数据
        Long 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());
        // 暂时先这样处理
        if (dto.getIsGatherCenter() == 1) {
            newResponsibility.setShareId(null)
                    .setShareLevel(0)
                    .setShareName(null)
                    .setParentId(0L);
        }
        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);
        }
        Long 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) {
        List<CostResponsibilityVO> costResponsibilityVOS = this.getCostResponsibilityVO(user);
        List<CenterDepartmentVO> centerDepartmentVOS = costResponsibilityVOS.stream().map(i -> {
            CenterDepartmentVO vo = BeanUtil.convertObj(i, CenterDepartmentVO.class);
            vo.setResponsibilityId(i.getId());
            return vo;
        }).collect(Collectors.toList());

        return centerDepartmentVOS.stream().filter(i -> i.getParentId() == 0)
                .peek(i -> {
                    List<CenterDepartmentVO> responsibilityChildrenForRelation = this.getResponsibilityChildrenForRelation(i, centerDepartmentVOS);
                    if (CollUtil.isEmpty(responsibilityChildrenForRelation)) {
                        i.setDepartments(responsibilityDepartMapper.getDepartByCenterId(i.getResponsibilityId()));
                        i.setIsParent(false);
                        i.setDepartments(responsibilityDepartMapper.getDepartByCenterId(i.getResponsibilityId()));
                    }
                    i.setChild(responsibilityChildrenForRelation);
                    i.setIsParent(true);
                })
                .collect(Collectors.toList());

    }

    private List<CenterDepartmentVO> getResponsibilityChildrenForRelation(CenterDepartmentVO
                                                                                  parent, List<CenterDepartmentVO> costResponsibilityVOS) {
        return costResponsibilityVOS.stream().filter(o -> o.getParentId().equals(parent.getId()))
                .peek(o -> {
                    o.setIsParent(true);
                    List<CenterDepartmentVO> responsibilityChildrenForRelation = this.getResponsibilityChildrenForRelation(o, costResponsibilityVOS);
                    if (CollUtil.isEmpty(responsibilityChildrenForRelation)) {
                        o.setIsParent(false);
                        o.setDepartments(responsibilityDepartMapper.getDepartByCenterId(o.getResponsibilityId()));
                    }
                    o.setChild(responsibilityChildrenForRelation);

                })
                .collect(Collectors.toList());

    }


    @Override
    public List<CommonVO> getParentList(User user) {
        List<Responsibility> list = this.list(
                new LambdaQueryWrapper<Responsibility>().select(Responsibility::getId, Responsibility::getResponsibilityName)
                        .eq(Responsibility::getParentId, 0)
                        .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(Long hospId) {
        List<Responsibility> responsibilities = baseMapper.selectList(new QueryWrapper<Responsibility>().lambda()
                .eq(Responsibility::getHospId, hospId)
                .eq(Responsibility::getIsGatherCenter, NumberConstant.TWO)
                .ne(Responsibility::getShareId, NumberConstant.ZERO));
        List<CostResponsibilityLevelVO> costResponsibilityLevelVOS = BeanUtil.convertList(responsibilities, CostResponsibilityLevelVO.class);
        List<CostShareLevelVO> costShareLevelServiceAll = costShareLevelService.getAll(hospId);
        Map<Long, List<CostShareLevelVO>> listMap = costShareLevelServiceAll.stream().collect(Collectors.groupingBy(CostShareLevelVO::getId));
        // 设置责任中心的计算方式
        costResponsibilityLevelVOS.forEach(i -> {
            i.setResponsibilityId(i.getId());
            Long shareId = i.getShareId();
            List<CostShareLevelVO> costShareLevelVOList = listMap.get(shareId);
            if (!CollectionUtils.isEmpty(costShareLevelVOList)) {
                i.setCalcType(costShareLevelVOList.get(0).getCalcType());
            }
        });
        return costResponsibilityLevelVOS;
    }

    /**
     * 责任中心在收入归集设置里面显示的列表
     *
     * @param user
     * @return
     */
    @Override
    public List<CostResponsibilityVO> responsibilityList(User user) {
        // 1. 获取所有的列表然后组装
        List<CostResponsibilityVO> costResponsibilityVOS = this.getCostResponsibilityVO(user);
        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<>();
                }
                j.setResponsibilityName(i.getResponsibilityName() + "/" + j.getResponsibilityName());
                child.add(j);
                i.setChild(child);
            }
        }));
        return parentCostResponsibility;
    }


    /**
     * 通过分摊级别id得到所有的责任中心
     *
     * @param levelId 分摊级别id
     * @param hospId  医院id
     * @return 责任中心
     */
    @Override
    public List<Responsibility> getByLevelIds(List<Long> levelId, Long hospId) {
        List<Responsibility> list = this.list(
                new LambdaQueryWrapper<Responsibility>()
                        .in(Responsibility::getShareId, levelId)
                        .eq(Responsibility::getHospId, hospId)
        );
        if (list.isEmpty()) {
            throw new CostException("责任中心未分配正确的分摊层级");
        }
        return list;
    }

    /**
     * 通过分摊层级列表得到对应的责任中心
     *
     * @param levelId 分摊层级id
     * @param hospId  医院id
     * @return 责任中心 可能存在null
     */
    @Override
    public List<Responsibility> getByLevelId(Long levelId, Long hospId) {
        return this.list(
                new LambdaQueryWrapper<Responsibility>()
                        .in(Responsibility::getShareId, levelId)
                        .eq(Responsibility::getHospId, hospId)
        );
    }

    /**
     * 通过code得到名字
     *
     * @param valueResponsibilityCode
     * @param hospId
     * @return
     */
    @Override
    public String getByCode(String valueResponsibilityCode, Long hospId) {
        Responsibility one = this.getOne(
                new LambdaQueryWrapper<Responsibility>()
                        .eq(Responsibility::getResponsibilityCode, valueResponsibilityCode)
                        .eq(Responsibility::getHospId, hospId)
                        .last(LIMIT)
        );
        if (Objects.isNull(one)) {
            throw new CostException("数据异常");
        }
        return one.getResponsibilityName();
    }
}