hsq / hsq-credit-manager · Files

package com.lhcredit.project.business.enterpriseInfo.service;

import com.lhcredit.common.utils.DateUtils;
import com.lhcredit.common.utils.StringUtils;
import com.lhcredit.project.business.enterpriseInfo.mapper.EnterpriseInfoMapper;
import com.lhcredit.project.system.dict.domain.DictData;
import com.lhcredit.project.system.dict.service.IDictDataService;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.compress.utils.Lists;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.lhcredit.project.business.enterpriseInfo.domain.EnterpriseInfo;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 企业信息Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-04-25
 */
@Service
public class EnterpriseInfoServiceImpl implements IEnterpriseInfoService
{
    @Autowired
    private EnterpriseInfoMapper enterpriseInfoMapper;

    @Autowired
    private IDictDataService  sysDictTypeService;


    /**
     * 查询企业信息
     * 
     * @param id 企业信息主键
     * @return 企业信息
     */
    @Override
    public EnterpriseInfo selectEnterpriseInfoById(Long id)
    {
        return enterpriseInfoMapper.selectEnterpriseInfoById(id);
    }

    public List<EnterpriseInfo> getEnterpriseInfoList(EnterpriseInfo enterpriseInfo){
        return enterpriseInfoMapper.selectEnterpriseInfoList(enterpriseInfo);
    }

    /**
     * 查询企业信息列表
     * 
     * @param enterpriseInfo 企业信息
     * @return 企业信息
     */
    @Override
    public List<EnterpriseInfo> selectEnterpriseInfoList(EnterpriseInfo enterpriseInfo)
    {

        //设置查询条件
        handleCondition(enterpriseInfo);

        List<EnterpriseInfo> enterpriseInfos = enterpriseInfoMapper.selectEnterpriseInfoList(enterpriseInfo);

        for (EnterpriseInfo en : enterpriseInfos){
            if (en.getMenlei().equals("n"))
                en.setMenleiStr("");
            else
                en.setMenleiStr(sysDictTypeService.selectDictLable("industry_categories",en.getMenlei()));
        }

        return enterpriseInfos;
    }



