TroubleAndRiskConnectHall.git

package com.ruoyi.project.tr.report.service;
 
import com.alibaba.fastjson.JSON;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.project.system.company.domain.Company;
import com.ruoyi.project.system.company.service.ICompanyService;
import com.ruoyi.project.tr.report.domain.Danger;
import com.ruoyi.project.tr.report.domain.DangerByTime;
import com.ruoyi.project.tr.report.domain.Report;
import com.ruoyi.project.tr.report.domain.RiskDomain;
import com.ruoyi.project.tr.report.mapper.ReportMapper;
import io.swagger.models.auth.In;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.ui.ModelMap;
 
import java.text.DecimalFormat;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
 
@Service
public class ReportService {
    @Autowired
    private ReportMapper reportMapper;
    @Autowired
    private ICompanyService companyService;
 
    //获取公司四色图数据
    public List getFourColorPic(long companyId) {
        Company company = companyService.selectCompanyById(companyId);
        String companyFourColorMapUrl = company.getCompanyFourColorMapUrl();
        Map colorPicMap = JSON.parseObject(companyFourColorMapUrl);
        Collection<String> values = colorPicMap.values();
        ArrayList<String> colorPic = new ArrayList<>();
        values.forEach(v -> {
            v = v.replaceAll("^http:\\/\\/[^/]+", "");
            colorPic.add(v);
        });
        return colorPic;
    }
 
    //查询公示上半部分信息
    public ModelMap selectPublicityHeadData(long companyId, ModelMap map) {
        //获取四色图
        List fourColorPic = getFourColorPic(companyId);
        //四色图
        map.put("fourColorMapUrl", fourColorPic);
        //获取风险数据
        List<RiskDomain> riskDomains = reportMapper.selectPublicityRisk(companyId);
        //风险总量
        map.put("allRiskCount", riskDomains.size());
        AtomicReference<Integer> lowRiskCount = new AtomicReference<>(0);
        AtomicReference<Integer> normalRiskCount = new AtomicReference<>(0);
        AtomicReference<Integer> middleRiskCount = new AtomicReference<>(0);
        AtomicReference<Integer> seriesRiskCount = new AtomicReference<>(0);
        ArrayList<RiskDomain> seriesRisks = new ArrayList<>();
        riskDomains.forEach(riskDomain -> {
            if (StringUtils.isNotEmpty(riskDomain.getRiskColor())) {
                switch (riskDomain.getRiskColor()) {
                    case "蓝色":
                        lowRiskCount.getAndSet(lowRiskCount.get() + 1);
                        break;
                    case "黄色":
                        normalRiskCount.getAndSet(normalRiskCount.get() + 1);
                        break;
                    case "橙色":
                        middleRiskCount.getAndSet(middleRiskCount.get() + 1);
                        break;
                    case "红色":
                        seriesRiskCount.getAndSet(seriesRiskCount.get() + 1);
                        seriesRisks.add(riskDomain);
                        break;
                }
            }
        });
        //低风险数量
        map.put("lowRiskCount", lowRiskCount);
        //一般风险数量
        map.put("normalRiskCount", normalRiskCount);
        //较大风险数量
        map.put("middleRiskCount", middleRiskCount);
        //重大风险数量
        map.put("seriesRiskCount", seriesRiskCount);
        //重大风险公示信息
        map.put("seriesRisks", seriesRisks);
        //获取隐患数据
        List<Danger> dangers = reportMapper.selectPublicityDanger(companyId);
        ArrayList<Danger> seriesDangers = new ArrayList<>();
        AtomicReference<Integer> unRectifyDangerCount = new AtomicReference<>(0);
        dangers.forEach(danger -> {
            if (danger != null) {
                if (StringUtils.isNotEmpty(danger.getDangerLevel()) && "1".equals(danger.getDangerLevel())) {
                    seriesDangers.add(danger);
                }
                if (StringUtils.isNotEmpty(danger.getRectifyStatus()) && "0".equals(danger.getRectifyStatus())) {
                    unRectifyDangerCount.getAndSet(unRectifyDangerCount.get() + 1);
                }
            }
        });
        //重大隐患公示信息
        map.put("seriesDangers", seriesDangers);
        //未整改隐患数量
        map.put("unRectifyDangerCount", unRectifyDangerCount);
 
        Map monthlyDangerMap = selectMonthlyDangers(companyId);
 
        ArrayList normalDanger = (ArrayList) monthlyDangerMap.get("normalDanger");
        long thisMonthNormalDangerCount = (long) normalDanger.get(normalDanger.size() - 1);
        ArrayList highDanger = (ArrayList) monthlyDangerMap.get("highDanger");
        long thisMonthHighDangerCount = (long) highDanger.get(highDanger.size() - 1);
        //当月一般隐患数量
        map.put("thisMonthNormalDangerCount", thisMonthNormalDangerCount);
        //当月重大隐患数量
        map.put("thisMonthHighDangerCount", thisMonthHighDangerCount);
        //月度隐患总量
        map.put("thisMonthDangerCount", thisMonthHighDangerCount + thisMonthNormalDangerCount);
        Map yearlyDangersMap = selectYearlyDangers(companyId);
        ArrayList normalDanger1 = (ArrayList) yearlyDangersMap.get("normalDanger");
        ArrayList highDanger1 = (ArrayList) yearlyDangersMap.get("highDanger");
        long yearlyDangerCount = (long) normalDanger1.get(normalDanger1.size() - 1) + (long) highDanger1.get(highDanger1.size() - 1);
        //年度隐患总量
        map.put("yearlyDangerCount", yearlyDangerCount);
        Long allDangers = (Long) yearlyDangersMap.get("allDangers");
        double tempPercent = 1.00;
        if (allDangers != 0) {
            tempPercent = (double) (allDangers - unRectifyDangerCount.get()) / allDangers;
        }
        String dangerRectifyPercent = new DecimalFormat("0.00%").format(tempPercent);
        //隐患整改率
        map.put("dangerRectifyPercent", dangerRectifyPercent);
        return map;
    }
 
