package com.estate.expert.admin.service.impl;
|
|
import com.alibaba.excel.util.StringUtils;
|
import com.alibaba.fastjson.JSONObject;
|
import com.estate.expert.admin.domain.business.client.Client;
|
import com.estate.expert.admin.domain.business.client.ClientRepository;
|
import com.estate.expert.admin.domain.business.device.Device;
|
import com.estate.expert.admin.domain.business.device.DeviceRepository;
|
import com.estate.expert.admin.domain.business.device.DeviceType;
|
import com.estate.expert.admin.domain.business.sign.project.ProjectSignRecord;
|
import com.estate.expert.admin.domain.business.sign.project.ProjectSignRecordRepository;
|
import com.estate.expert.admin.domain.common.request.PageReq;
|
import com.estate.expert.admin.domain.common.request.ScreenRangeRequest;
|
import com.estate.expert.admin.domain.common.request.ScreenRequest;
|
import com.estate.expert.admin.domain.exam.eval.fuzzy.EvalFuzzyResult;
|
import com.estate.expert.admin.domain.exam.eval.fuzzy.EvalFuzzyResultRepository;
|
import com.estate.expert.admin.domain.exam.eval.fuzzy.FuzzyResult;
|
import com.estate.expert.admin.domain.exam.eval.fuzzy.FuzzyValue;
|
import com.estate.expert.admin.domain.exam.record.error.ErrorLevel;
|
import com.estate.expert.admin.domain.exam.record.error.ErrorRecord;
|
import com.estate.expert.admin.domain.exam.record.error.ErrorRecordDto;
|
import com.estate.expert.admin.domain.exam.record.error.ErrorRecordRepository;
|
import com.estate.expert.admin.domain.exam.task.check.CheckTask;
|
import com.estate.expert.admin.domain.plan.Plan;
|
import com.estate.expert.admin.domain.plan.PlanType;
|
import com.estate.expert.admin.domain.project.Project;
|
import com.estate.expert.admin.domain.project.ProjectDto;
|
import com.estate.expert.admin.domain.project.detail.AddressInfo;
|
import com.estate.expert.admin.domain.project.enums.ProjectType;
|
import com.estate.expert.admin.domain.standard.hierachy.Hierarchy;
|
import com.estate.expert.admin.domain.standard.hierachy.HierarchyData;
|
import com.estate.expert.admin.domain.standard.problem.Problem;
|
import com.estate.expert.admin.domain.user.User;
|
import com.estate.expert.admin.domain.user.UserRepository;
|
import com.estate.expert.admin.service.*;
|
import com.estate.expert.admin.service.screen.ScreenService;
|
import com.estate.expert.admin.utils.tree.TreeNode;
|
import com.estate.expert.admin.utils.tree.helper.TreeHelper;
|
import io.swagger.models.auth.In;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.data.domain.Page;
|
import org.springframework.data.domain.PageRequest;
|
import org.springframework.data.domain.Sort;
|
import org.springframework.stereotype.Service;
|
import javax.annotation.Resource;
|
import java.math.BigDecimal;
|
import java.time.LocalDateTime;
|
import java.time.LocalTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* 大屏服务实现
|
*/
|
@Slf4j
|
@Service
|
public class ScreenServiceImpl implements ScreenService {
|
@Resource
|
private ErrorRecordRepository errorRecordRepository;
|
|
@Resource
|
private EvalFuzzyResultRepository evalFuzzyResultRepository;
|
|
@Resource
|
private DeviceRepository deviceRepository;
|
|
@Resource
|
private HierarchyService hierarchyService;
|
|
@Resource
|
private ProjectSignRecordRepository projectSignRecordRepository;
|
|
@Resource
|
private ClientRepository clientRepository;
|
|
@Resource
|
private UserRepository userRepository;
|
|
@Resource
|
private UserService userService;
|
|
@Resource
|
private ClientService clientService;
|
|
@Resource
|
private ProjectService projectService;
|
|
@Resource
|
private ErrorRecordService errorRecordService;
|
|
|
@Override
|
public Map<String, Object> dataIntegration(ScreenRangeRequest screenRangeRequest) {
|
//什么都不传递就是当天
|
List<LocalDateTime> startTimeAndEndTime = getStartTimeAndEndTime(screenRangeRequest);
|
LocalDateTime startTime = startTimeAndEndTime.get(0);
|
LocalDateTime endTime = startTimeAndEndTime.get(1);
|
Map<String, Object> stringObjectHashMap = new HashMap<>();
|
List<ProjectSignRecord> projectSignRecords = projectSignRecordRepository.listSignRecord(startTime, endTime);
|
List<EvalFuzzyResult> evalFuzzyResults = evalFuzzyResultRepository.todayInspectionSituationByDate(null,startTime, endTime);
|
Set<Integer> ids = new HashSet<>();
|
//设备检查项次
|
int equipmentInspectionItems = 0;
|
for (EvalFuzzyResult evalFuzzyResult : evalFuzzyResults) {
|
Map<Integer, FuzzyResult> deviceResMap = evalFuzzyResult.getDeviceResMap();
|
if(null!=deviceResMap){
|
Set<Integer> integers = deviceResMap.keySet();
|
for (Integer integer : integers) {
|
ids.add(integer);
|
}
|
for (Integer ignored : deviceResMap.keySet()) {
|
equipmentInspectionItems++;
|
}
|
}
|
}
|
List<Device> deviceByIds = deviceRepository.findDeviceByIds(ids.stream().toList());
|
Map<String, List<Device>> deviceGroupBy = deviceByIds.stream().collect(Collectors.groupingBy(res -> res.getProperties().get("工程起重机械租赁单位")));
|
int hiddenDangers = 0;
|
HashMap<String, Integer> deviceStatistics = new HashMap<>();
|
for (DeviceType value : DeviceType.values()) {
|
deviceStatistics.put(value.getDesc(),0);
|
}
|
Map<String, Integer> safetyHazards = new HashMap<>();
|
ErrorLevel[] values = ErrorLevel.values();
|
for (ErrorLevel value : values) {
|
safetyHazards.put(value.getDesc(),0);
|
}
|
for (EvalFuzzyResult evalFuzzyResult : evalFuzzyResults) {
|
FuzzyResult systemRes = evalFuzzyResult.getSystemRes();
|
int[] totalErrorCounts = systemRes.getContent().getData().getTotalErrorCounts();
|
hiddenDangers += Arrays.stream(totalErrorCounts).sum();
|
for (int i = 0; i < values.length; i++) {
|
Integer count = safetyHazards.get(values[i].getDesc());
|
count += totalErrorCounts[i];
|
safetyHazards.put(values[i].getDesc(),count);
|
}
|
Map<Integer, FuzzyResult> deviceResMap = evalFuzzyResult.getDeviceResMap();
|
for (Integer i : deviceResMap.keySet()) {
|
FuzzyResult fuzzyResult = deviceResMap.get(i);
|
hiddenDangers += Arrays.stream(fuzzyResult.getContent().getData().getTotalErrorCounts()).sum();
|
List<Device> collect = deviceByIds.stream().filter(res -> res.getId() == i).collect(Collectors.toList());
|
if(collect.size()>0){
|
Device device = collect.get(0);
|
Integer typeCount = deviceStatistics.get(device.getType().getDesc());
|
typeCount ++;
|
deviceStatistics.put(device.getType().getDesc(),typeCount);
|
}
|
}
|
}
|
List<Project> projectList = evalFuzzyResults.stream().map(EvalFuzzyResult::getProject).collect(Collectors.toList());
|
List<Integer> projectListById = projectList.stream().collect(Collectors.groupingBy(Project::getId)).keySet().stream().toList();
|
Map<ProjectType, List<Project>> collect = projectList.stream().collect(Collectors.groupingBy(res -> res.getType()));
|
stringObjectHashMap.put("patrolItems",projectListById.size());//巡查项目
|
stringObjectHashMap.put("patrolTeam",projectList.size());//巡查组
|
stringObjectHashMap.put("hiddenDangers",hiddenDangers);//隐患问题
|
Map<String, Object> projectStatistics = new HashMap<>();
|
for (ProjectType projectType : collect.keySet()) {
|
projectStatistics.put(projectType.getDesc(),collect.get(projectType).size());
|
}
|
int plannedAttendance = 0;
|
int actualAttendance = 0;
|
Map<Integer, List<ProjectSignRecord>> projectSignRecordById = projectSignRecords.stream().collect(Collectors.groupingBy(res -> res.getCreator().getId()));
|
for (Integer id : projectSignRecordById.keySet()) {
|
Map<Integer, List<ProjectSignRecord>> process = projectSignRecordById.get(id).stream().collect(Collectors.groupingBy(res -> res.getProject().getId()));
|
//计划考勤
|
List<EvalFuzzyResult> collectProcess = evalFuzzyResults.stream().filter(res -> process.keySet().contains(res.getProject().getId())).collect(Collectors.toList());
|
//这个就是实际考勤
|
if(collectProcess.size()>0){
|
actualAttendance++;
|
}
|
plannedAttendance++;
|
}
|
HashMap<String, Integer> achievement = new HashMap<>();
|
achievement.put("project",projectListById.size());
|
achievement.put("record",evalFuzzyResults.size());
|
achievement.put("hiddenDangers",hiddenDangers);
|
HashMap<String, Integer> personnelAttendance = new HashMap<>();
|
personnelAttendance.put("plannedAttendance",plannedAttendance);
|
personnelAttendance.put("actualAttendance",actualAttendance);
|
stringObjectHashMap.put("personnelAttendance",personnelAttendance);
|
stringObjectHashMap.put("projectStatistics",projectStatistics);
|
stringObjectHashMap.put("deviceStatistics",deviceStatistics);
|
stringObjectHashMap.put("safetyHazards",safetyHazards);
|
stringObjectHashMap.put("achievement",achievement);
|
HashMap<String, Integer> device = new HashMap<>();
|
device.put("lessor",deviceGroupBy.keySet().size());
|
device.put("equipmentInspectionItems",equipmentInspectionItems);
|
stringObjectHashMap.put("device",device);
|
return stringObjectHashMap;
|
}
|
|
@Override
|
public List<Map<String, Object>> attendance(ScreenRangeRequest screenRangeRequest) {
|
List<LocalDateTime> startTimeAndEndTime = getStartTimeAndEndTime(screenRangeRequest);
|
LocalDateTime startTime = startTimeAndEndTime.get(0);
|
LocalDateTime endTime = startTimeAndEndTime.get(1);
|
//获取到当前的时间的考勤
|
List<ProjectSignRecord> projectSignRecords = projectSignRecordRepository.listSignRecord(startTime, endTime);
|
List<Integer> projectIds = projectSignRecords.stream().map(res -> res.getProject().getId()).collect(Collectors.toList());
|
List<EvalFuzzyResult> evalFuzzyResults = evalFuzzyResultRepository.getEvalFuzzyResultProjectIds(projectIds,startTime,endTime);
|
List<Map<String, Object>> maps = new ArrayList<>();
|
Map<Integer, List<ProjectSignRecord>> projectSignRecordById = projectSignRecords.stream().collect(Collectors.groupingBy(res -> res.getCreator().getId()));
|
for (Integer id : projectSignRecordById.keySet()) {
|
Map<Integer, List<ProjectSignRecord>> process = projectSignRecordById.get(id).stream().collect(Collectors.groupingBy(res -> res.getProject().getId()));
|
//计划考勤
|
List<EvalFuzzyResult> collectProcess = evalFuzzyResults.stream().filter(res -> process.keySet().contains(res.getProject().getId())).collect(Collectors.toList());
|
//这个就是实际考勤
|
ProjectSignRecord projectSignRecord = projectSignRecordById.get(id).get(0);
|
Map<String, Object> stringObjectHashMap = new HashMap<>();
|
stringObjectHashMap.put("clientName",projectSignRecord.getProject().getClient().getName());
|
stringObjectHashMap.put("name",projectSignRecord.getCreator().getName());
|
stringObjectHashMap.put("phone",projectSignRecord.getCreator().getMobile());
|
stringObjectHashMap.put("checkTime",projectSignRecord.getCreateTime());
|
if(collectProcess.size()>0){
|
stringObjectHashMap.put("inspectionTime",collectProcess.get(0).getCreateTime());
|
}else{
|
stringObjectHashMap.put("inspectionTime","未打卡");
|
}
|
stringObjectHashMap.put("creatorId",projectSignRecord.getCreator().getId());
|
maps.add(stringObjectHashMap);
|
}
|
return maps;
|
}
|
|
@Override
|
public List<Map<String, Object>> basedInspectionResults(String name, Integer creatorId,ScreenRangeRequest screenRangeRequest) {
|
List<LocalDateTime> startTimeAndEndTime = getStartTimeAndEndTime(screenRangeRequest);
|
LocalDateTime startTime = startTimeAndEndTime.get(0);
|
LocalDateTime endTime = startTimeAndEndTime.get(1);
|
//如果没有传入姓名或者id 那就查询所有人 然后时间是到今日
|
List<Map<String, Object>> maps = new ArrayList<>();
|
List<User> userList = new ArrayList<>();
|
if(null== name && null == creatorId){
|
List<User> userLists = userRepository.findNoDeleted();
|
userList = userLists;
|
}else{
|
if(StringUtils.isEmpty(name)){
|
Optional<User> users = userRepository.findById(creatorId);
|
userList.add(users.get());
|
}else{
|
userList = userRepository.findByNameLike(name);
|
}
|
}
|
List<Integer> userIds = userList.stream().map(User::getId).collect(Collectors.toList());
|
List<ErrorRecord> errorRecords = errorRecordRepository.inspectionResultsBasedOnPersonnel(userIds, startTime, endTime);
|
Map<Integer, List<ErrorRecord>> collect = errorRecords.parallelStream().collect(Collectors.groupingBy(res -> res.getCreator().getId()));
|
for (User user : userList) {
|
Map<String, Object> stringObjectHashMap = new HashMap<>();
|
List<ErrorRecord> errorRecordLists = collect.get(user.getId());
|
Map<String, List<ErrorRecord>> collected = null;
|
if(null!=errorRecordLists){
|
collected = errorRecordLists.stream().collect(Collectors.groupingBy(res -> res.getLevel().getDesc()));
|
}
|
ErrorLevel[] values = ErrorLevel.values();
|
for (ErrorLevel value : values) {
|
String desc = value.getDesc();
|
if(null == collected){
|
stringObjectHashMap.put(desc,0);
|
}else{
|
List<ErrorRecord> errorRecordsLists = collected.get(desc);
|
if(null!=errorRecordsLists){
|
stringObjectHashMap.put(desc,errorRecordsLists.size());
|
}else{
|
stringObjectHashMap.put(desc,0);
|
}
|
}
|
}
|
stringObjectHashMap.put("userId",user.getId());
|
stringObjectHashMap.put("name",user.getName());
|
maps.add(stringObjectHashMap);
|
}
|
return maps;
|
}
|
|
@Override
|
public Map<String,Object> rentalManufacturerMalfunction(ScreenRangeRequest screenRangeRequest){
|
HashMap<String, Object> dataMap = new HashMap<>();
|
List<LocalDateTime> startTimeAndEndTime = getStartTimeAndEndTime(screenRangeRequest);
|
LocalDateTime startTime = startTimeAndEndTime.get(0);
|
LocalDateTime endTime = startTimeAndEndTime.get(1);
|
List<Device> devices = deviceRepository.findDevices();
|
Map<String, List<Device>> deviceByProperties = devices.stream().filter(res -> {
|
Map<String, String> properties = res.getProperties();
|
if (null != properties) {
|
if (null != properties.get("工程起重机械租赁单位")) {
|
return true;
|
}
|
}
|
return false;
|
}).collect(Collectors.groupingBy(res -> res.getProperties().get("工程起重机械租赁单位")));
|
//根据时间获取这些数据
|
List<EvalFuzzyResult> evalFuzzyResults = evalFuzzyResultRepository.todayInspectionSituationByDateByContainDeviceRes(null,startTime, endTime);
|
List<Map<Integer, FuzzyResult>> devicesMaps = evalFuzzyResults.stream().map(EvalFuzzyResult::getDeviceResMap).collect(Collectors.toList());
|
ArrayList<HashMap<String, Object>> hashMaps = new ArrayList<>();
|
for (String renting : deviceByProperties.keySet()) {
|
HashMap<String, Object> stringObjectHashMap = new HashMap<>();
|
//renting 租聘厂商
|
int dangerLevelByOne = 0;
|
int failureRate = 0;
|
int total = 0;
|
HashMap<String, Integer> statistics = new HashMap<>();
|
HashMap<String, Integer> statisticsFailureRate = new HashMap<>();
|
HashMap<String, Integer> statisticsDangerLevelByOne = new HashMap<>();
|
for (DeviceType value : DeviceType.values()) {
|
statistics.put(value.getDesc(),0);
|
statisticsFailureRate.put(value.getDesc(),0);
|
statisticsDangerLevelByOne.put(value.getDesc(),0);
|
}
|
List<Device> deviceList = deviceByProperties.get(renting);
|
for (Map<Integer, FuzzyResult> devicesMap : devicesMaps) {
|
for (Device device : deviceList) {
|
FuzzyResult fuzzyResult = devicesMap.get(device.getId());
|
if(null != fuzzyResult){
|
int[] totalErrorCounts = fuzzyResult.getContent().getData().getTotalErrorCounts();
|
if(totalErrorCounts[0]>0){
|
//说明有一级故障率
|
dangerLevelByOne++;
|
Integer count = statisticsDangerLevelByOne.get(device.getType().getDesc());
|
if(null!=count){
|
count++;
|
statisticsDangerLevelByOne.put(device.getType().getDesc(),count);
|
}
|
}
|
if(Arrays.stream(totalErrorCounts).sum()>0){
|
failureRate++;
|
Integer count = statisticsFailureRate.get(device.getType().getDesc());
|
if(null!=count){
|
count++;
|
statisticsFailureRate.put(device.getType().getDesc(),count);
|
}
|
}
|
total++;
|
Integer count = statistics.get(device.getType().getDesc());
|
if(null!=count){
|
count++;
|
statistics.put(device.getType().getDesc(),count);
|
}
|
}
|
}
|
}
|
if(failureRate !=0 && total != 0 && dangerLevelByOne!=0){
|
double failurePercentage = (failureRate / total) * 100;
|
double dangerLevelByOnePercentage = (dangerLevelByOne / total) * 100;
|
stringObjectHashMap.put("failurePercentage",new BigDecimal(failurePercentage).setScale(2,BigDecimal.ROUND_HALF_UP)+"%");
|
stringObjectHashMap.put("dangerLevelByOnePercentage",new BigDecimal(dangerLevelByOnePercentage).setScale(2,BigDecimal.ROUND_HALF_UP)+"%");
|
}else{
|
stringObjectHashMap.put("failurePercentage","0%");
|
stringObjectHashMap.put("dangerLevelByOnePercentage","0%");
|
}
|
ArrayList<HashMap<String, Object>> equipmentStatistics = new ArrayList<>();
|
Integer totalCount = 0;
|
Integer totalNormal = 0;
|
Integer totalFailure = 0;
|
for (DeviceType value : DeviceType.values()) {
|
HashMap<String, Object> equipmentStatistic = new HashMap<>();
|
Integer count = statistics.get(value.getDesc());
|
Integer failureRateCount = statisticsFailureRate.get(value.getDesc());
|
Integer normal = count - failureRateCount;
|
equipmentStatistic.put("renting",value.getDesc());
|
equipmentStatistic.put("inspectionFrequency",count);
|
equipmentStatistic.put("failure",failureRateCount);
|
equipmentStatistic.put("normal",normal);
|
equipmentStatistics.add(equipmentStatistic);
|
totalFailure+=failureRateCount;
|
totalNormal+=normal;
|
totalCount+=count;
|
}
|
stringObjectHashMap.put("equipmentStatistics",equipmentStatistics);
|
stringObjectHashMap.put("renting",renting);
|
stringObjectHashMap.put("total",totalCount);
|
stringObjectHashMap.put("totalNormal",totalNormal);
|
stringObjectHashMap.put("totalFailure",totalFailure);
|
hashMaps.add(stringObjectHashMap);
|
}
|
List<ArrayList<Map<String, Object>>> equipmentStatistics = hashMaps.stream().map(res -> (ArrayList<Map<String, Object>>) res.get("equipmentStatistics")).collect(Collectors.toList());
|
Map<String, List<Map<String, Object>>> rentingMaps = equipmentStatistics.stream()
|
.flatMap(subList -> subList.stream())
|
.collect(Collectors.groupingBy(
|
map -> (String) map.get("renting")));
|
ArrayList<HashMap<String, Object>> totalEquipmentStatisticsMaps = new ArrayList<>();
|
for (String deviceTypeDesc : rentingMaps.keySet()) {
|
HashMap<String, Object> totalEquipmentStatistics = new HashMap<>();
|
List<Map<String, Object>> mapsProcess = rentingMaps.get(deviceTypeDesc);
|
int inspectionFrequency = mapsProcess.stream().mapToInt(res -> (Integer) res.get("inspectionFrequency")).sum();
|
int failure = mapsProcess.stream().mapToInt(res -> (Integer) res.get("failure")).sum();
|
int normal = mapsProcess.stream().mapToInt(res -> (Integer) res.get("normal")).sum();
|
totalEquipmentStatistics.put("renting",deviceTypeDesc);
|
totalEquipmentStatistics.put("inspectionFrequency",inspectionFrequency);
|
totalEquipmentStatistics.put("failure",failure);
|
totalEquipmentStatistics.put("normal",normal);
|
totalEquipmentStatisticsMaps.add(totalEquipmentStatistics);
|
}
|
dataMap.put("total",hashMaps.stream().mapToInt(res->(Integer) res.get("total")).sum());
|
dataMap.put("totalNormal",hashMaps.stream().mapToInt(res->(Integer) res.get("totalNormal")).sum());
|
dataMap.put("totalFailure",hashMaps.stream().mapToInt(res->(Integer) res.get("totalFailure")).sum());
|
dataMap.put("totalEquipmentStatistics",totalEquipmentStatisticsMaps);
|
dataMap.put("result",hashMaps);
|
return dataMap;
|
// Map<String, Device> stringDeviceHashMap = new HashMap<>();
|
// for (Device device : devices) {
|
// Map<String, String> properties = device.getProperties();
|
// if(null!=properties){
|
// String rental = properties.get("工程起重机械租赁单位");
|
// if(null!=rental && !rental.equals("null")){
|
// stringDeviceHashMap.put(rental,device);
|
// }
|
// }
|
// }
|
// List<EvalFuzzyResult> evalFuzzyResults = evalFuzzyResultRepository.todayInspectionSituationByDate(null,startTime, endTime);
|
// HashMap<String, Map<String,Double>> statisticsProcess = new HashMap<>();
|
// HashMap<String, Object> stringObjectHashMap = new HashMap<>();
|
// int totalAll = 0;
|
// int faultTotal = 0;
|
// if(evalFuzzyResults.size()>0){
|
// DeviceType[] values = DeviceType.values();
|
// HashMap<String, Map<String,Double>> statistics = new HashMap<>();
|
// for (String rentalVendors : stringDeviceHashMap.keySet()) {
|
// HashMap<String, Object> rate = new HashMap<>();
|
// Device device = stringDeviceHashMap.get(rentalVendors);
|
// double total = 0;
|
// double fault = 0;
|
// double danger = 0;
|
// for (EvalFuzzyResult evalFuzzyResult : evalFuzzyResults) {
|
// Map<Integer, FuzzyResult> deviceResMap = evalFuzzyResult.getDeviceResMap();
|
// //获取到当前的
|
// FuzzyResult fuzzyResult = deviceResMap.get(device.getId());
|
// if(null!=fuzzyResult){
|
// int[] totalErrorCounts = fuzzyResult.getContent().getData().getTotalErrorCounts();
|
// int sum = Arrays.stream(totalErrorCounts).sum();
|
// if(sum>0){
|
// //就代表有隐患有隐患就故障了
|
// fault++;
|
// faultTotal++;
|
// }
|
// if(totalErrorCounts[0] >0 ){
|
// danger++;
|
// }
|
// }
|
// total++;
|
// totalAll++;
|
// }
|
// double equipmentFailureRate = (fault / total) * 100;
|
// double gradeHazardRate = (danger / total) * 100;
|
// rate.put("equipmentFailureRate",equipmentFailureRate);
|
// rate.put("gradeHazardRate",gradeHazardRate);
|
// stringObjectHashMap.put(rentalVendors,rate);
|
// Map<String, Double> stringObjectMap = statistics.get(device.getType().getDesc());
|
// if(null == stringObjectMap){
|
// HashMap<String, Double> deviceStatistics = new HashMap<>();
|
// deviceStatistics.put("normal",(total - fault));
|
// deviceStatistics.put("total",total);
|
// deviceStatistics.put("fault",fault);
|
// statistics.put(device.getType().getDesc(),deviceStatistics);
|
// }else{
|
// Double normal = stringObjectMap.get("normal");
|
// Double totalProcess = stringObjectMap.get("total");
|
// Double faultProcess = stringObjectMap.get("fault");
|
// normal += (total - fault);
|
// totalProcess += total;
|
// faultProcess += fault;
|
// stringObjectMap.put("normal",normal);
|
// stringObjectMap.put("total",totalProcess);
|
// stringObjectMap.put("fault",faultProcess);
|
// statistics.put(device.getType().getDesc(),stringObjectMap);
|
// }
|
// }
|
//
|
// for (DeviceType value : values) {
|
// Map<String, Double> stringDoubleMap = statistics.get(value.getDesc());
|
// if(null==stringDoubleMap){
|
// HashMap<String, Double> deviceStatistics = new HashMap<>();
|
// deviceStatistics.put("normal",0.0);
|
// deviceStatistics.put("total",0.0);
|
// deviceStatistics.put("fault",0.0);
|
// statisticsProcess.put(value.getDesc(),deviceStatistics);
|
// }else{
|
// statisticsProcess.put(value.getDesc(),stringDoubleMap);
|
// }
|
// }
|
// }
|
// HashMap<String, Object> resultMap = new HashMap<>();
|
// resultMap.put("devices",stringObjectHashMap);
|
// resultMap.put("equipmentStatistics",statisticsProcess);
|
// resultMap.put("normal",(totalAll-faultTotal));
|
// resultMap.put("fault",faultTotal);
|
// return resultMap;
|
}
|
|
public Map<String,Object> inspectionSituation(ScreenRangeRequest screenRangeRequest){
|
Map<String, Object> mapData = new HashMap<>();
|
List<LocalDateTime> startTimeAndEndTime = getStartTimeAndEndTime(screenRangeRequest);
|
LocalDateTime startTime = startTimeAndEndTime.get(0);
|
LocalDateTime endTime = startTimeAndEndTime.get(1);
|
List<EvalFuzzyResult> evalFuzzyResults = evalFuzzyResultRepository.todayInspectionSituation(startTime, endTime);
|
//获取所有的user和teamLeader
|
Map<Integer, List<EvalFuzzyResult>> collect = evalFuzzyResults.stream().collect(Collectors.groupingBy(res -> res.getProject().getId()));
|
List<Map<String, Object>> maps = new ArrayList<>();
|
for (Integer i : collect.keySet()) {
|
Map<String, Object> stringObjectHashMap = new HashMap<>();
|
//获取这个对象 目前不管多个只需1
|
EvalFuzzyResult evalFuzzyResult = collect.get(i).get(0);
|
PlanType type = evalFuzzyResult.getPlan().getType();
|
FuzzyResult systemRes = evalFuzzyResult.getSystemRes();
|
Map<Integer, FuzzyResult> deviceResMap = evalFuzzyResult.getDeviceResMap();
|
int p1 = 0;
|
int p2 = 0;
|
int p3 = 0;
|
int p4 = 0;
|
int equipmentHazards = 0;
|
for (Integer integer : deviceResMap.keySet()) {
|
int[] totalErrorCounts = deviceResMap.get(integer).getContent().getData().getTotalErrorCounts();
|
equipmentHazards += Arrays.stream(totalErrorCounts).sum();
|
p1 += totalErrorCounts[0];
|
p2 += totalErrorCounts[1];
|
p3 += totalErrorCounts[2];
|
p4 += totalErrorCounts[3];
|
}
|
int[] totalErrorCountsSys = systemRes.getContent().getData().getTotalErrorCounts();
|
p1 += totalErrorCountsSys[0];
|
p2 += totalErrorCountsSys[1];
|
p3 += totalErrorCountsSys[2];
|
p4 += totalErrorCountsSys[3];
|
int []totalErrorCounts = {p1,p2,p3,p4};
|
equipmentHazards+= Arrays.stream(systemRes.getContent().getData().getTotalErrorCounts()).sum();
|
String groupName = "";
|
if(type == PlanType.SECURITY_CHECK){
|
groupName = "安全小组";
|
}else if(type == PlanType.QUALITY_CHECK){
|
groupName = "质量小组";
|
}else if(type == PlanType.EQUIPMENT_CHECK){
|
groupName = "设备小组";
|
}
|
Project project = evalFuzzyResult.getProject();
|
//获取检查任务
|
CheckTask task = evalFuzzyResult.getTask();
|
var groupLeaders = task.getGroupLeaders();
|
var groupMembers = task.getGroupMembers();
|
String name = project.getName();
|
stringObjectHashMap.put("projectName",name);
|
stringObjectHashMap.put("groupLeaders",groupLeaders.stream().map(res->res.getName()).collect(Collectors.toList()));
|
stringObjectHashMap.put("groupMembers",groupMembers.stream().map(res->res.getName()).collect(Collectors.toList()));
|
stringObjectHashMap.put("groupName",groupName);
|
stringObjectHashMap.put("totalDanger",equipmentHazards);
|
stringObjectHashMap.put("totalErrorCounts",totalErrorCounts);
|
maps.add(stringObjectHashMap);
|
}
|
int p1 = 0;
|
int p2 = 0;
|
int p3 = 0;
|
int p4 = 0;
|
for (Map<String, Object> map : maps) {
|
Object obj = map.get("totalErrorCounts");
|
if(null!=obj){
|
int [] totalErrorCounts = (int []) obj;
|
p1 += totalErrorCounts[0];
|
p2 += totalErrorCounts[1];
|
p3 += totalErrorCounts[2];
|
p4 += totalErrorCounts[3];
|
}
|
}
|
int []totalErrorCounts = {p1,p2,p3,p4};
|
mapData.put("result",maps);
|
mapData.put("totalErrorCounts",totalErrorCounts);
|
return mapData;
|
}
|
|
public Map<String, Object> inspectionStatisticsByClient(ScreenRangeRequest screenRangeRequest){
|
List<LocalDateTime> startTimeAndEndTime = getStartTimeAndEndTime(screenRangeRequest);
|
LocalDateTime startTime = startTimeAndEndTime.get(0);
|
LocalDateTime endTime = startTimeAndEndTime.get(1);
|
Map<String, Object> stringObjectHashMap = new HashMap<>();
|
List<EvalFuzzyResult> evalFuzzyResults = evalFuzzyResultRepository.todayInspectionSituationByDate(null,startTime,endTime);
|
//检查项目统计
|
ProjectType[] projectTypes = ProjectType.values();
|
PlanType[] planTypes = PlanType.values();
|
HashMap<String, Integer> projectStatistics = new HashMap<>();
|
for (ProjectType projectType : projectTypes) {
|
projectStatistics.put(projectType.getDesc(),0);
|
}
|
HashMap<String, Integer> reportStatistics = new HashMap<>();
|
for (PlanType planType : planTypes) {
|
reportStatistics.put(planType.getDesc(),0);
|
}
|
HashMap<String, int[]> stringHashMap = new HashMap<>();
|
for (EvalFuzzyResult evalFuzzyResult : evalFuzzyResults) {
|
Integer planCount = reportStatistics.get(evalFuzzyResult.getPlan().getType().getDesc());
|
Integer projectCount = projectStatistics.get(evalFuzzyResult.getProject().getType().getDesc());
|
planCount++;
|
projectCount++;
|
reportStatistics.put(evalFuzzyResult.getPlan().getType().getDesc(),planCount);
|
projectStatistics.put(evalFuzzyResult.getProject().getType().getDesc(),projectCount);
|
FuzzyResult systemRes = evalFuzzyResult.getSystemRes();
|
TreeHelper.bfsTravel(systemRes.root(), (node) -> {
|
if(node.getDepth() == 4) {
|
//获取4级节点
|
int[] integers = stringHashMap.get(node.getName());
|
if(null == integers){
|
stringHashMap.put(node.getName(),node.getData().getTotalErrorCounts());
|
}else{
|
int[] totalErrorCounts = node.getData().getTotalErrorCounts();
|
for (int i = 0; i < totalErrorCounts.length; i++) {
|
integers[i] += totalErrorCounts[i];
|
}
|
stringHashMap.put(node.getName(),integers);
|
}
|
}
|
});
|
}
|
stringObjectHashMap.put("reportStatistics",reportStatistics);
|
stringObjectHashMap.put("projectStatistics",projectStatistics);
|
stringObjectHashMap.put("dangerData",stringHashMap);
|
return stringObjectHashMap;
|
}
|
|
public List<HashMap<String, Object>> dangerTrendWheel(Integer clientId, ScreenRangeRequest screenRangeRequest){
|
List<LocalDateTime> startTimeAndEndTime = getStartTimeAndEndTime(screenRangeRequest);
|
LocalDateTime startTime = startTimeAndEndTime.get(0);
|
LocalDateTime endTime = startTimeAndEndTime.get(1);
|
List<EvalFuzzyResult> evalFuzzyResults = evalFuzzyResultRepository.todayInspectionSituationByDate(clientId,startTime,endTime);
|
Map<Integer, List<EvalFuzzyResult>> collect = evalFuzzyResults.stream().sorted(Comparator.comparing(vl -> vl.getPlan().getId())).collect(Collectors.groupingBy(vl -> vl.getPlan().getId()));
|
List<HashMap<String, Object>> hashMaps = new ArrayList<>();
|
for (Integer i : collect.keySet()) {
|
List<EvalFuzzyResult> evalFuzzyResultsList = collect.get(i);
|
HashMap<String, int[]> parent = new HashMap<>();
|
HashMap<String, Map<String,int[]>> children = new HashMap<>();
|
for (EvalFuzzyResult evalFuzzyResult : evalFuzzyResultsList) {
|
TreeHelper.bfsTravel(evalFuzzyResult.getSystemRes().root(), (node) -> {
|
if(node.getDepth() == 4) {
|
int[] integers = parent.get(node.getName());
|
if(null == integers){
|
parent.put(node.getName(),node.getData().getTotalErrorCounts());
|
}else{
|
int[] totalErrorCounts = node.getData().getTotalErrorCounts();
|
for (int j = 0; j < totalErrorCounts.length; j++) {
|
integers[j] += totalErrorCounts[j];
|
}
|
parent.put(node.getName(),integers);
|
}
|
}
|
});
|
}
|
for (EvalFuzzyResult evalFuzzyResult : evalFuzzyResultsList) {
|
TreeHelper.bfsTravel(evalFuzzyResult.getSystemRes().root(), (node) -> {
|
if(node.getDepth() == 6) {
|
//获取四级的
|
TreeNode<FuzzyValue> parentNode = node.getParent().getParent();
|
Map<String, int[]> stringIntegerMap = children.get(parentNode.getName());
|
HashMap<String, int[]> stringHashMap = new HashMap<>();
|
if(null == stringIntegerMap){
|
stringHashMap.put(node.getName(),node.getData().getTotalErrorCounts());
|
children.put(parentNode.getName(),stringHashMap);
|
}else{
|
int[] integers = stringIntegerMap.get(node.getName());
|
if(null == integers){
|
stringIntegerMap.put(node.getName(),node.getData().getTotalErrorCounts());
|
children.put(parentNode.getName(),stringIntegerMap);
|
}else{
|
int[] totalErrorCounts = node.getData().getTotalErrorCounts();
|
for (int j = 0; j < totalErrorCounts.length; j++) {
|
integers[j] += totalErrorCounts[j];
|
}
|
stringHashMap.put(node.getName(),integers);
|
children.put(parentNode.getName(),stringHashMap);
|
}
|
}
|
}
|
});
|
}
|
ArrayList<Map<String, Object>> maps = new ArrayList<>();
|
for (String value : parent.keySet()) {
|
//获取子集的数据
|
Map<String, int[]> stringMap = children.get(value);
|
//父
|
int[] ints = parent.get(value);
|
HashMap<String, Object> dataMap = new HashMap<>();
|
dataMap.put("name",value);
|
dataMap.put("danger",ints);
|
dataMap.put("children",stringMap);
|
maps.add(dataMap);
|
}
|
HashMap<String, Object> planMaps = new HashMap<>();
|
planMaps.put("round",i);
|
planMaps.put("data",maps);
|
hashMaps.add(planMaps);
|
}
|
return hashMaps;
|
}
|
//工程概述
|
@Override
|
public List<HashMap<String, Object>> engineeringOverview(){
|
//这个就是一个evalFuzzy就对应一个task 一个task就是一次检查
|
List<EvalFuzzyResult> evalFuzzyResults = evalFuzzyResultRepository.todayInspectionSituationByDate(null,null, null);
|
//根据项目进行分组
|
Map<Integer, List<EvalFuzzyResult>> collect = evalFuzzyResults.stream().collect(Collectors.groupingBy(res -> res.getProject().getId()));
|
List<HashMap<String, Object>> maps = new ArrayList<>();
|
for (Integer i : collect.keySet()) {
|
HashMap<String, Object> stringObjectHashMap = new HashMap<>();
|
//然后根据这个项目里面plan来分组 看看有几轮一个plan就代表一轮
|
List<EvalFuzzyResult> evalFuzzyResultsProcess = collect.get(i);
|
Map<Integer, List<EvalFuzzyResult>> planSize = evalFuzzyResultsProcess.stream().collect(Collectors.groupingBy(res -> res.getPlan().getId()));
|
int p1 = 0;
|
int p2 = 0;
|
int p3 = 0;
|
int p4 = 0;
|
int dangers = 0;
|
Project project = new Project();
|
for (EvalFuzzyResult fuzzyResultsProcess : evalFuzzyResultsProcess) {
|
project = fuzzyResultsProcess.getProject();
|
Map<Integer, FuzzyResult> deviceResMap = fuzzyResultsProcess.getDeviceResMap();
|
FuzzyResult systemRes = fuzzyResultsProcess.getSystemRes();
|
for (Integer integer : deviceResMap.keySet()) {
|
int[] totalErrorCounts = deviceResMap.get(integer).getContent().getData().getTotalErrorCounts();
|
p1 += totalErrorCounts[0];
|
p2 += totalErrorCounts[1];
|
p3 += totalErrorCounts[2];
|
p4 += totalErrorCounts[3];
|
dangers += Arrays.stream(totalErrorCounts).sum();
|
}
|
int[] totalErrorCountsSys = systemRes.getContent().getData().getTotalErrorCounts();
|
p1 += totalErrorCountsSys[0];
|
p2 += totalErrorCountsSys[1];
|
p3 += totalErrorCountsSys[2];
|
p4 += totalErrorCountsSys[3];
|
dangers+= Arrays.stream(systemRes.getContent().getData().getTotalErrorCounts()).sum();
|
}
|
int []totalErrorCounts = {p1,p2,p3,p4};
|
AddressInfo addressInfo = project.getAddressInfo();
|
stringObjectHashMap.put("name",project.getName());
|
stringObjectHashMap.put("type",project.getType().getDesc());
|
stringObjectHashMap.put("address",addressInfo.getProvince()+addressInfo.getCity()+addressInfo.getDistrict()+addressInfo.getDetail());
|
stringObjectHashMap.put("projectCost",project.getProjectCost());
|
stringObjectHashMap.put("checkRound",planSize.keySet().size());
|
stringObjectHashMap.put("dangersCount",dangers);
|
stringObjectHashMap.put("totalErrorCounts",totalErrorCounts);
|
stringObjectHashMap.put("constructionCompanyInfo",project.getConstructionCompanyInfo());
|
stringObjectHashMap.put("supervisorCompanyInfo",project.getSupervisorCompanyInfo());
|
stringObjectHashMap.put("developmentCompanyInfo",project.getDevelopmentCompanyInfo());
|
maps.add(stringObjectHashMap);
|
}
|
return maps;
|
}
|
|
//弹出委托方检查统计
|
public List<HashMap<String, Object>> clientInspectionStatistics(Integer clientIdP, ScreenRequest screenRequest, PageReq pageReq){
|
String string = screenRequest.toString();
|
ScreenRangeRequest screenRangeRequest = JSONObject.parseObject(string, ScreenRangeRequest.class);
|
List<LocalDateTime> startTimeAndEndTime = getStartTimeAndEndTime(screenRangeRequest);
|
LocalDateTime startTime = startTimeAndEndTime.get(0);
|
LocalDateTime endTime = startTimeAndEndTime.get(1);
|
Page<Client> clients = clientRepository.listClientsById(clientIdP,pageReq.toPageRequest());
|
List<Client> content = clients.getContent();
|
List<Integer> clientIds = content.stream().map(Client::getId).collect(Collectors.toList());
|
List<EvalFuzzyResult> evalFuzzyResults = evalFuzzyResultRepository.todayInspectionSituationHaveClient(clientIds,startTime, endTime);
|
Map<Integer, List<EvalFuzzyResult>> collect = evalFuzzyResults.stream().collect(Collectors.groupingBy(res -> res.getClient().getId()));
|
Set<Integer> ids = new HashSet<>();
|
for (EvalFuzzyResult evalFuzzyResult : evalFuzzyResults) {
|
Map<Integer, FuzzyResult> deviceResMap = evalFuzzyResult.getDeviceResMap();
|
Set<Integer> integers = deviceResMap.keySet();
|
for (Integer integer : integers) {
|
ids.add(integer);
|
}
|
}
|
List<Device> deviceByIds = deviceRepository.findDeviceByIds(ids.stream().toList());
|
List<HashMap<String, Object>> hashMaps = new ArrayList<>();
|
for (Integer clientId : clientIds) {
|
HashMap<String, Object> stringObjectHashMap = new HashMap<>();
|
List<EvalFuzzyResult> evalFuzzyResultsByClientId = collect.get(clientId);
|
int comprehensiveSafetyInspection = 0;
|
int specialSafetyInspection = 0;
|
int specialEquipmentInspection = 0;
|
//获取委托方公司
|
Client client = content.stream().filter(res->res.getId() == clientId).collect(Collectors.toList()).get(0);
|
HashMap<String, Integer> deviceTypeMap = new HashMap<>();
|
//说明没有
|
if(null != evalFuzzyResultsByClientId){
|
//然后根据计划类型来分组
|
Map<Plan, List<EvalFuzzyResult>> planListMap = evalFuzzyResultsByClientId.stream().collect(Collectors.groupingBy(EvalFuzzyResult::getPlan));
|
for (Plan plan : planListMap.keySet()) {
|
List<EvalFuzzyResult> evalFuzzyResults1 = planListMap.get(plan);
|
if(plan.getType() == PlanType.COMPREHENSIVE_CHECK){
|
comprehensiveSafetyInspection += evalFuzzyResults1.size();
|
}
|
if(plan.getType() == PlanType.SECURITY_CHECK){
|
specialSafetyInspection += evalFuzzyResults1.size();
|
}
|
if(plan.getType() == PlanType.EQUIPMENT_CHECK){
|
specialEquipmentInspection += evalFuzzyResults1.size();
|
}
|
}
|
|
DeviceType[] values = DeviceType.values();
|
for (DeviceType value : values) {
|
deviceTypeMap.put(value.getDesc(),0);
|
}
|
for (EvalFuzzyResult evalFuzzyResult : evalFuzzyResultsByClientId) {
|
Map<Integer, FuzzyResult> deviceResMap = evalFuzzyResult.getDeviceResMap();
|
for (Integer deviceId : deviceResMap.keySet()) {
|
List<Device> hasDevice = deviceByIds.stream().filter(res -> res.getId() == deviceId).collect(Collectors.toList());
|
Device device = null;
|
if(hasDevice.size()>0){
|
device = hasDevice.get(0);
|
}
|
if(null!=device){
|
Integer count = deviceTypeMap.get(device.getType().getDesc());
|
count++;
|
deviceTypeMap.put(device.getType().getDesc(),count);
|
}
|
}
|
}
|
}
|
stringObjectHashMap.put("clientName",client.getName());
|
stringObjectHashMap.put("clientId",client.getId());
|
stringObjectHashMap.put("comprehensiveSafetyInspection",comprehensiveSafetyInspection);
|
stringObjectHashMap.put("specialSafetyInspection",specialSafetyInspection);
|
stringObjectHashMap.put("specialEquipmentInspection",specialEquipmentInspection);
|
stringObjectHashMap.put("deviceMap",deviceTypeMap);
|
hashMaps.add(stringObjectHashMap);
|
}
|
return hashMaps;
|
}
|
//项目得分
|
public HashMap<String, Object> projectScore(ScreenRangeRequest screenRangeRequest){
|
List<LocalDateTime> startTimeAndEndTime = getStartTimeAndEndTime(screenRangeRequest);
|
LocalDateTime startTime = startTimeAndEndTime.get(0);
|
LocalDateTime endTime = startTimeAndEndTime.get(1);
|
List<EvalFuzzyResult> evalFuzzyResults = evalFuzzyResultRepository.todayInspectionSituationByDate(null,startTime, endTime);
|
Map<Integer, List<EvalFuzzyResult>> planGroupBy = evalFuzzyResults.stream().collect(Collectors.groupingBy(res -> res.getPlan().getId()));
|
HashMap<Integer, Object> stringObjectHashMap = new HashMap<>();
|
for (Integer planId : planGroupBy.keySet()) {
|
//获取每一轮的项目得分
|
List<EvalFuzzyResult> evalFuzzyResultsByPlanId = planGroupBy.get(planId);
|
Map<Integer, List<EvalFuzzyResult>> projectGroupBy = evalFuzzyResultsByPlanId.stream().collect(Collectors.groupingBy(res -> res.getProject().getId()));
|
HashMap<Project, Double> projectDoubleHashMap = new HashMap<>();
|
for (Integer projectId : projectGroupBy.keySet()) {
|
List<EvalFuzzyResult> evalFuzzyResultList = projectGroupBy.get(projectId);
|
Project project = evalFuzzyResultList.get(0).getProject();
|
double score = 0;
|
for (EvalFuzzyResult evalFuzzyResult : evalFuzzyResultList) {
|
score += evalFuzzyResult.getScore();
|
}
|
projectDoubleHashMap.put(project,score);
|
}
|
//Comparator.reverseOrder() 加这个就是倒叙
|
Map<Project, Double> sortedMap = projectDoubleHashMap.entrySet().stream()
|
.sorted(Map.Entry.comparingByValue())
|
.collect(Collectors.toMap(
|
Map.Entry::getKey,
|
Map.Entry::getValue,
|
(oldValue, newValue) -> oldValue,
|
LinkedHashMap::new
|
));
|
stringObjectHashMap.put(planId,sortedMap);
|
}
|
List<Map<String, Object>> maps = new ArrayList<>();
|
for (Integer i : stringObjectHashMap.keySet()) {
|
Object obj = stringObjectHashMap.get(i);
|
Map<Project, Double> projectDoubleHashMap = (Map<Project, Double>)obj;
|
int j = 0;
|
for (Project project : projectDoubleHashMap.keySet()) {
|
j++;
|
Map<String, Object> scoreMap = new HashMap<>();
|
scoreMap.put("turn",i);
|
scoreMap.put("turnDes","第"+i+"轮");
|
scoreMap.put("project",projectService.toDto(project));
|
scoreMap.put("score",projectDoubleHashMap.get(project));
|
scoreMap.put("ranking",j);
|
maps.add(scoreMap);
|
}
|
}
|
//得分趋势 根据项目进行分组
|
Map<String, List<Map<String, Object>>> projectMap = maps.stream().collect(Collectors.groupingBy(vl->{
|
ProjectDto project = (ProjectDto) vl.get("project");
|
return project.getName();
|
}));
|
HashMap<String, Object> map = new HashMap<>();
|
//排名趋势
|
map.put("scoringTrend",projectMap);
|
map.put("rankingTrend",projectMap);
|
map.put("datas",maps);
|
return map;
|
}
|
|
//隐患列表
|
@Override
|
public Map<String, Object> dangerList(){
|
//查询所有错误的数据
|
List<ErrorRecord> errorRecordAndProblem = errorRecordRepository.getErrorRecordByNotDevice();
|
Set<Integer> integers = errorRecordAndProblem.stream().collect(Collectors.groupingBy(res -> res.getProblem().getHierarchyId())).keySet();
|
HashMap<Integer, Hierarchy> integerHierarchyHashMap = new HashMap<>();
|
for (Integer hierarchyId : integers) {
|
Hierarchy hierarchy = hierarchyService.get(hierarchyId);
|
integerHierarchyHashMap.put(hierarchyId,hierarchy);
|
}
|
HashMap<String, List<ErrorRecord>> stringObjectHashMap = new HashMap<>();
|
for (ErrorRecord errorRecord : errorRecordAndProblem) {
|
Problem problem = errorRecord.getProblem();
|
Hierarchy hierarchy = integerHierarchyHashMap.get(problem.getHierarchyId());
|
TreeNode<HierarchyData> hierarchyDataTreeNode = hierarchy.getContent().get(problem.getHierarchyPath());
|
int depth = hierarchyDataTreeNode.getDepth();
|
for (int i = 0; i < depth -4 ; i++) {
|
hierarchyDataTreeNode = hierarchyDataTreeNode.getParent();
|
}
|
String name = hierarchyDataTreeNode.getName();
|
List<ErrorRecord> errorRecords = stringObjectHashMap.get(name);
|
if(null == errorRecords){
|
errorRecords = new ArrayList<>();
|
}
|
errorRecords.add(errorRecord);
|
stringObjectHashMap.put(name,errorRecords);
|
}
|
List<Map<String, Object>> maps = new ArrayList<>();
|
for (String danger : stringObjectHashMap.keySet()) {
|
List<ErrorRecord> errorRecords = stringObjectHashMap.get(danger);
|
Map<Integer, List<ErrorRecord>> collect = errorRecords.stream().collect(Collectors.groupingBy(vl -> vl.getCheckTask().getProject().getId()));
|
for (Integer project : collect.keySet()) {
|
List<ErrorRecord> errorRecordsByProject = collect.get(project);
|
Map<Integer, List<ErrorRecord>> collectByPlan = errorRecordsByProject.stream().collect(Collectors.groupingBy(vl -> vl.getCheckTask().getPlan().getId()));
|
for (Integer planId : collectByPlan.keySet()) {
|
List<ErrorRecord> errorRecordsByPlan = collectByPlan.get(planId);
|
Map<ErrorLevel, List<ErrorRecord>> collectByLevel = errorRecordsByPlan.stream().collect(Collectors.groupingBy(vl -> vl.getLevel()));
|
for (ErrorLevel errorLevel : collectByLevel.keySet()) {
|
Map<Boolean, List<ErrorRecord>> collectByReformed = collectByLevel.get(errorLevel).stream().collect(Collectors.groupingBy(vl -> vl.isReformed()));
|
for (Boolean b : collectByReformed.keySet()) {
|
HashMap<String, Object> stringObjectHashMapProcess = new HashMap<>();
|
stringObjectHashMapProcess.put("count",collectByReformed.get(b).size());
|
stringObjectHashMapProcess.put("project",errorRecordService.toDto(collect.get(project).get(0)));
|
stringObjectHashMapProcess.put("projectId",collect.get(project).get(0).getCheckTask().getProject().getId());
|
stringObjectHashMapProcess.put("plan",collectByPlan.get(planId).get(0).getCheckTask().getPlan().getId());
|
stringObjectHashMapProcess.put("danger",danger);
|
stringObjectHashMapProcess.put("level",errorLevel.getDesc());
|
if(b){
|
stringObjectHashMapProcess.put("reformed","已整改");
|
}else{
|
stringObjectHashMapProcess.put("reformed","未整改");
|
}
|
stringObjectHashMapProcess.put("value",collectByReformed.get(b).stream().map(res->errorRecordService.toDto(res)).collect(Collectors.toList()));
|
maps.add(stringObjectHashMapProcess);
|
}
|
}
|
}
|
}
|
}
|
List<HashMap<String, Object>> dangerMaps = new ArrayList<>();
|
Map<String, List<Map<String, Object>>> dangerGroupBy = maps.stream().collect(Collectors.groupingBy(res -> String.valueOf(res.get("danger"))));
|
Map<String, List<Map<String, Object>>> levelMaps = maps.stream().collect(Collectors.groupingBy(res -> String.valueOf(res.get("level"))));
|
HashMap<String, Double> proportion = new HashMap<>();
|
int total = 0;
|
for (String level : levelMaps.keySet()) {
|
int count = 0;
|
for (Map<String, Object> stringObjectMap : levelMaps.get(level)) {
|
count += Integer.parseInt(String.valueOf(stringObjectMap.get("count")));
|
}
|
total += count;
|
proportion.put(level,Double.valueOf(count));
|
}
|
for (String level : proportion.keySet()) {
|
double value = (proportion.get(level) / total) * 100;
|
proportion.put(level,value);
|
}
|
for (String dangerName : dangerGroupBy.keySet()) {
|
HashMap<String, Object> dangerMap = new HashMap<>();
|
dangerMap.put("danger",dangerName);
|
List<Map<String, Object>> dangerNames = dangerGroupBy.get(dangerName);
|
//根据隐患等级获取到对于的数据
|
Map<String, List<Map<String, Object>>> level = dangerNames.stream().collect(Collectors.groupingBy(res -> String.valueOf(res.get("level"))));
|
|
for (String levelValue : level.keySet()) {
|
//隐患等级
|
int count = 0;
|
List<Map<String, Object>> mapsProcess = level.get(levelValue);
|
for (Map<String, Object> process : mapsProcess) {
|
count += Integer.parseInt(String.valueOf(process.get("count")));
|
}
|
dangerMap.put(levelValue,count);
|
}
|
dangerMaps.add(dangerMap);
|
}
|
Map<String, List<Map<String, Object>>> planGroupBy = maps.stream().collect(Collectors.groupingBy(res -> String.valueOf(res.get("plan"))));
|
HashMap<String, Object> dangerByPlan = new HashMap<>();
|
for (String planId : planGroupBy.keySet()) {
|
List<Map<String, Object>> mapsByPlan = planGroupBy.get(planId);
|
Map<String, List<Map<String, Object>>> dangerByName = mapsByPlan.stream().collect(Collectors.groupingBy(res -> String.valueOf(res.get("danger"))));
|
List<HashMap<String, Object>> dangerMapsByPlan = new ArrayList<>();
|
for (String danger : dangerByName.keySet()) {
|
HashMap<String, Object> dangerByNameMap= new HashMap<>();
|
int count = 0;
|
List<Map<String, Object>> mapsByDanger = dangerByName.get(danger);
|
for (Map<String, Object> stringObjectMap : mapsByDanger) {
|
count += Integer.parseInt(String.valueOf(stringObjectMap.get("count")));
|
}
|
dangerByNameMap.put(danger,count);
|
dangerMapsByPlan.add(dangerByNameMap);
|
}
|
dangerByPlan.put(planId,dangerMapsByPlan);
|
}
|
Map<String, Object> resultMap = new HashMap<>();
|
resultMap.put("list",maps);
|
resultMap.put("dangerTrend",dangerByPlan);
|
resultMap.put("dangerCount",dangerMaps);
|
resultMap.put("proportion",proportion);
|
return resultMap;
|
}
|
|
public static List<LocalDateTime> getStartTimeAndEndTime(ScreenRangeRequest screenRangeRequest){
|
ArrayList<LocalDateTime> localDateTimes = new ArrayList<>();
|
LocalDateTime startTime = null;
|
LocalDateTime endTime = null;
|
//都为空的时候
|
if(StringUtils.isBlank(screenRangeRequest.getStartTime()) && StringUtils.isBlank(screenRangeRequest.getStartTimeStamp()) && StringUtils.isEmpty(screenRangeRequest.getStartTime()) && StringUtils.isEmpty(screenRangeRequest.getStartTimeStamp())){
|
startTime = LocalDateTime.now().with(LocalTime.MIN);
|
}
|
//都为空的时候
|
if(StringUtils.isBlank(screenRangeRequest.getEndTime()) && StringUtils.isBlank(screenRangeRequest.getEndTimeStamp()) && StringUtils.isEmpty(screenRangeRequest.getEndTime()) && StringUtils.isEmpty(screenRangeRequest.getEndTimeStamp())){
|
endTime = startTime.withHour(23).withMinute(59).withSecond(59);
|
}
|
//就是都传递的时候
|
if(StringUtils.isNotBlank(screenRangeRequest.getStartTime()) && StringUtils.isNotBlank(screenRangeRequest.getStartTimeStamp()) && !StringUtils.isEmpty(screenRangeRequest.getStartTime()) && !StringUtils.isEmpty(screenRangeRequest.getStartTimeStamp())){
|
try {
|
startTime = LocalDateTime.parse(screenRangeRequest.getStartTime() +" "+screenRangeRequest.getStartTimeStamp(), DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
|
}catch (Exception e){
|
startTime = LocalDateTime.now().with(LocalTime.MIN);
|
}
|
}
|
//就是都传递的时候
|
if(StringUtils.isNotBlank(screenRangeRequest.getEndTime()) && StringUtils.isNotBlank(screenRangeRequest.getEndTimeStamp()) && !StringUtils.isEmpty(screenRangeRequest.getEndTime()) && !StringUtils.isEmpty(screenRangeRequest.getEndTimeStamp())){
|
try {
|
endTime = LocalDateTime.parse(screenRangeRequest.getEndTime() +" "+screenRangeRequest.getEndTimeStamp(), DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
|
}catch (Exception e){
|
endTime = startTime.withHour(23).withMinute(59).withSecond(59);
|
}
|
}
|
localDateTimes.add(startTime);
|
localDateTimes.add(endTime);
|
return localDateTimes;
|
}
|
}
|
