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

package com.imed.costaccount.service.impl;

import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.druid.util.StringUtils;
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.*;
import com.imed.costaccount.constants.NumberConstant;
import com.imed.costaccount.enums.DateStyleEnum;
import com.imed.costaccount.mapper.CostCostingGroupMapper;
import com.imed.costaccount.model.*;
import com.imed.costaccount.model.dto.StartDTO;
import com.imed.costaccount.model.vo.AllocationVO;
import com.imed.costaccount.model.vo.CostingGroupStartVO;
import com.imed.costaccount.model.vo.IncomeErrorMessage;
import com.imed.costaccount.service.*;
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 org.springframework.web.multipart.MultipartFile;

import java.math.BigDecimal;
import java.util.*;


@Service("costCostingGroupService")
@Slf4j
public class CostCostingGroupServiceImpl extends ServiceImpl<CostCostingGroupMapper, CostCostingGroup> implements CostCostingGroupService {

    private final CostIncomeGroupServiceImpl costIncomeGroupService;

    private final AccountingProductService accountingProductService;

    private final CostIncomeFileService costIncomeFileService;

    private final ResponsibilityService responsibilityService;

    private final CostCostingCollectionService costingCollectionService;

    public CostCostingGroupServiceImpl(CostIncomeGroupServiceImpl costIncomeGroupService,
                                       AccountingProductService accountingProductService,
                                       CostIncomeFileService costIncomeFileService,
                                       ResponsibilityService responsibilityService,
                                       CostCostingCollectionService costingCollectionService) {
        this.costIncomeGroupService = costIncomeGroupService;
        this.accountingProductService = accountingProductService;
        this.costIncomeFileService = costIncomeFileService;
        this.responsibilityService = responsibilityService;
        this.costingCollectionService = costingCollectionService;
    }

    /**
     * 分摊前查询
     *
     * @param current            当前页
     * @param pageSize           每页数据大小
     * @param responsibilityCode 责任中心代码
     * @param accountCode        会计中心代码
     * @param date               日期 yyyy-MM
     * @param hospId             医院id
     * @return 分摊前查询列表
     */
    @Override
    public PageUtils queryStartAllocation(Integer current, Integer pageSize, String responsibilityCode, String accountCode, String date, Long hospId) {
        Integer startIndex = (current - 1) * pageSize;
        int year = 0;
        int month = 0;
        if (StrUtil.isNotBlank(date)) {
            Date dateTime = DateUtils.StringToDate(date, DateStyleEnum.YYYY_MM);
            year = DateUtil.year(dateTime);
            month = DateUtil.month(dateTime) + 1;
        }
//        DateTime dateTime = DateUtil.parseDate(date);
//
//        Integer year = DateUtil.year(dateTime);
//        Integer month = DateUtil.month(dateTime) + 1;
        List<CostingGroupStartVO> list = baseMapper.queryStartAllocation(startIndex, pageSize, responsibilityCode, accountCode, year, month, hospId);
        int count = baseMapper.queryStartAllocationCount(responsibilityCode, accountCode, year, month, hospId);
        BigDecimal totalAmount = baseMapper.queryStartAllocationTotalAmount(responsibilityCode, accountCode, year, month, hospId);

        return new PageUtils(list, count, pageSize, current, totalAmount);
    }


    /**
     * 成本分摊列表
     *
     * @param current  当前页
     * @param pageSize 每页数据大小
     * @param date     日期 这里是 yyyy-MM-dd
     * @param hospId
     * @return 分页对象
     */
    @Override
    public PageUtils queryAllocation(Integer current, Integer pageSize, String date, Long hospId) {
        Integer year = null;
        Integer month = null;
        if (StrUtil.isNotBlank(date)) {
            DateTime dateTime = DateUtil.parseDate(date);
            year = DateUtil.year(dateTime);
            month = DateUtil.month(dateTime) + 1;
        }
        Integer startIndex = (current - 1) * pageSize;

        List<AllocationVO> list = baseMapper.queryAllocation(startIndex, pageSize, year, month, hospId);
        list.forEach(i -> {
            List<CostCostingCollection> collections = costingCollectionService.list(new LambdaQueryWrapper<CostCostingCollection>().eq(CostCostingCollection::getYear, i.getYear())
                    .eq(CostCostingCollection::getMonth, i.getMonth())
                    .eq(CostCostingCollection::getHospId, hospId)
            );
            if (!collections.isEmpty()) {
                i.setIsAllocation(true);
            }
        });
        int count = baseMapper.queryAllocationCount(year, month, hospId);
        return new PageUtils(list, count, pageSize, current);
    }