    //查询公示所需报表信息
    public Map selectPublicityReportData(long companyId) {
        HashMap<String, Object> map = new HashMap<>();
        //获取隐患和风险报表数据
        Map regionRiskMap = selectRiskByRegion(companyId);
        //区域风险柱状图数据
        map.put("regionRiskMap", regionRiskMap);
        Map deptRiskMap = selectRiskByDept(companyId);
        //部门风险柱状图数据
        map.put("deptRiskMap", deptRiskMap);
        Map deptDangerMap = selectDeptDangers(companyId);
        //部门隐患柱状图数据
        map.put("deptDangerMap", deptDangerMap);
        Map regionDangerMap = selectDangerByRegion(companyId);
        //区域隐患柱状图数据
        map.put("regionDangerMap", regionDangerMap);
        Map typeDangerMap = selectTroubleTypeDangers(companyId);
        //类别隐患柱状图数据
        map.put("typeDangerMap", typeDangerMap);
        Map dangerTrendMap = selectMonthlyDangers(companyId);
        //隐患趋势折线图数据
        map.put("dangerTrendMap", dangerTrendMap);
        List<RiskDomain> deviceRiskPointList = reportMapper.selectRiskPoint(1, companyId);
        Map deviceRiskPointMap = handlePublicityRiskPoint(deviceRiskPointList);
        //设备设施风险单元柱状图数据
        map.put("deviceRiskPointMap", deviceRiskPointMap);
        List<RiskDomain> workRiskPointList = reportMapper.selectRiskPoint(2, companyId);
        Map workRiskPointMap = handlePublicityRiskPoint(workRiskPointList);
        //作业活动风险单元柱状图数据
        map.put("workRiskPointMap", workRiskPointMap);
        List<RiskDomain> craftRiskPointList = reportMapper.selectRiskPoint(3, companyId);
        Map craftRiskPointMap = handlePublicityRiskPoint(craftRiskPointList);
        //工艺节点风险单元柱状图数据
        map.put("craftRiskPointMap", craftRiskPointMap);
        return map;
    }
 
    private Map handlePublicityRiskPoint(List<RiskDomain> list) {
        ArrayList<String> reportName = new ArrayList<>();
        ArrayList<Integer> reportCount = new ArrayList<>();
        list.forEach(drp -> {
            reportName.add(drp.getName());
            reportCount.add(drp.getCount());
        });
        HashMap<String, List> listHashMap = new HashMap<>();
        listHashMap.put("riskPointName", reportName);
        listHashMap.put("riskPointCount", reportCount);
        return listHashMap;
    }
 
