package com.qianwen.smartman.modules.mdc.wrapper;
|
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.stream.Collectors;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import com.qianwen.smartman.common.constant.MdcConstant;
|
import com.qianwen.smartman.common.utils.MessageUtils;
|
import com.qianwen.core.tool.utils.Func;
|
import com.qianwen.smartman.modules.cps.entity.Workstation;
|
import com.qianwen.smartman.modules.mdc.dto.IntervalDateDto;
|
import com.qianwen.smartman.modules.mdc.dto.ShiftIndexNameDTO;
|
import com.qianwen.smartman.modules.mdc.dto.StatisticsWrapperDto;
|
import com.qianwen.smartman.modules.mdc.entity.SuperAggregate;
|
import com.qianwen.smartman.modules.mdc.entity.SuperAggregateOutput;
|
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.service.ITimeUsedAnalysisService;
|
import com.qianwen.smartman.modules.mdc.utils.EifficiencyUtils;
|
import com.qianwen.smartman.modules.mdc.utils.FilterOffUtils;
|
import com.qianwen.smartman.modules.mdc.vo.StatisticsAnalysisQueryVO;
|
import com.qianwen.smartman.modules.mdc.vo.StatisticsDataVO;
|
import com.qianwen.smartman.modules.mdc.vo.StatisticsVO;
|
import org.springframework.stereotype.Component;
|
|
@Component
|
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/mdc/wrapper/StatisticsWrapper.class */
|
public class StatisticsWrapper {
|
private static final Logger log = LoggerFactory.getLogger(StatisticsWrapper.class);
|
private final ITimeUsedAnalysisService timeUsedAnalysisService;
|
|
public StatisticsWrapper(final ITimeUsedAnalysisService timeUsedAnalysisService) {
|
this.timeUsedAnalysisService = timeUsedAnalysisService;
|
}
|
|
public StatisticsVO entityVO(StatisticsWrapperDto statisticsWrapperDto) {
|
StatisticsVO statisticsVO;
|
StatisticsAnalysisQueryVO statisticsAnalysisQueryVO = statisticsWrapperDto.getStatisticsAnalysisQueryVO();
|
List<IntervalDateDto> intervalDates = statisticsWrapperDto.getIntervalDates();
|
List<SuperAggregate> superAggregates = new ArrayList<>(statisticsWrapperDto.getSuperAggregateList());
|
IPage<Workstation> workstationPage = statisticsWrapperDto.getWorkstationPage();
|
Boolean isOutput = statisticsWrapperDto.getIsOutput();
|
Integer queryType = statisticsAnalysisQueryVO.getQueryType();
|
List<Integer> shiftIndexList = statisticsAnalysisQueryVO.getShiftIndexList();
|
new StatisticsVO();
|
ProductivityTypeEnum productivityType = statisticsAnalysisQueryVO.getProductivityType();
|
switch (statisticsAnalysisQueryVO.getStatisticalMethod()) {
|
case DAY:
|
if (MdcConstant.SHEET.equals(queryType)) {
|
statisticsVO = buildDateDataSheet(intervalDates, superAggregates, workstationPage, isOutput, productivityType);
|
break;
|
} else {
|
statisticsVO = buildDateData(intervalDates, superAggregates, workstationPage.getRecords(), isOutput, productivityType);
|
break;
|
}
|
case WEEK:
|
if (MdcConstant.SHEET.equals(queryType)) {
|
statisticsVO = buildMonthOrWeekDataSheet(intervalDates, superAggregates, workstationPage, MdcConstant.WEEK, isOutput, productivityType);
|
break;
|
} else {
|
statisticsVO = buildMonthOrWeekData(intervalDates, superAggregates, workstationPage.getRecords(), MdcConstant.WEEK, isOutput, productivityType);
|
break;
|
}
|
case MONTH:
|
if (MdcConstant.SHEET.equals(queryType)) {
|
statisticsVO = buildMonthOrWeekDataSheet(intervalDates, superAggregates, workstationPage, MdcConstant.MONTH, isOutput, productivityType);
|
break;
|
} else {
|
statisticsVO = buildMonthOrWeekData(intervalDates, superAggregates, workstationPage.getRecords(), MdcConstant.MONTH, isOutput, productivityType);
|
break;
|
}
|
default:
|
List<Long> workstationIds = (List) workstationPage.getRecords().stream().map((v0) -> {
|
return v0.getId();
|
}).collect(Collectors.toList());
|
Map<Long, List<ShiftIndexNameDTO>> idToValue = this.timeUsedAnalysisService.queryWorkStationShiftIndex(workstationIds, statisticsAnalysisQueryVO.getStartDate());
|
statisticsVO = buildShiftData(superAggregates, workstationPage, shiftIndexList, idToValue, isOutput, productivityType);
|
break;
|
}
|
return statisticsVO;
|
}
|
|
public StatisticsVO buildDateDataSheet(List<IntervalDateDto> intervalDates, List<SuperAggregate> superAggregates, IPage<Workstation> workstationIPage, Boolean isOutput, ProductivityTypeEnum productivityType) {
|
StatisticsVO statisticsVO = new StatisticsVO();
|
Map<Long, Map<Integer, List<SuperAggregate>>> collectGroupByDate = (Map) superAggregates.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getWorkstationId();
|
}, Collectors.groupingBy((v0) -> {
|
return v0.getFactoryDate();
|
})));
|
List<String> dayList = intervalDates.get(0).getDayList();
|
List<StatisticsDataVO> statisticsDataVOS = new ArrayList<>();
|
List<Workstation> workstationList = workstationIPage.getRecords();
|
workstationList.forEach(workstation -> {
|
StatisticsDataVO statisticsDataVO = new StatisticsDataVO();
|
statisticsDataVO.setId(workstation.getId().toString());
|
statisticsDataVO.setWorkstationCode(workstation.getCode());
|
statisticsDataVO.setWorkstationName(workstation.getName());
|
Map<Integer, List<SuperAggregate>> map = (Map) collectGroupByDate.get(workstation.getId());
|
LinkedHashMap<String, String> data = new LinkedHashMap<>();
|
if (Func.isEmpty(map)) {
|
dayList.forEach(day -> {
|
data.put(day, "0");
|
});
|
} else {
|
dayList.forEach(day2 -> {
|
List<SuperAggregate> superAggregateList = (List) map.get(Integer.valueOf(day2.replaceAll("-", "")));
|
String value = getValue(superAggregateList, isOutput, productivityType);
|
data.put(day2, value);
|
});
|
}
|
statisticsDataVO.setData(data);
|
statisticsDataVOS.add(statisticsDataVO);
|
});
|
Page page = new Page();
|
page.setRecords(statisticsDataVOS);
|
page.setTotal(workstationIPage.getTotal()).setPages(workstationIPage.getPages()).setSize(workstationIPage.getSize()).setCurrent(workstationIPage.getCurrent());
|
statisticsVO.setItems(page);
|
return statisticsVO;
|
}
|
|
public StatisticsVO buildDateData(List<IntervalDateDto> intervalDates, List<SuperAggregate> superAggregates, List<Workstation> workstationList, Boolean isOutput, ProductivityTypeEnum productivityType) {
|
Map<Long, Workstation> workstationIdToValue = (Map) workstationList.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getId();
|
}, v -> {
|
return v;
|
}));
|
List<Long> workstationIdList = (List) workstationList.stream().map((v0) -> {
|
return v0.getId();
|
}).collect(Collectors.toList());
|
StatisticsVO statisticsVO = new StatisticsVO();
|
Map<Integer, Map<Long, List<SuperAggregate>>> collectGroupByDate = (Map) superAggregates.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getFactoryDate();
|
}, Collectors.groupingBy((v0) -> {
|
return v0.getWorkstationId();
|
})));
|
List<String> dayList = intervalDates.get(0).getDayList();
|
List<StatisticsDataVO> statisticsDataVOS = new ArrayList<>();
|
dayList.forEach(day -> {
|
StatisticsDataVO statisticsDataVO = new StatisticsDataVO();
|
statisticsDataVO.setId(day);
|
Map<Long, List<SuperAggregate>> map = (Map) collectGroupByDate.get(Integer.valueOf(day.replaceAll("-", "")));
|
LinkedHashMap<String, String> data = new LinkedHashMap<>();
|
LinkedHashMap<String, String> nameData = new LinkedHashMap<>();
|
if (Func.isEmpty(map)) {
|
workstationIdList.forEach(workstationId -> {
|
data.put(workstationId.toString(), "0");
|
nameData.put(String.valueOf(workstationId), ((Workstation) workstationIdToValue.get(workstationId)).getName());
|
});
|
} else {
|
workstationIdList.forEach(workstationId2 -> {
|
List<SuperAggregate> superAggregateList = (List) map.get(workstationId2);
|
String value = getValue(superAggregateList, isOutput, productivityType);
|
data.put(workstationId2.toString(), value);
|
nameData.put(String.valueOf(workstationId2), ((Workstation) workstationIdToValue.get(workstationId2)).getName());
|
});
|
}
|
statisticsDataVO.setData(data);
|
statisticsDataVO.setNameData(nameData);
|
statisticsDataVOS.add(statisticsDataVO);
|
});
|
Page page = new Page();
|
page.setRecords(statisticsDataVOS).setSize(-1L);
|
statisticsVO.setItems(page);
|
return statisticsVO;
|
}
|
|
public StatisticsVO buildMonthOrWeekDataSheet(List<IntervalDateDto> intervalDates, List<SuperAggregate> superAggregates, IPage<Workstation> workstationIPage, Boolean isMonth, Boolean isOutput, ProductivityTypeEnum productivityType) {
|
StatisticsVO statisticsVO = new StatisticsVO();
|
Map<Long, Map<Integer, Map<Integer, List<SuperAggregate>>>> collectGroupByMonth = (Map) superAggregates.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getWorkstationId();
|
}, Collectors.groupingBy((v0) -> {
|
return v0.getFactoryYear();
|
}, Collectors.groupingBy((v0) -> {
|
return v0.getFactoryMonth();
|
}))));
|
Map<Long, Map<Integer, Map<Integer, List<SuperAggregate>>>> collectGroupByWeek = (Map) superAggregates.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getWorkstationId();
|
}, Collectors.groupingBy((v0) -> {
|
return v0.getFactoryYear();
|
}, Collectors.groupingBy((v0) -> {
|
return v0.getFactoryWeek();
|
}))));
|
List<StatisticsDataVO> statisticsDataVOS = new ArrayList<>();
|
List<Workstation> workstationList = workstationIPage.getRecords();
|
workstationList.forEach(workstation -> {
|
Map<Integer, Map<Integer, List<SuperAggregate>>> yearMap;
|
StatisticsDataVO statisticsDataVO = new StatisticsDataVO();
|
statisticsDataVO.setId(String.valueOf(workstation.getId()));
|
statisticsDataVO.setWorkstationCode(workstation.getCode());
|
statisticsDataVO.setWorkstationName(workstation.getName());
|
LinkedHashMap<String, String> data = new LinkedHashMap<>();
|
if (isMonth.booleanValue()) {
|
yearMap = (Map) collectGroupByMonth.get(workstation.getId());
|
} else {
|
yearMap = (Map) collectGroupByWeek.get(workstation.getId());
|
}
|
if (Func.isEmpty(yearMap)) {
|
intervalDates.forEach(intervalDateDto -> {
|
Integer year = intervalDateDto.getYear();
|
if (isMonth.booleanValue()) {
|
intervalDateDto.getMonthList().forEach(month -> {
|
data.put(year + "-" + month, "0");
|
});
|
} else {
|
intervalDateDto.getWeekList().forEach(week -> {
|
data.put(year + "-" + week, "0");
|
});
|
}
|
});
|
} else {
|
Map<Integer, Map<Integer, List<SuperAggregate>>> map = yearMap;
|
intervalDates.forEach(intervalDateDto2 -> {
|
Map<Integer, List<SuperAggregate>> monthOrWeekMap = (Map) map.get(intervalDateDto2.getYear());
|
if (Func.isEmpty(monthOrWeekMap)) {
|
if (isMonth.booleanValue()) {
|
List<Integer> monthList = intervalDateDto2.getMonthList();
|
monthList.forEach(month -> {
|
data.put(intervalDateDto2.getYear() + "-" + month, "0");
|
});
|
return;
|
}
|
List<Integer> weekList = intervalDateDto2.getWeekList();
|
weekList.forEach(week -> {
|
data.put(intervalDateDto2.getYear() + "-" + week, "0");
|
});
|
} else if (isMonth.booleanValue()) {
|
intervalDateDto2.getMonthList().forEach(month2 -> {
|
List<SuperAggregate> superAggregateList = (List) monthOrWeekMap.get(month2);
|
String value = getValue(superAggregateList, isOutput, productivityType);
|
data.put(intervalDateDto2.getYear() + "-" + month2, value);
|
});
|
} else {
|
intervalDateDto2.getWeekList().forEach(week2 -> {
|
List<SuperAggregate> superAggregateList = (List) monthOrWeekMap.get(week2);
|
String value = getValue(superAggregateList, isOutput, productivityType);
|
data.put(intervalDateDto2.getYear() + "-" + week2, value);
|
});
|
}
|
});
|
}
|
statisticsDataVO.setData(data);
|
statisticsDataVOS.add(statisticsDataVO);
|
});
|
Page page = new Page();
|
page.setRecords(statisticsDataVOS);
|
page.setTotal(workstationIPage.getTotal()).setPages(workstationIPage.getPages()).setSize(workstationIPage.getSize()).setCurrent(workstationIPage.getCurrent());
|
statisticsVO.setItems(page);
|
return statisticsVO;
|
}
|
|
public StatisticsVO buildMonthOrWeekData(List<IntervalDateDto> intervalDates, List<SuperAggregate> superAggregates, List<Workstation> workstationList, Boolean isMonth, Boolean isOutput, ProductivityTypeEnum productivityType) {
|
Map<Integer, Map<Integer, Map<Long, List<SuperAggregate>>>> collectGroupByMonthOrWeek;
|
Map<Long, Workstation> workstationIdToValue = (Map) workstationList.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getId();
|
}, v -> {
|
return v;
|
}));
|
List<Long> workstationIdList = (List) workstationList.stream().map((v0) -> {
|
return v0.getId();
|
}).collect(Collectors.toList());
|
StatisticsVO statisticsVO = new StatisticsVO();
|
if (isMonth.booleanValue()) {
|
collectGroupByMonthOrWeek = (Map) superAggregates.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getFactoryYear();
|
}, Collectors.groupingBy((v0) -> {
|
return v0.getFactoryMonth();
|
}, Collectors.groupingBy((v0) -> {
|
return v0.getWorkstationId();
|
}))));
|
} else {
|
collectGroupByMonthOrWeek = (Map) superAggregates.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getFactoryYear();
|
}, Collectors.groupingBy((v0) -> {
|
return v0.getFactoryWeek();
|
}, Collectors.groupingBy((v0) -> {
|
return v0.getWorkstationId();
|
}))));
|
}
|
List<StatisticsDataVO> statisticsDataVOS = new ArrayList<>();
|
Map<Integer, Map<Integer, Map<Long, List<SuperAggregate>>>> finalCollectGroupByMonthOrWeek = collectGroupByMonthOrWeek;
|
intervalDates.forEach(intervalDateDto -> {
|
List<Integer> monthOrWeekList;
|
Integer year = intervalDateDto.getYear();
|
Map<Integer, Map<Long, List<SuperAggregate>>> monthOrWeekToValue = (Map) finalCollectGroupByMonthOrWeek.get(year);
|
if (isMonth.booleanValue()) {
|
monthOrWeekList = intervalDateDto.getMonthList();
|
} else {
|
monthOrWeekList = intervalDateDto.getWeekList();
|
}
|
if (Func.isEmpty(monthOrWeekToValue)) {
|
monthOrWeekList.forEach(monthOrWeek -> {
|
StatisticsDataVO statisticsDataVO = new StatisticsDataVO();
|
LinkedHashMap<String, String> data = new LinkedHashMap<>();
|
LinkedHashMap<String, String> nameData = new LinkedHashMap<>();
|
statisticsDataVO.setId(year + "-" + monthOrWeek);
|
workstationIdList.forEach(workstationId -> {
|
data.put(workstationId.toString(), "0");
|
nameData.put(workstationId.toString(), ((Workstation) workstationIdToValue.get(workstationId)).getName());
|
});
|
statisticsDataVO.setData(data);
|
statisticsDataVO.setNameData(nameData);
|
statisticsDataVOS.add(statisticsDataVO);
|
});
|
} else {
|
monthOrWeekList.forEach(monthOrWeek2 -> {
|
StatisticsDataVO statisticsDataVO = new StatisticsDataVO();
|
LinkedHashMap<String, String> data = new LinkedHashMap<>();
|
LinkedHashMap<String, String> nameData = new LinkedHashMap<>();
|
statisticsDataVO.setId(year + "-" + monthOrWeek2);
|
Map<Long, List<SuperAggregate>> workstationMap = (Map) monthOrWeekToValue.get(monthOrWeek2);
|
if (Func.isEmpty(workstationMap)) {
|
workstationIdList.forEach(workstationId -> {
|
data.put(workstationId.toString(), "0");
|
nameData.put(workstationId.toString(), ((Workstation) workstationIdToValue.get(workstationId)).getName());
|
});
|
} else {
|
workstationIdList.forEach(workstationId2 -> {
|
List<SuperAggregate> superAggregateList = (List) workstationMap.get(workstationId2);
|
String value = getValue(superAggregateList, isOutput, productivityType);
|
data.put(workstationId2.toString(), value);
|
nameData.put(workstationId2.toString(), ((Workstation) workstationIdToValue.get(workstationId2)).getName());
|
});
|
}
|
statisticsDataVO.setData(data);
|
statisticsDataVO.setNameData(nameData);
|
statisticsDataVOS.add(statisticsDataVO);
|
});
|
}
|
});
|
Page page = new Page();
|
page.setRecords(statisticsDataVOS).setSize(-1L);
|
statisticsVO.setItems(page);
|
return statisticsVO;
|
}
|
|
public StatisticsVO buildShiftData(List<SuperAggregate> superAggregates, IPage<Workstation> workstationIPage, List<Integer> shiftIndexList, Map<Long, List<ShiftIndexNameDTO>> idToValue, Boolean isOutput, ProductivityTypeEnum productivityType) {
|
Map<Long, Map<Integer, List<SuperAggregate>>> collectGroupByShift = (Map) superAggregates.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getWorkstationId();
|
}, Collectors.groupingBy((v0) -> {
|
return v0.getShiftIndex();
|
})));
|
StatisticsVO statisticsVO = new StatisticsVO();
|
List<Workstation> workstationList = workstationIPage.getRecords();
|
List<StatisticsDataVO> statisticsDataVOS = new ArrayList<>();
|
workstationList.forEach(workstation -> {
|
StatisticsDataVO statisticsDataVO = new StatisticsDataVO();
|
statisticsDataVO.setId(String.valueOf(workstation.getId()));
|
statisticsDataVO.setWorkstationCode(workstation.getCode());
|
statisticsDataVO.setWorkstationName(workstation.getName());
|
Map<Integer, List<SuperAggregate>> map = (Map) collectGroupByShift.get(workstation.getId());
|
LinkedHashMap<String, String> data = new LinkedHashMap<>();
|
LinkedHashMap<String, String> shiftData = new LinkedHashMap<>();
|
List<ShiftIndexNameDTO> shiftDetails = (List) idToValue.get(workstation.getId());
|
List<Integer> trueShiftIndexList = new ArrayList<>();
|
Map<Integer, String> shiftIndexToName = new HashMap<>();
|
if (Func.isNotEmpty(shiftDetails)) {
|
trueShiftIndexList = (List) shiftDetails.stream().map((v0) -> {
|
return v0.getShiftIndex();
|
}).collect(Collectors.toList());
|
shiftIndexToName = (Map) shiftDetails.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getShiftIndex();
|
}, (v0) -> {
|
return v0.getIndexName();
|
}));
|
}
|
if (Func.isEmpty(map)) {
|
List<Integer> finalTrueShiftIndexList = trueShiftIndexList;
|
Map<Integer, String> finalShiftIndexToName = shiftIndexToName;
|
shiftIndexList.forEach(shiftIndex -> {
|
if (finalTrueShiftIndexList.contains(shiftIndex)) {
|
data.put(shiftIndex.toString(), "0");
|
shiftData.put(shiftIndex.toString(), finalShiftIndexToName.get(shiftIndex));
|
return;
|
}
|
data.put(shiftIndex.toString(), "-");
|
shiftData.put(shiftIndex.toString(), MessageUtils.message("mdc.not.schedule", new Object[0]));
|
});
|
} else {
|
Map<Integer, String> finalShiftIndexToName1 = shiftIndexToName;
|
List<Integer> finalTrueShiftIndexList1 = trueShiftIndexList;
|
shiftIndexList.forEach(shiftIndex2 -> {
|
if (finalTrueShiftIndexList1.contains(shiftIndex2)) {
|
List<SuperAggregate> superAggregateList = (List) map.get(shiftIndex2);
|
String value = getValue(superAggregateList, isOutput, productivityType);
|
data.put(shiftIndex2.toString(), value);
|
shiftData.put(shiftIndex2.toString(), finalShiftIndexToName1.get(shiftIndex2));
|
return;
|
}
|
data.put(shiftIndex2.toString(), "-");
|
shiftData.put(shiftIndex2.toString(), MessageUtils.message("mdc.not.schedule", new Object[0]));
|
});
|
}
|
statisticsDataVO.setData(data);
|
statisticsDataVO.setNameData(shiftData);
|
statisticsDataVOS.add(statisticsDataVO);
|
});
|
Page page = new Page();
|
page.setRecords(statisticsDataVOS);
|
page.setTotal(workstationIPage.getTotal()).setPages(workstationIPage.getPages()).setSize(workstationIPage.getSize()).setCurrent(workstationIPage.getCurrent());
|
statisticsVO.setItems(page);
|
return statisticsVO;
|
}
|
|
public String getValue(List<SuperAggregate> superAggregateList, Boolean output, ProductivityTypeEnum productivityType) {
|
String value;
|
if (output.booleanValue()) {
|
List<SuperAggregateOutput> superAggregateOutputList = getSuperAggregateOutputList(superAggregateList);
|
value = String.valueOf(calculateOutput(superAggregateOutputList));
|
} else {
|
List<SuperAggregateState> superAggregateStateList = getSuperAggregateStateList(superAggregateList);
|
value = String.valueOf(EifficiencyUtils.calculationResults(superAggregateStateList, productivityType));
|
}
|
return value;
|
}
|
|
public List<SuperAggregateOutput> getSuperAggregateOutputList(List<SuperAggregate> superAggregateList) {
|
List<SuperAggregateOutput> superAggregateOutputList = new ArrayList<>();
|
if (Func.isEmpty(superAggregateList)) {
|
return superAggregateOutputList;
|
}
|
superAggregateList.forEach(superAggregate -> {
|
if (superAggregate instanceof SuperAggregateOutput) {
|
superAggregateOutputList.add((SuperAggregateOutput) superAggregate);
|
}
|
});
|
return superAggregateOutputList;
|
}
|
|
public List<SuperAggregateState> getSuperAggregateStateList(List<SuperAggregate> superAggregateList) {
|
List<SuperAggregateState> superAggregateStateList = new ArrayList<>();
|
if (Func.isEmpty(superAggregateList)) {
|
return superAggregateStateList;
|
}
|
superAggregateList.forEach(superAggregate -> {
|
if (superAggregate instanceof SuperAggregateState) {
|
superAggregateStateList.add((SuperAggregateState) superAggregate);
|
}
|
});
|
return superAggregateStateList;
|
}
|
|
public Long calculateOutput(List<SuperAggregateOutput> superAggregateOutputList) {
|
List<SuperAggregateOutput> superAggregateOutputList2 = FilterOffUtils.filterOffDay(superAggregateOutputList, OpenTypeEnums.OUT_PUT);
|
if (Func.isEmpty(superAggregateOutputList2)) {
|
return 0L;
|
}
|
return Long.valueOf(superAggregateOutputList2.stream().mapToLong((v0) -> {
|
return v0.getOutput();
|
}).sum());
|
}
|
}
|