    /**
     * 开始成本分摊
     *
     * @param startDTO {@link StartDTO}
     * @param hospId   医院id
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
    public void startAllocation(StartDTO startDTO, Long hospId) {
        // 先拿到这个月数据 如果数据量很大 优化处理
        List<CostCostingGroup> list = this.list(
                new LambdaQueryWrapper<CostCostingGroup>()
                        .eq(CostCostingGroup::getDateYear, startDTO.getYear())
                        .eq(CostCostingGroup::getDateMonth, startDTO.getMonth())
                        .eq(CostCostingGroup::getHospId, hospId)
        );

        // 删除该年月已经过的数据
        costingCollectionService.remove(
                new LambdaQueryWrapper<CostCostingCollection>()
                        .eq(CostCostingCollection::getYear, startDTO.getYear())
                        .eq(CostCostingCollection::getMonth, startDTO.getMonth())
                        .eq(CostCostingCollection::getHospId, hospId)
        );
        // 得到分摊层级为1 的
//        list.stream().map(get)

    }

    /**
     * 批量导入成本数据
     *
     * @param list
     * @param user
     * @param file
     * @param dateTime
     * @param fileType
     * @return
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public Result importCostingGroup(List<List<Object>> list, User user, MultipartFile file, String dateTime, Integer fileType) {
        // 先检验当前年月是否存在数据
        int year = 0;
        int month = 0;
        if (StrUtil.isNotBlank(dateTime)) {
            Date date = DateUtils.StringToDate(dateTime, DateStyleEnum.YYYY_MM);
            year = DateUtil.year(date);
            month = DateUtil.month(date) + 1;
        }
        Long hospId = user.getHospId();
        List<CostCostingGroup> groups = this.list(new QueryWrapper<CostCostingGroup>().lambda().eq(CostCostingGroup::getHospId, hospId)
                .eq(CostCostingGroup::getDateYear, year).eq(CostCostingGroup::getDateMonth, month));
        if (!CollectionUtils.isEmpty(groups)) {
            throw new CostException(500, year + "年" + month + "月数据已存在");
        }
        for (int i = list.size() - 1; i >= 0; i--) {
            if (i == NumberConstant.ZERO || i == NumberConstant.ONE || i == NumberConstant.TWO || i == NumberConstant.THREE) {
                list.remove(list.get(i));
            }
        }
        List<IncomeErrorMessage> incomeErrorMessageList = new ArrayList<>();
        //获取所有的科室 成本项目 责任中心 会计科目
        Map<String, Department> departmentMap = costIncomeGroupService.getDepartmentByCodeNameMap(hospId);
        Map<String, Product> productMap = costIncomeGroupService.getProductByCodeNameMap(hospId);
        Map<Long, Responsibility> responsibilityMap = costIncomeGroupService.getResponsibilityIdResponsibilityMap(hospId);
        Map<Long, Accounting> accountingMap = costIncomeGroupService.getAccountIdAccountingMap(hospId);
        List<ResponsibilityDepartment> responsibilityDepartmentList = costIncomeGroupService.getResponsibilityDepartments(hospId);
        if (CollectionUtils.isEmpty(responsibilityDepartmentList)) {
            throw new CostException(500, "没有科室责任中心对照数据");
        }
        List<AccountingProduct> accountingProductList = accountingProductService.list(new QueryWrapper<AccountingProduct>().lambda().eq(AccountingProduct::getHospId, hospId));
        if (CollectionUtils.isEmpty(accountingProductList)) {
            throw new CostException(500, "没有成本会计对照数据");
        }
        Map<Long, Long> responsibilityDepMap = costIncomeGroupService.getDepartmentIdResponsibilityIdMap(responsibilityDepartmentList);
        Map<Long, Long> accountProMap = costIncomeGroupService.getProductIdAccountIdMap(accountingProductList);

        String endStatus = list.get(0).get(list.get(0).size() - 1).toString();
        // 要保存的数据
        List<CostCostingGroup> costCostingGroupArrayList = new LinkedList<>();
        // 判断最后科室代码的最后一个字符是否是-1
        if (!"-1".equals(endStatus)) {
            // 如果没有-1说明终结符
            IncomeErrorMessage incomeErrorMessage = new IncomeErrorMessage();
            incomeErrorMessage.setTotal(5);
            incomeErrorMessage.setErrMessage("科室代码末尾没有-1终结符");
            incomeErrorMessageList.add(incomeErrorMessage);
            // 文件上传
            String uploadFile = costIncomeGroupService.uploadFile(file, UserContext.getCurrentUser());
            // 上传记录保存
            if (StrUtil.isBlank(uploadFile)) {
                throw new CostException(500, "文件上传异常");
            }
            // 记录文件上传记录
            CostIncomeFile costIncomeFile = costIncomeFileService.saveCostIncomeFile(list, user, file, hospId, incomeErrorMessageList, uploadFile, fileType, year, month);
            return Result.build(500, "数据未成功导入", null);
        }
        // 检验数据的合理性
        // 检验成本数据
        checkCostData(list, incomeErrorMessageList, departmentMap, productMap, responsibilityMap, accountingMap, responsibilityDepMap, accountProMap, costCostingGroupArrayList, year, month);
        // 文件上传
        String uploadFile = costIncomeGroupService.uploadFile(file, UserContext.getCurrentUser());
        // 上传记录保存
        if (StrUtil.isBlank(uploadFile)) {
            throw new CostException(500, "文件上传异常");
        }
        // 记录文件上传记录
        CostIncomeFile costIncomeFile = costIncomeFileService.saveCostIncomeFile(list, user, file, hospId, incomeErrorMessageList, uploadFile, fileType, year, month);
        Long id = costIncomeFile.getId();
        costCostingGroupArrayList.forEach(i -> {
            // 设置文件Id
            i.setFileId(id);
        });
        if (CollectionUtils.isEmpty(incomeErrorMessageList)) {
            this.saveBatch(costCostingGroupArrayList);
            return Result.build(200, "数据导入成功", null);
        } else {

            return Result.build(200, "数据未成功导入", null);
        }
    }


    /**
     * 检验成本数据
     *
     * @param list
     * @param incomeErrorMessageList
     * @param departmentMap
     * @param productMap
     * @param responsibilityMap
     * @param accountingMap
     * @param responsibilityDepMap
     * @param accountProMap
     * @param costCostingGroupArrayList
     */
    private void checkCostData(List<List<Object>> list, List<IncomeErrorMessage> incomeErrorMessageList, Map<String, Department> departmentMap, Map<String, Product> productMap, Map<Long, Responsibility> responsibilityMap, Map<Long, Accounting> accountingMap, Map<Long, Long> responsibilityDepMap, Map<Long, Long> accountProMap, List<CostCostingGroup> costCostingGroupArrayList, Integer year, Integer month) {
        List<Object> departmentCodes = list.get(0);
        List<Object> departmentNames = list.get(1);
        //检验数据是否准确
        for (int i = 2; i < list.size(); i++) {
            int row = i + 5;
            List<Object> data = list.get(i);
            for (int j = 2; j < departmentCodes.size(); j++) {
                int column = j + 1;
                if (data.size() > j) {
                    if (Objects.isNull(data.get(j))) {
                        data.set(j, NumberConstant.ZERO);
                    } else if (data.get(j).toString().contains("-") || !StringUtils.isNumber(data.get(j).toString())) {
                        IncomeErrorMessage incomeErrorMessage = new IncomeErrorMessage();
                        incomeErrorMessage.setTotal(row);
                        incomeErrorMessage.setErrMessage("第" + row + "行 第" + column + "列数据不符合规范");
                        incomeErrorMessageList.add(incomeErrorMessage);
                    } else {
                        data.set(j, Double.parseDouble(data.get(j).toString()));
                    }
                } else {
                    data.add(NumberConstant.ZERO);
                }
            }
            if (CollectionUtils.isEmpty(incomeErrorMessageList)) {
                incomeErrorMessageList = new ArrayList<>();
                int emptyStatus = 0;
                for (int j = 2; j < data.size() - 1; j++) {
                    BigDecimal parseInt = new BigDecimal(data.get(j).toString());
                    if (!BigDecimal.ZERO.equals(parseInt)) {
                        emptyStatus = 1;
                        break;
                    }
                }
                // 检验成本项目是否正确
                CostCostingGroup costCostingGroupRequest = new CostCostingGroup();
                if (Objects.nonNull(data.get(0)) && Objects.nonNull(data.get(1))) {
                    String productCode = data.get(0).toString();
                    String productName = data.get(1).toString();
                    Product product = productMap.get(productCode + productName);
                    AfterCostGroup afterCostGroupRequest = new AfterCostGroup();
                    if (Objects.nonNull(product)) {
                        Long id = product.getId();
                        Long accountTingId = accountProMap.get(id);
                        if (Objects.nonNull(accountTingId)) {
                            Accounting accounting = accountingMap.get(accountTingId);
                            if (Objects.nonNull(accounting)) {

                                costCostingGroupRequest.setProductCode(productCode);
                                costCostingGroupRequest.setProductName(productName);
                                costCostingGroupRequest.setAccountCode(accounting.getAccountingCode());
                                costCostingGroupRequest.setAccountName(accounting.getAccountingName());
                                afterCostGroupRequest.setProductCode(productCode);
                                afterCostGroupRequest.setProductName(productName);
                                afterCostGroupRequest.setAccountCode(accounting.getAccountingCode());
                                afterCostGroupRequest.setAccountName(accounting.getAccountingName());
                            } else {
                                IncomeErrorMessage incomeErrorMessage = new IncomeErrorMessage();
                                incomeErrorMessage.setTotal(1);
                                incomeErrorMessage.setErrMessage("成本代码" + productCode + " 成本名称" + productName + " 不存在对应的会计科目不存在");
                                incomeErrorMessageList.add(incomeErrorMessage);
                            }
                        } else {
                            IncomeErrorMessage incomeErrorMessage = new IncomeErrorMessage();
                            incomeErrorMessage.setTotal(1);
                            incomeErrorMessage.setErrMessage("成本代码" + productCode + " 成本名称" + productName + " 不存在对应的会计科目不存在");
                            incomeErrorMessageList.add(incomeErrorMessage);
                        }
                    } else {
                        IncomeErrorMessage incomeErrorMessage = new IncomeErrorMessage();
                        incomeErrorMessage.setTotal(1);
                        incomeErrorMessage.setErrMessage("成本代码" + productCode + " 成本名称" + productName + "不存在");
                        incomeErrorMessageList.add(incomeErrorMessage);
                    }
                    // 0表示全为0 1表示不全为0

                    BigDecimal combined = new BigDecimal(data.get(data.size() - 1).toString());
                    if (!BigDecimal.ZERO.equals(combined) && NumberConstant.ZERO.equals(emptyStatus)) {
                        // 这条数据是保存到其他责任中心的
                        CostCostingGroup costCostingGroup = costCostingGroupRequest;
                        AfterCostGroup afterCostGroup = BeanUtil.convertObj(afterCostGroupRequest, AfterCostGroup.class);
                        // TODO 设置其他责任中心
                        Responsibility responsibilityServiceOne = responsibilityService.getOne(new QueryWrapper<Responsibility>().lambda().eq(Responsibility::getHospId, UserContext.getHospId()).eq(Responsibility::getIsDefault, NumberConstant.ONE));
                        if (Objects.nonNull(responsibilityServiceOne)) {
                            costCostingGroup.setResponsibilityCode(responsibilityServiceOne.getResponsibilityCode());
                            costCostingGroup.setResponsibilityName(responsibilityServiceOne.getResponsibilityName());
                            // 设置统计数据
                            afterCostGroup.setOtherResponsibilityCode(responsibilityServiceOne.getResponsibilityCode());
                            afterCostGroup.setOtherResponsibilityName(responsibilityServiceOne.getResponsibilityName());
                        } else {
                            IncomeErrorMessage incomeErrorMessage = new IncomeErrorMessage();
                            incomeErrorMessage.setTotal(row);
                            incomeErrorMessage.setErrMessage("不存在默认责任中心");
                            incomeErrorMessageList.add(incomeErrorMessage);
                        }
                        costCostingGroup.setProductCode(costCostingGroupRequest.getProductCode());
                        costCostingGroup.setProductName(costCostingGroupRequest.getProductName());
                        costCostingGroup.setAccountCode(costCostingGroupRequest.getAccountCode());
                        costCostingGroup.setAccountName(costCostingGroupRequest.getAccountName());
                        costCostingGroup.setAmount(combined);
                        costCostingGroup.setHospId(UserContext.getHospId());
                        costCostingGroup.setCreateTime(System.currentTimeMillis());
                        costCostingGroup.setDateYear(year);
                        costCostingGroup.setDateMonth(month);
                        afterCostGroup.setAmount(combined);
//                    String s = -JsonUtil.toJSONString(afterCostGroup);
                        String s = JacksonUtil.obj2Str(combined);
                        costCostingGroup.setAfterCostGroup(s);
                        costCostingGroupArrayList.add(costCostingGroup);
                    } else {
                        for (int j = 2; j < data.size() - 1; j++) {
                            AfterCostGroup afterCostGroup = BeanUtil.convertObj(afterCostGroupRequest, AfterCostGroup.class);
                            CostCostingGroup costCostingGroup = BeanUtil.convertObj(costCostingGroupRequest, CostCostingGroup.class);
                            // 检验科室信息是否准确
                            String departmentCode = departmentCodes.get(j).toString();
                            String departmentName = departmentNames.get(j).toString();
                            Department department = departmentMap.get(departmentCode + departmentName);
                            if (Objects.nonNull(department)) {
                                // 检测责任中心是否存在
                                Long id = department.getId();
                                Long responsibilityId = responsibilityDepMap.get(id);
                                if (Objects.nonNull(responsibilityId)) {
                                    Responsibility responsibility = responsibilityMap.get(responsibilityId);
                                    if (Objects.nonNull(responsibility)) {
                                        costCostingGroup.setDepartmentCode(departmentCode);
                                        costCostingGroup.setDepartmentName(departmentName);
                                        costCostingGroup.setResponsibilityCode(responsibility.getResponsibilityCode());
                                        costCostingGroup.setResponsibilityName(responsibility.getResponsibilityName());
                                        afterCostGroup.setResponsibilityCode(responsibility.getResponsibilityCode());
                                        afterCostGroup.setResponsibilityName(responsibility.getResponsibilityName());
                                        afterCostGroup.setDepartmentCode(departmentCode);
                                        afterCostGroup.setDepartmentName(departmentName);
                                    } else {
                                        IncomeErrorMessage incomeErrorMessage = new IncomeErrorMessage();
                                        incomeErrorMessage.setTotal(j);
                                        incomeErrorMessage.setErrMessage("第" + j + "列科室信息对应的责任中心不存在");
                                        incomeErrorMessageList.add(incomeErrorMessage);
                                    }
                                } else {
                                    IncomeErrorMessage incomeErrorMessage = new IncomeErrorMessage();
                                    incomeErrorMessage.setTotal(j);
                                    incomeErrorMessage.setErrMessage("第" + j + "列科室信息不存在对应的责任中心");
                                    incomeErrorMessageList.add(incomeErrorMessage);
                                }
                            } else {
                                IncomeErrorMessage incomeErrorMessage = new IncomeErrorMessage();
                                incomeErrorMessage.setTotal(j);
                                incomeErrorMessage.setErrMessage("第" + j + "列科室信息不存在");
                                incomeErrorMessageList.add(incomeErrorMessage);
                            }
                            costCostingGroup.setAmount(new BigDecimal((Objects.isNull(data.get(j)) || "0".equals(data.get(j).toString())) ? "0.00" : data.get(j).toString()));
                            costCostingGroup.setHospId(UserContext.getHospId());
                            costCostingGroup.setCreateTime(System.currentTimeMillis());
                            costCostingGroup.setDateYear(year);
                            costCostingGroup.setDateMonth(month);
                            afterCostGroup.setAmount(new BigDecimal((Objects.isNull(data.get(j)) || "0".equals(data.get(j).toString())) ? "0.00" : data.get(j).toString()));
//                        String s = JsonUtil.toJSONString(afterCostGroup);
                            String s = JacksonUtil.obj2Str(afterCostGroup);
                            costCostingGroup.setAfterCostGroup(s);
                            costCostingGroupArrayList.add(costCostingGroup);
                        }
                    }
                }

            }
        }
    }
}