    public Map selectReportCount(long companyId, long userId) {
        int identityCount = reportMapper.selectRiskIdentityCount(companyId, userId);
        int evaluationCount = reportMapper.selectRiskEvaluationCount(userId);
        int reviewCount = reportMapper.selectRiskReviewCount(userId);
        int troubleCheckCount = reportMapper.selectTroubleCheckCount(userId);
        int troubleReportCount = reportMapper.selectTroubleReportCount(userId);
        int troubleExamineCount = reportMapper.selectTroubleExamineCount(userId);
        int troubleRectifyCount = reportMapper.selectTroubleRectifyCount(userId);
        int troubleAcceptCount = reportMapper.selectTroubleAcceptCount(userId);
        HashMap<String, Integer> countReport = new HashMap<>();
        countReport.put("identityCount", identityCount);
        countReport.put("evaluationCount", evaluationCount);
        countReport.put("reviewCount", reviewCount);
        countReport.put("troubleCheckCount", troubleCheckCount);
        countReport.put("troubleReportCount", troubleReportCount);
        countReport.put("troubleExamineCount", troubleExamineCount);
        countReport.put("troubleRectifyCount", troubleRectifyCount);
        countReport.put("troubleAcceptCount", troubleAcceptCount);
        return countReport;
    }
 
    //查询隐患区域数据
    public Map selectDangerByRegion(long companyId) {
        List<Report> reports = new ArrayList<>();
        if(147l==companyId){
            reports = reportMapper.selectDangerByRegionByCompanyId147(companyId);
        }else {
            reports = reportMapper.selectDangerByRegion(companyId);
        }
        return handleResult(reports);
    }
 
    //查询风险单元数据
    public Map selectRiskPoint(int riskType, long companyId) {
        List<RiskDomain> risks = reportMapper.selectRiskPoint(riskType, companyId);
        ArrayList<String> reportNames = new ArrayList<>();
        ArrayList<HashMap> data = new ArrayList<>();
        risks.forEach(risk -> {
            if (risk != null) {
                reportNames.add(risk.getName());
                HashMap<Object, Object> temp = new HashMap<>();
                temp.put("name", risk.getName());
                temp.put("value", risk.getCount());
                data.add(temp);
            }
        });
        HashMap<String, List> reportMap = new HashMap<>();
        reportMap.put("reportNames", reportNames);
        reportMap.put("data", data);
        return reportMap;
    }
 
    //查询风险趋势数据
    public Map selectRiskTrend(long companyId) {
        List<RiskDomain> risks = reportMapper.selectRiskTrend(companyId);
        String nowYear = DateUtils.parseDateToStr("YYYY", DateUtils.getNowDate());
        Integer startYear = Integer.parseInt(nowYear);
        if (risks != null && risks.size() != 0 && risks.get(0) != null) {
            startYear = Integer.parseInt(risks.get(0).getName());
        }
        ArrayList<Integer> reportNames = new ArrayList<>();
        ArrayList<Integer> lowRisk = new ArrayList<>();
        ArrayList<Integer> normalRisk = new ArrayList<>();
        ArrayList<Integer> middleRisk = new ArrayList<>();
        ArrayList<Integer> seriesRisk = new ArrayList<>();
        for (int i = 0; i <= Integer.parseInt(nowYear) - startYear; i++) {
            reportNames.add(startYear + i);
            lowRisk.add(0);
            normalRisk.add(0);
            middleRisk.add(0);
            seriesRisk.add(0);
        }
        risks.forEach(risk -> {
            if (risk != null) {
                int i = reportNames.indexOf(Integer.parseInt(risk.getName()));
                if (StringUtils.isNotEmpty(risk.getRiskColor())) {
                    switch (risk.getRiskColor()) {
                        case "蓝色":
                            lowRisk.set(i, risk.getCount());
                            break;
                        case "黄色":
                            normalRisk.set(i, risk.getCount());
                            break;
                        case "橙色":
                            middleRisk.set(i, risk.getCount());
                            break;
                        case "红色":
                            seriesRisk.set(i, risk.getCount());
                            break;
                    }
                }
            }
        });
        HashMap<String, List> reportMap = new HashMap<>();
        reportMap.put("reportNames", reportNames);
        reportMap.put("lowRisk", lowRisk);
        reportMap.put("normalRisk", normalRisk);
        reportMap.put("middleRisk", middleRisk);
        reportMap.put("seriesRisk", seriesRisk);
        return reportMap;
    }
 