    /**
     * 处理 查询条件
     * @param enterpriseInfo
     */
    private  void handleCondition(EnterpriseInfo enterpriseInfo) {
        //成立年限
        if (StringUtils.isNotEmpty(enterpriseInfo.getEstiblishTimeStr())){
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern(DateUtils.YYYY_MM_DD);
            LocalDate now = LocalDate.now();
            LocalDate oneYearAgo = now.minusYears(1);
            String oneYearAgeStr = oneYearAgo.format(formatter);

            LocalDate threeYearAgo = now.minusYears(3);
            String threeYearAgoStr = threeYearAgo.format(formatter);

            LocalDate fourYearAgo = now.minusYears(4);
            String fourYearAgoStr = fourYearAgo.format(formatter);

            LocalDate tenYearAgo = now.minusYears(10);
            String tenYearAgoStr = tenYearAgo.format(formatter);

//            LocalDate fourYearAge = now.minusDays(3);
            switch (enterpriseInfo.getEstiblishTimeStr()){
                case "1年内":
                    String nowStr = now.format(formatter);
                    enterpriseInfo.setEstiblishTimeStart(oneYearAgeStr);
                    enterpriseInfo.setEstiblishTimeEnd(nowStr);
                    break;
                case "1-3年":
                    enterpriseInfo.setEstiblishTimeStart(threeYearAgoStr);
                    enterpriseInfo.setEstiblishTimeEnd(oneYearAgeStr);
                    break;
                case "4-10年":
                    enterpriseInfo.setEstiblishTimeStart(tenYearAgoStr);
                    enterpriseInfo.setEstiblishTimeEnd(fourYearAgoStr);
                    break;
                case "10年以上":
                    enterpriseInfo.setEstiblishTimeStart(null);
                    enterpriseInfo.setEstiblishTimeEnd(tenYearAgoStr);
                    break;
                default:
                    break;
            }

        }

        //注册资本
        if (StringUtils.isNotEmpty(enterpriseInfo.getRegCapital())){
            switch (enterpriseInfo.getRegCapital()){
                case "0-1000万":
                    enterpriseInfo.setRegCapitalStart(0);
                    enterpriseInfo.setRegCapitalEnd(1000);
                    break;
                case "1000万-5000万":
                    enterpriseInfo.setRegCapitalStart(1000);
                    enterpriseInfo.setRegCapitalEnd(5000);
                    break;
                case "5000万-1亿":
                    enterpriseInfo.setRegCapitalStart(5000);
                    enterpriseInfo.setRegCapitalEnd(10000);
                    break;
                case "1亿-10亿":
                    enterpriseInfo.setRegCapitalStart(10000);
                    enterpriseInfo.setRegCapitalEnd(100000);
                    break;
                case "10亿以上":
                    enterpriseInfo.setRegCapitalStart(100000);
                    break;
                default:
                    break;
            }
        }

        //信用评分
        if (StringUtils.isNotEmpty(enterpriseInfo.getCreditFraction())){
            switch (enterpriseInfo.getCreditFraction()){
                case "576分以下":
                    enterpriseInfo.setCreditFractionStart(null);
                    enterpriseInfo.setCreditFractionEnd(576);
                    break;
                case "576分-578分":
                    enterpriseInfo.setCreditFractionStart(576);
                    enterpriseInfo.setCreditFractionEnd(578);
                    break;
                case "578分-582分":
                    enterpriseInfo.setCreditFractionStart(578);
                    enterpriseInfo.setCreditFractionEnd(582);
                    break;
                case "582分-584分":
                    enterpriseInfo.setCreditFractionStart(582);
                    enterpriseInfo.setCreditFractionEnd(584);
                    break;
                case "584分-586分":
                    enterpriseInfo.setCreditFractionStart(584);
                    enterpriseInfo.setCreditFractionEnd(586);
                    break;
                case "586分-591分":
                    enterpriseInfo.setCreditFractionStart(586);
                    enterpriseInfo.setCreditFractionEnd(591);
                    break;
                case "591分-607分":
                    enterpriseInfo.setCreditFractionStart(591);
                    enterpriseInfo.setCreditFractionEnd(607);
                    break;
                case "607分-621分":
                    enterpriseInfo.setCreditFractionStart(607);
                    enterpriseInfo.setCreditFractionEnd(621);
                    break;
                case "621分-629分":
                    enterpriseInfo.setCreditFractionStart(621);
                    enterpriseInfo.setCreditFractionEnd(629);
                    break;
                case "629分以上":
                    enterpriseInfo.setCreditFractionStart(629);
                    enterpriseInfo.setCreditFractionEnd(null);
                    break;
                default:
                    break;
            }
        }
        //高新技术企业 设置 默认的认定年限
        if (enterpriseInfo.getTableType() !=null && enterpriseInfo.getTableType().equals("2")) {
            //高新技术企业 当认定年限为空 则查询字典中的所有值
            if (CollectionUtils.isEmpty(enterpriseInfo.getRecognitionPeriods())){
                List<DictData> sysDictData = sysDictTypeService.selectDictDataByType("duration");
                List<String> periods = sysDictData.stream().map(DictData::getDictValue).collect(Collectors.toList());
                enterpriseInfo.setRecognitionPeriods(periods);
            }
        }
    }

    /**
     * 新增企业信息
     * 
     * @param enterpriseInfo 企业信息
     * @return 结果
     */
    @Override
    public int insertEnterpriseInfo(EnterpriseInfo enterpriseInfo)
    {
        return enterpriseInfoMapper.insertEnterpriseInfo(enterpriseInfo);
    }

    /**
     * 修改企业信息
     * 
     * @param enterpriseInfo 企业信息
     * @return 结果
     */
    @Override
    public int updateEnterpriseInfo(EnterpriseInfo enterpriseInfo)
    {
        return enterpriseInfoMapper.updateEnterpriseInfo(enterpriseInfo);
    }

    /**
     * 批量删除企业信息
     * 
     * @param ids 需要删除的企业信息主键
     * @return 结果
     */
    @Override
    public int deleteEnterpriseInfoByIds(Long[] ids)
    {
        return enterpriseInfoMapper.deleteEnterpriseInfoByIds(ids);
    }

    /**
     * 删除企业信息信息
     * 
     * @param id 企业信息主键
     * @return 结果
     */
    @Override
    public int deleteEnterpriseInfoById(Long id)
    {
        return enterpriseInfoMapper.deleteEnterpriseInfoById(id);
    }


    /**
     * 获取各个类型企业数量
     *
     * @return
     */
    @Override
    public EnterpriseInfo getEnterpriseCount() {
        return enterpriseInfoMapper.getEnterpriseCount();
    }

