package com.qianwen.smartman.modules.visual.wrapper;
|
|
import cn.hutool.core.util.NumberUtil;
|
import com.google.common.collect.Lists;
|
import java.math.BigDecimal;
|
import java.util.ArrayList;
|
import java.util.Comparator;
|
import java.util.HashMap;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.concurrent.atomic.AtomicReference;
|
import java.util.function.Function;
|
import java.util.stream.Collectors;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import com.qianwen.smartman.common.cache.cps.WorkstationCache;
|
import com.qianwen.smartman.common.constant.ChartNameConstant;
|
import com.qianwen.smartman.common.constant.MdcConstant;
|
import com.qianwen.core.tool.utils.Func;
|
import com.qianwen.smartman.modules.cps.entity.GlobalWcs;
|
import com.qianwen.smartman.modules.cps.entity.Workstation;
|
import com.qianwen.smartman.modules.mdc.entity.SuperAggregateState;
|
import com.qianwen.smartman.modules.mdc.enums.OpenTypeEnums;
|
import com.qianwen.smartman.modules.mdc.enums.ProductivityTypeEnum;
|
import com.qianwen.smartman.modules.mdc.utils.EifficiencyUtils;
|
import com.qianwen.smartman.modules.mdc.utils.FilterOffUtils;
|
import com.qianwen.smartman.modules.mdc.vo.StatusTimeTopVO;
|
import com.qianwen.smartman.modules.system.entity.SeriesItem;
|
import com.qianwen.smartman.modules.system.vo.ChartGanttStatusDataVO;
|
import com.qianwen.smartman.modules.system.vo.ChartNameValueDataVO;
|
import com.qianwen.smartman.modules.system.vo.ChartSeriesDataVO;
|
import com.qianwen.smartman.modules.system.vo.GanttStatusVO;
|
import com.qianwen.smartman.modules.system.vo.WorkstationChartSeriesDataVO;
|
import org.springframework.stereotype.Component;
|
|
@Component
|
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/visual/wrapper/StatusWrapper.class */
|
public class StatusWrapper {
|
private static final Logger log = LoggerFactory.getLogger(StatusWrapper.class);
|
|
public ChartNameValueDataVO entityToGroupRunning(List<SuperAggregateState> superAggregateStates, Integer size) {
|
long sum = superAggregateStates.stream().mapToLong((v0) -> {
|
return v0.getDurationCollect();
|
}).sum();
|
String result = sum != 0 ? secondToHour(Double.valueOf((sum * 1.0d) / size.intValue())) : "";
|
return new ChartNameValueDataVO().addValue(MdcConstant.GROUP_RUNNING, result);
|
}
|
|
private String secondToHour(Number second) {
|
if (second instanceof Double) {
|
double s = second.doubleValue();
|
log.info("second:{},s{}", second, Double.valueOf(s));
|
return NumberUtil.decimalFormat(MdcConstant.NORMAL_FORMAT, s / 3600000.0d);
|
}
|
return "";
|
}
|
|
public ChartNameValueDataVO entityToEfficiencyAverageVo(List<SuperAggregateState> superAggregateStates, ProductivityTypeEnum productivityTypeEnum) {
|
ChartNameValueDataVO vo = new ChartNameValueDataVO();
|
Map<Long, List<SuperAggregateState>> collect = superAggregateStates.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getWorkstationId();
|
}));
|
AtomicReference<Double> allValue = new AtomicReference<>(Double.valueOf(0.0d));
|
collect.forEach((workstationId, superAggregateStateList) -> {
|
Double value = EifficiencyUtils.calculationResults(superAggregateStateList, productivityTypeEnum);
|
allValue.updateAndGet(v -> {
|
return Double.valueOf(v.doubleValue() + value.doubleValue());
|
});
|
});
|
double v = BigDecimal.valueOf(allValue.get().doubleValue()).divide(BigDecimal.valueOf(collect.keySet().size()), 4, 4).multiply(BigDecimal.valueOf(100L)).doubleValue();
|
switch (productivityTypeEnum) {
|
case ALARM:
|
vo.addValue("平均报警率", Double.valueOf(v));
|
break;
|
case RUNNING:
|
vo.addValue("平均运行率", Double.valueOf(v));
|
break;
|
default:
|
vo.addValue("平均稼动率", Double.valueOf(v));
|
break;
|
}
|
return vo;
|
}
|
|
/* JADX WARN: Multi-variable type inference failed */
|
public ChartGanttStatusDataVO entityVO(List<Workstation> workstations, List<SuperAggregateState> superAggregateStateList) {
|
Map<Long, List<SuperAggregateState>> map = new HashMap<>(32);
|
if (Func.isNotEmpty(superAggregateStateList)) {
|
map = superAggregateStateList.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getWorkstationId();
|
}));
|
}
|
ChartGanttStatusDataVO chartGanttStatusDataVO = new ChartGanttStatusDataVO();
|
List<SeriesItem<GanttStatusVO>> series = new ArrayList<>();
|
List<ChartGanttStatusDataVO.ColorStatus> colorStatusList = WorkstationCache.getDefaultWcs().stream().map(globalWcs -> {
|
return new ChartGanttStatusDataVO.ColorStatus(globalWcs.getColor(), Integer.valueOf(globalWcs.getCode()), globalWcs.getName());
|
}).collect(Collectors.toList());
|
for (Workstation workstation : workstations) {
|
List<SuperAggregateState> superAggregateStates = map.getOrDefault(workstation.getId(), new ArrayList<>());
|
List<GanttStatusVO> list = superAggregateStates.stream().map(superAggregateState -> {
|
return GanttStatusVO.builder().startTime(superAggregateState.getStartTime()).endTime(superAggregateState.getEndTime()).status(superAggregateState.getWcs()).build();
|
}).collect(Collectors.toList());
|
SeriesItem seriesItem = new SeriesItem(workstation.getName(), list);
|
series.add(seriesItem);
|
}
|
chartGanttStatusDataVO.setColorStatusInfo(colorStatusList);
|
chartGanttStatusDataVO.setSeries(series);
|
return chartGanttStatusDataVO;
|
}
|
|
public ChartNameValueDataVO entityToChartName(List<SuperAggregateState> data) {
|
ChartNameValueDataVO vo = new ChartNameValueDataVO();
|
List<GlobalWcs> defaultWcs = WorkstationCache.getDefaultWcs();
|
Map<Integer, GlobalWcs> wcsMap = defaultWcs.stream().collect(Collectors.toMap(k -> {
|
return Integer.valueOf(Integer.parseInt(k.getCode()));
|
}, v -> {
|
return v;
|
}));
|
Map<Integer, Long> durationMap = data.stream().filter(c -> {
|
return wcsMap.containsKey(c.getValueCollect());
|
}).collect(Collectors.groupingBy((v0) -> {
|
return v0.getWcs();
|
}, Collectors.summingLong((v0) -> {
|
return v0.getDurationCollect();
|
})));
|
double sum = durationMap.values().stream().mapToDouble(c2 -> {
|
return c2.longValue();
|
}).sum();
|
for (Map.Entry<Integer, Long> entry : durationMap.entrySet()) {
|
double result = !new Double(sum).equals(Double.valueOf(0.0d)) ? Double.parseDouble(NumberUtil.decimalFormat(MdcConstant.NORMAL_FORMAT, (entry.getValue().longValue() / sum) * 100.0d)) : 0.0d;
|
vo.addValue(wcsMap.get(entry.getKey()).getName(), Double.valueOf(result), "", wcsMap.get(entry.getKey()).getColor());
|
}
|
return vo;
|
}
|
|
public ChartNameValueDataVO entityToOee(List<SuperAggregateState> data) {
|
List<SuperAggregateState> data2 = FilterOffUtils.filterOffDay(data, OpenTypeEnums.OEE);
|
ChartNameValueDataVO vo = new ChartNameValueDataVO();
|
Double oee = EifficiencyUtils.calculationOee(data2);
|
vo.addValue(MdcConstant.OEE_NAME, NumberUtil.decimalFormat(MdcConstant.NORMAL_FORMAT, oee.doubleValue() * 100.0d));
|
return vo;
|
}
|
|
public ChartNameValueDataVO entityToMonthOee(List<SuperAggregateState> data) {
|
List<SuperAggregateState> data2 = FilterOffUtils.filterOffDay(data, OpenTypeEnums.OEE);
|
ChartNameValueDataVO vo = new ChartNameValueDataVO();
|
Double oee = EifficiencyUtils.calculationOee(data2);
|
vo.addValue(MdcConstant.MONTH_OEE_NAME, NumberUtil.decimalFormat(MdcConstant.NORMAL_FORMAT, oee.doubleValue() * 100.0d));
|
return vo;
|
}
|
|
public ChartNameValueDataVO entityToMonthRunning(List<SuperAggregateState> data) {
|
List<SuperAggregateState> data2 = FilterOffUtils.filterOffDay(data, OpenTypeEnums.RUNNING);
|
ChartNameValueDataVO vo = new ChartNameValueDataVO();
|
Double oee = EifficiencyUtils.calculationRunning(data2);
|
vo.addValue(MdcConstant.MONTH_RUNNING_NAME, NumberUtil.decimalFormat(MdcConstant.NORMAL_FORMAT, oee.doubleValue() * 100.0d));
|
return vo;
|
}
|
|
public ChartSeriesDataVO entityToEfficiencyTopVo(List<SuperAggregateState> statusByCondition, ProductivityTypeEnum productivityTypeEnum, Integer top, List<Workstation> workstations, String name) {
|
Map<Long, Workstation> workstationMap = workstations.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getId();
|
}, Function.identity()));
|
Map<Long, List<SuperAggregateState>> collect = statusByCondition.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getWorkstationId();
|
}));
|
Map<Long, Double> idToValue = new HashMap<>();
|
collect.forEach((workstationId, statusByConditionList) -> {
|
Double value = EifficiencyUtils.calculationResults(statusByConditionList, productivityTypeEnum);
|
double v = BigDecimal.valueOf(value.doubleValue()).multiply(BigDecimal.valueOf(100L)).doubleValue();
|
idToValue.put(workstationId, Double.valueOf(v));
|
});
|
LinkedHashMap<Long, Double> collectSorted = idToValue.entrySet().stream().sorted(Map.Entry.comparingByValue(Comparator.reverseOrder())).limit(top.intValue()).collect(Collectors.toMap((v0) -> {
|
return v0.getKey();
|
}, (v0) -> {
|
return v0.getValue();
|
}, (oldValue, newValue) -> {
|
return oldValue;
|
}, LinkedHashMap::new));
|
WorkstationChartSeriesDataVO chartSeriesDataVO = new WorkstationChartSeriesDataVO();
|
ArrayList<Object> data = new ArrayList<>();
|
SeriesItem seriesItem = new SeriesItem();
|
seriesItem.setName(name);
|
List<Workstation> categories = new ArrayList<>();
|
collectSorted.forEach((workstationId2, value) -> {
|
data.add(value);
|
categories.add(workstationMap.get(workstationId2));
|
});
|
seriesItem.setData(data);
|
chartSeriesDataVO.setSeries(Lists.newArrayList(new SeriesItem[]{seriesItem}));
|
chartSeriesDataVO.generateCategories(categories);
|
return chartSeriesDataVO;
|
}
|
|
public ChartSeriesDataVO deviceStatusDuration(List<StatusTimeTopVO> statusTimeByWcs, Integer status, Integer top) {
|
WorkstationChartSeriesDataVO chartSeriesDataVO = new WorkstationChartSeriesDataVO();
|
ArrayList arrayList = new ArrayList();
|
ArrayList arrayList2 = new ArrayList();
|
if (Func.isNotEmpty(statusTimeByWcs)) {
|
SeriesItem seriesItem = new SeriesItem();
|
if (ChartNameConstant.DEVICE_RUN_STATUS.equals(status)) {
|
seriesItem.setName(ChartNameConstant.DEVICE_RUN_DURATION + top);
|
}
|
if (ChartNameConstant.DEVICE_WAIT_STATUS.equals(status)) {
|
seriesItem.setName(ChartNameConstant.DEVICE_WAIT_DURATION + top);
|
}
|
statusTimeByWcs.forEach(s -> {
|
arrayList2.add(s.getValue());
|
});
|
seriesItem.setData(arrayList2);
|
arrayList.add(seriesItem);
|
}
|
chartSeriesDataVO.generateCategories((List) statusTimeByWcs.stream().map((v0) -> {
|
return v0.getWorkstation();
|
}).collect(Collectors.toList()));
|
chartSeriesDataVO.setSeries(arrayList);
|
return chartSeriesDataVO;
|
}
|
|
public ChartNameValueDataVO entityToEfficiencyTodayVo(List<SuperAggregateState> superAggregateStates, List<Workstation> workstations, ProductivityTypeEnum productivityTypeEnum) {
|
ChartNameValueDataVO vo = new ChartNameValueDataVO();
|
Map<Long, String> workstationIdToName = workstations.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getId();
|
}, (v0) -> {
|
return v0.getName();
|
}));
|
Map<Long, List<SuperAggregateState>> collect = superAggregateStates.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getWorkstationId();
|
}));
|
collect.forEach((workstationId, superAggregateStateList) -> {
|
Double value = EifficiencyUtils.calculationResults(superAggregateStateList, productivityTypeEnum);
|
vo.addValue((String) workstationIdToName.get(workstationId), value);
|
});
|
return vo;
|
}
|
}
|