    //查询区域风险明细
    public Map selectRiskByRegion(long companyId) {
        List<RiskDomain> risks = reportMapper.selectRiskByRegion(companyId);
        //查询公司所属二级区域
        List<RiskDomain> region = reportMapper.selectRegion(companyId);
        ArrayList<String> reportNames = new ArrayList<>();
        ArrayList<Integer> lowRisk = new ArrayList<>();
        ArrayList<Integer> normalRisk = new ArrayList<>();
        ArrayList<Integer> middleRisk = new ArrayList<>();
        ArrayList<Integer> seriesRisk = new ArrayList<>();
        for (int i = 0; i < region.size(); i++) {
            reportNames.add(region.get(i).getName());
            Integer lowRiskTemp = new Integer(0);
            Integer normalRiskTemp = new Integer(0);
            Integer middleRiskTemp = new Integer(0);
            Integer seriesRiskTemp = new Integer(0);
            for (RiskDomain risk : risks) {
                if (risk.getAncestors().contains(String.valueOf(region.get(i).getId())) || risk.getId() == region.get(i).getId()){
                    switch (risk.getRiskColor()) {
                        case "蓝色":
                            lowRiskTemp+=risk.getCount();
                            break;
                        case "黄色":
                            normalRiskTemp+=risk.getCount();
                            break;
                        case "橙色":
                            middleRiskTemp+=risk.getCount();
                            break;
                        case "红色":
                            seriesRiskTemp+=risk.getCount();
                            break;
                    }
                }
            }
            lowRisk.add(lowRiskTemp);
            normalRisk.add(normalRiskTemp);
            middleRisk.add(middleRiskTemp);
            seriesRisk.add(seriesRiskTemp);
        }
        HashMap<String, List> reportMap = new HashMap<>();
        reportMap.put("reportNames", reportNames);
        reportMap.put("lowRisk", lowRisk);
        reportMap.put("normalRisk", normalRisk);
        reportMap.put("middleRisk", middleRisk);
        reportMap.put("seriesRisk", seriesRisk);
        return reportMap;
    }
 
    //查询部门风险明细
    public Map selectRiskByDept(long companyId) {
        List<RiskDomain> risks = reportMapper.selectRiskByDept(companyId);
        List<RiskDomain> dept = reportMapper.selectDept(companyId);
        return handleRiskData(risks, dept);
    }
 
    //处理风险查询数据
    private Map handleRiskData(List<RiskDomain> risks, List<RiskDomain> temp) {
        ArrayList<Long> reportId = new ArrayList<>();
        ArrayList<String> reportNames = new ArrayList<>();
        ArrayList<Integer> lowRisk = new ArrayList<>();
        ArrayList<Integer> normalRisk = new ArrayList<>();
        ArrayList<Integer> middleRisk = new ArrayList<>();
        ArrayList<Integer> seriesRisk = new ArrayList<>();
        for (int i = 0; i < temp.size(); i++) {
            reportId.add(temp.get(i).getId());
            reportNames.add(temp.get(i).getName());
            lowRisk.add(0);
            normalRisk.add(0);
            middleRisk.add(0);
            seriesRisk.add(0);
        }
        risks.forEach(risk -> {
            if (risk != null) {
                int i = reportId.indexOf(risk.getId());
                if (StringUtils.isNotEmpty(risk.getRiskColor())) {
                    switch (risk.getRiskColor()) {
                        case "蓝色":
                            lowRisk.set(i, risk.getCount());
                            break;
                        case "黄色":
                            normalRisk.set(i, risk.getCount());
                            break;
                        case "橙色":
                            middleRisk.set(i, risk.getCount());
                            break;
                        case "红色":
                            seriesRisk.set(i, risk.getCount());
                            break;
                    }
                }
            }
        });
        HashMap<String, List> reportMap = new HashMap<>();
        reportMap.put("reportNames", reportNames);
        reportMap.put("lowRisk", lowRisk);
        reportMap.put("normalRisk", normalRisk);
        reportMap.put("middleRisk", middleRisk);
        reportMap.put("seriesRisk", seriesRisk);
        return reportMap;
    }
 
    //查询部门隐患明细
    public Map selectDeptDangers(long companyId) {
        List<Report> reports = reportMapper.selectDeptDangers(companyId);
        return handleResult(reports);
    }
 
    //查询隐患类别隐患明细
    public Map selectTroubleTypeDangers(long companyId) {
        List<Report> reports = reportMapper.selectTroubleTypeDangers(companyId);
        return handleResult(reports);
    }
 
    //查询按月统计隐患数据
    public Map selectMonthlyDangers(long companyId) {
        Date date = DateUtils.addMonths(DateUtils.getNowDate(), -12);
        List<DangerByTime> dangerByTimes = reportMapper.selectDangersByMonths(date, companyId);
        return handleMonthlyDangers(date, dangerByTimes);
    }
 