    /**
     * 查询 企业数量变化趋势 图
     *
     * @param enterpriseInfo
     * @return
     */
    @Override
    public List<EnterpriseInfo> getEnterpriseCountTrend(EnterpriseInfo enterpriseInfo) {

        //将时间条件 前移一年，来计算 起始时间的 增速；
        Integer year = Integer.valueOf(enterpriseInfo.getEstiblishTimeStart());
        Integer i = year - 1;
        enterpriseInfo.setEstiblishTimeStart(i.toString());
        /*List<EnterpriseInfo> trends = Lists.newArrayList();
        if (StringUtils.isEmpty(enterpriseInfo.getTableType())){
            trends = enterpriseInfoMapper.getAllEnterpriseCountTrend(enterpriseInfo);
        }else {
            trends = enterpriseInfoMapper.getTypeEnterpriseCountTrend(enterpriseInfo);
        }*/
        List<EnterpriseInfo> trends = enterpriseInfoMapper.getAllEnterpriseCountTrend(enterpriseInfo);

        //计算增长率
        if (CollectionUtils.isNotEmpty(trends)){
            for (int j=1; j<= trends.size(); j++){
                //等于 list长度时候，停止计算，避免越界
                if (j == trends.size())
                    break;

                int k = j - 1;
                EnterpriseInfo info = trends.get(k);
                EnterpriseInfo info1 = trends.get(j);
                Integer o = info.getCounts();
                Integer o1 = info1.getCounts();
                BigDecimal divide = BigDecimal.valueOf(o1 - o)
                                                .divide(BigDecimal.valueOf(o), 4, RoundingMode.HALF_UP) //除法时保留4位，确保*100% 保持确定的精度
                                                .multiply(new BigDecimal("100"))
                                                .setScale(2,RoundingMode.HALF_UP);
                info1.setIncreaseRate(divide.toString());

//                System.out.println(info1.getYears() + "--->" + info1.getCounts() + "---->" + info1.getIncreaseRate());
            }
            //去掉 最开始前移的一年
            trends.remove(0);
        }
        return trends;
    }

    /**
     * 企业吊销/注销数量变化趋势 图
     *
     * @param enterpriseInfo
     * @return
     */
    @Override
    public HashMap<Integer, EnterpriseInfo> getEnterpriseRegCountTrend(EnterpriseInfo enterpriseInfo) {

        //设置月份
        HashMap<Integer, EnterpriseInfo> infoMap = new HashMap<>();
        int start = Integer.parseInt(enterpriseInfo.getEstiblishTimeStart());
        int end = Integer.parseInt(enterpriseInfo.getEstiblishTimeEnd());
        int index = end - start;
        for (int i =0 ; i <= index; i++){
            int month = start + i;
            infoMap.put(month,EnterpriseInfo.builder().revokeEnterpriseCount(0).logoffEnterpriseCount(0).build());
        }

        //吊销企业数量统计
        enterpriseInfo.setRegStatusCode("3");
        List<EnterpriseInfo> revokeTrends = enterpriseInfoMapper.getAllEnterpriseCountTrend(enterpriseInfo);
        infoMap.forEach((k,v)->{
            for (EnterpriseInfo en : revokeTrends) {
                if (k.equals(en.getYears()))
                    v.setRevokeEnterpriseCount(en.getCounts());
            }

        });

        //注销企业数量统计
        enterpriseInfo.setRegStatusCode("2");
        List<EnterpriseInfo> logoffTrends = enterpriseInfoMapper.getAllEnterpriseCountTrend(enterpriseInfo);
        infoMap.forEach((k,v)->{
            for (EnterpriseInfo en : logoffTrends) {
                if (k.equals(en.getYears()))
                    v.setLogoffEnterpriseCount(en.getCounts());
            }
        });
        return infoMap;
    }