    //查询按年统计隐患数据
    public Map selectYearlyDangers(long companyId) {
        List<DangerByTime> dangerByTimes = reportMapper.selectDangersByYear(companyId);
        return handleYearlyDangers(dangerByTimes);
    }
 
    //处理按年统计报表数据
    private Map handleYearlyDangers(List<DangerByTime> list) {
        String nowYear = DateUtils.parseDateToStr("YYYY", DateUtils.getNowDate());
        Long allDangers = 0l;
        String startYear = nowYear;
        if (list.size() != 0) {
            startYear = list.get(0).getDateTime();
            for (int i = 0; i < list.size(); i++) {
                allDangers += list.get(i).getCount();
            }
        }
        ArrayList<Integer> reportNames = new ArrayList<>();
        ArrayList<Long> normalDanger = new ArrayList<>();
        ArrayList<Long> highDanger = new ArrayList<>();
        for (int i = 0; i <= Integer.parseInt(nowYear) - Integer.parseInt(startYear); i++) {
            Integer temp = Integer.parseInt(startYear) + i;
            reportNames.add(temp);
            normalDanger.add(0l);
            highDanger.add(0l);
            int finalI = i;
            list.forEach(dt -> {
                if (dt != null) {
                    if (temp.toString().equals(dt.getDateTime()) && dt.getDangerLevel() != null) {
                        switch (dt.getDangerLevel()) {
                            case "0":
                                normalDanger.set(finalI, dt.getCount());
                                break;
                            case "1":
                                highDanger.set(finalI, dt.getCount());
                                break;
                        }
                    }
                }
            });
        }
        HashMap<String, Object> reportMap = new HashMap<>();
        reportMap.put("reportNames", reportNames);
        reportMap.put("normalDanger", normalDanger);
        reportMap.put("highDanger", highDanger);
        reportMap.put("allDangers", allDangers);
        return reportMap;
    }
 
    //处理按月统计报表数据
    private Map handleMonthlyDangers(Date date, List<DangerByTime> list) {
        ArrayList<String> reportNames = new ArrayList<>();
        ArrayList<Long> normalDanger = new ArrayList<>();
        ArrayList<Long> highDanger = new ArrayList<>();
        for (int i = 0; i < 12; i++) {
            date = DateUtils.addMonths(date, 1);
            String str = DateUtils.parseDateToStr("YYYY-MM", date);
            reportNames.add(str);
            normalDanger.add(0l);
            highDanger.add(0l);
            int finalI = i;
            list.forEach(dt -> {
                if (dt != null) {
                    if (str.equals(dt.getDateTime()) && dt.getDangerLevel() != null) {
                        switch (dt.getDangerLevel()) {
                            case "0":
                                normalDanger.set(finalI, dt.getCount());
                                break;
                            case "1":
                                highDanger.set(finalI, dt.getCount());
                                break;
                        }
                    }
                }
            });
        }
        HashMap<String, List> reportMap = new HashMap<>();
        reportMap.put("reportNames", reportNames);
        reportMap.put("normalDanger", normalDanger);
        reportMap.put("highDanger", highDanger);
        return reportMap;
    }
 
    //处理查询结果为map返回
    private Map handleResult(List<Report> reports) {
        ArrayList<String> reportNames = new ArrayList<>();
        ArrayList<String> normalDanger = new ArrayList<>();
        ArrayList<String> highDanger = new ArrayList<>();
        reports.forEach(report -> {
            if (report != null) {
                reportNames.add(report.getReportName());
                AtomicInteger normalCount = new AtomicInteger();
                AtomicInteger highCount = new AtomicInteger();
                if (report.getDangers() != null) {
                    report.getDangers().forEach(danger -> {
                        if (StringUtils.isNotEmpty(danger.getDangerLevel()) && "1".equals(danger.getWhetherDanger())
                                && (StringUtils.isNotEmpty(danger.getRectifyUserName()))) {
                            switch (danger.getDangerLevel()) {
                                case "0":
                                    normalCount.addAndGet(1);
                                    break;
                                case "1":
                                    highCount.getAndIncrement();
                                    break;
                            }
                        }
                    });
                }
                normalDanger.add(normalCount.toString());
                highDanger.add(highCount.toString());
            }
        });
        HashMap<String, List> reportMap = new HashMap<>();
        reportMap.put("reportNames", reportNames);
        reportMap.put("normalDanger", normalDanger);
        reportMap.put("highDanger", highDanger);
        return reportMap;
    }
}