    /**
     * 企业地区数量占比分布情况 图  / 企业信用评级分布图
     *
     * @param enterpriseInfo
     * @return
     */
    @Override
    public List<EnterpriseInfo> getEnterpriseCountByType(EnterpriseInfo enterpriseInfo) {
        //地区list
        ArrayList<EnterpriseInfo> trendtList = Lists.newArrayList();
        //地区分组
        if (enterpriseInfo.getGroupBy().equals("1")){
            trendtList.add(EnterpriseInfo.builder().abscissa("银川市").counts(0).build());
            trendtList.add(EnterpriseInfo.builder().abscissa("吴忠市").counts(0).build());
            trendtList.add(EnterpriseInfo.builder().abscissa("石嘴山市").counts(0).build());
            trendtList.add(EnterpriseInfo.builder().abscissa("固原市").counts(0).build());
            trendtList.add(EnterpriseInfo.builder().abscissa("中卫市").counts(0).build());

            //分组查询
            List<EnterpriseInfo> typeList  = enterpriseInfoMapper.getEnterpriseCountByType(enterpriseInfo);
            getDataAndCalculate(typeList, trendtList);

            //信用评级分组
        }else if(enterpriseInfo.getGroupBy().equals("2")){
            //查询字典中的 评级级别
            List<DictData> levels = sysDictTypeService.selectDictDataByType("level");
            //构建信用数据
            levels.forEach(le -> {
                trendtList.add(EnterpriseInfo.builder().abscissa(le.getDictValue()).counts(0).build());
            });

            //按照信用评级分组 统计数量
            List<EnterpriseInfo> typeList  = enterpriseInfoMapper.getEnterpriseCountByType(enterpriseInfo);
            getDataAndCalculate(typeList,trendtList);
        }

        return trendtList;
    }

    private void getDataAndCalculate(List<EnterpriseInfo> typeList, ArrayList<EnterpriseInfo> trendtList) {

        //计算 总数量
        Integer sum = Optional.ofNullable(typeList)
                .filter(list -> !list.isEmpty())
                .map(list -> list.stream()
                        .filter(e-> e.getCounts() != null )
                        .mapToInt(EnterpriseInfo::getCounts)
                        .sum())
                .orElse(-1);
        if (sum <=0 )
            return;
        //计算 并设置数值
        trendtList.forEach((d) ->{
            for (EnterpriseInfo e : typeList) {
                if (d.getAbscissa().equals(e.getAbscissa())) {
                    d.setCounts(e.getCounts());
                    //计算占比
                    if (e.getCounts() != null && e.getCounts() != 0){
                        BigDecimal divide = BigDecimal.valueOf(e.getCounts())
                                .divide(BigDecimal.valueOf(sum), 4, RoundingMode.HALF_UP) //除法时保留4位，确保*100% 保持确定的精度
                                .multiply(new BigDecimal("100"))
                                .setScale(2,RoundingMode.HALF_UP);
                        d.setRate(divide.toString());
                    }
                }
            }
        });
    }


    /**
     * 企业注册资本规模占比分布情况 图
     *
     * @param enterpriseInfo
     * @return
     */
    @Override
    public List<EnterpriseInfo> getEnterpriseCountRegCapTrend(EnterpriseInfo enterpriseInfo) {

        //注册资本list
        ArrayList<EnterpriseInfo> regCapitalList = new ArrayList<>(
                Arrays.asList(EnterpriseInfo.builder().abscissa("0-1000万").counts(0).build(),
                        EnterpriseInfo.builder().abscissa("1000万-5000万").counts(0).build(),
                        EnterpriseInfo.builder().abscissa("5000万-1亿").counts(0).build(),
                        EnterpriseInfo.builder().abscissa("1亿-10亿").counts(0).build(),
                        EnterpriseInfo.builder().abscissa("10亿以上").counts(0).build())
        );
        //查询 并 计算数据
        List<EnterpriseInfo> countRegCapTrends = enterpriseInfoMapper.getEnterpriseCountRegCapTrend(enterpriseInfo);

        getDataAndCalculate(countRegCapTrends,regCapitalList);

        return regCapitalList;
    }


    /**
     * 根据企业统一社会信用代码查询 企业详情
     *
     * @param enterpriseInfo
     * @return
     */
    @Override
    public EnterpriseInfo getEnterpriseInfoByEcdoe(EnterpriseInfo enterpriseInfo) {

        List<EnterpriseInfo> enterpriseInfos = selectEnterpriseInfoList(enterpriseInfo);
        if (CollectionUtils.isEmpty(enterpriseInfos)) {
            return null;
        }
        EnterpriseInfo info = enterpriseInfos.get(0);
        //查询
        EnterpriseInfo type = enterpriseInfoMapper.getEnterpriseType(enterpriseInfo);
        //设置 企业类型标签
        ArrayList<String> list = new ArrayList<>();
        if (type.getTechMediumCount() > 0)
            list.add("科技中小型企业");
        else if (type.getHighTechCount() > 0)
            list.add("高新技术企业");
        else if (type.getGazelleCount() > 0)
            list.add("瞪羚企业");
        else if (type.getUnicornCount() > 0)
            list.add("独角兽企业");
        else if (type.getGiantCount() > 0)
            list.add("专精特新小巨人企业");

        info.setEnterpriseTypeList(list);
        return info;
    }
}