package com.qianwen.smartman.modules.report.service.impl;
|
|
import cn.hutool.cache.CacheUtil;
|
import cn.hutool.cache.impl.TimedCache;
|
import cn.hutool.core.collection.CollectionUtil;
|
import cn.hutool.core.convert.Convert;
|
import cn.hutool.json.JSONObject;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import java.time.LocalDate;
|
import java.util.ArrayList;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.concurrent.Callable;
|
import java.util.function.Function;
|
import java.util.stream.Collectors;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import com.qianwen.core.tool.utils.BeanUtil;
|
import com.qianwen.core.tool.utils.Func;
|
import com.qianwen.smartman.modules.cps.dto.ShiftInfoDTO;
|
import com.qianwen.smartman.modules.cps.mapper.CalendarMapper;
|
import com.qianwen.smartman.modules.cps.mapper.WorkstationMapper;
|
import com.qianwen.smartman.modules.mdc.entity.SuperAggregateOutput;
|
import com.qianwen.smartman.modules.mdc.enums.OpenTypeEnums;
|
import com.qianwen.smartman.modules.mdc.enums.StatisticalMethodEnum;
|
import com.qianwen.smartman.modules.mdc.mapper.SuperAggregateOutputMapper;
|
import com.qianwen.smartman.modules.mdc.utils.FilterOffUtils;
|
import com.qianwen.smartman.modules.report.dto.WorkstationDataDTO;
|
import com.qianwen.smartman.modules.report.dto.WorkstationShiftDTO;
|
import com.qianwen.smartman.modules.report.mapper.CommonMapper;
|
import com.qianwen.smartman.modules.report.service.IOutputStatisticsReportService;
|
import com.qianwen.smartman.modules.report.utils.CommonUtil;
|
import com.qianwen.smartman.modules.report.utils.DateCycleUtil;
|
import com.qianwen.smartman.modules.report.utils.ResultUtil;
|
import com.qianwen.smartman.modules.report.utils.ThreadPoolUtil;
|
import com.qianwen.smartman.modules.report.vo.OutputResultVO;
|
import com.qianwen.smartman.modules.report.vo.OutputShiftResultVO;
|
import com.qianwen.smartman.modules.report.vo.StatisticsQueryVO;
|
import org.springframework.stereotype.Service;
|
|
@Service
|
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/report/service/impl/OutputStatisticsReportServiceImpl.class */
|
public class OutputStatisticsReportServiceImpl implements IOutputStatisticsReportService {
|
private final SuperAggregateOutputMapper aggregateOutputMapper;
|
private final WorkstationMapper workstationMapper;
|
private final CalendarMapper calendarMapper;
|
private final CommonMapper commonMapper;
|
private static final String TIME_CONDITION = "timeCondition";
|
private static final String OUTPUT_TABLE_NAME = "aggregate_output";
|
private static final int TIMEOUT = 1800000;
|
private static final String SHIFT_KYE = "shift-";
|
private static final String DATE_KYE = "date-";
|
private static final Logger log = LoggerFactory.getLogger(OutputStatisticsReportServiceImpl.class);
|
private static final TimedCache<String, OutputShiftResultVO> RESULT_TIMED_CACHE = CacheUtil.newTimedCache(1800000);
|
|
public OutputStatisticsReportServiceImpl(final SuperAggregateOutputMapper aggregateOutputMapper, final WorkstationMapper workstationMapper, final CalendarMapper calendarMapper, final CommonMapper commonMapper) {
|
this.aggregateOutputMapper = aggregateOutputMapper;
|
this.workstationMapper = workstationMapper;
|
this.calendarMapper = calendarMapper;
|
this.commonMapper = commonMapper;
|
}
|
|
@Override // org.springblade.modules.report.service.IOutputStatisticsReportService
|
public JSONObject outputStatisticsByShift(StatisticsQueryVO queryVO) {
|
queryVO.setBeginTime(DateCycleUtil.setTimeCondition(TIME_CONDITION, Boolean.TRUE));
|
queryVO.setEndTime(DateCycleUtil.setTimeCondition(TIME_CONDITION, Boolean.FALSE));
|
StatisticalMethodEnum anEnum = StatisticalMethodEnum.DAY;
|
List<String> fillDateCol = DateCycleUtil.fillDateCol(queryVO.getBeginTime(), queryVO.getEndTime(), anEnum);
|
IPage<WorkstationDataDTO> iPage = workstations(queryVO);
|
List<WorkstationDataDTO> workstationData = iPage.getRecords();
|
if (CollectionUtil.isEmpty(workstationData)) {
|
return new JSONObject();
|
}
|
List<Long> ids = workstationData.parallelStream().map((v0) -> {
|
return v0.getWorkstationId();
|
}).collect(Collectors.toList());
|
List<ShiftInfoDTO> shiftInfoDtoList = this.calendarMapper.listShiftInfo(ids, LocalDate.parse(queryVO.getBeginTime()), LocalDate.parse(queryVO.getEndTime()));
|
List<WorkstationShiftDTO> workstationShifts = CommonUtil.dataMerge(workstationData, shiftInfoDtoList);
|
List<WorkstationShiftDTO> filter =workstationShifts.parallelStream().filter(CommonUtil.conditionFilter(queryVO.getShiftName(), queryVO.getShiftIndex())).collect(Collectors.toList());
|
List<OutputShiftResultVO> result = settingResult(fillDateCol, filter);
|
String beginTime = DateCycleUtil.getDateByDateCycle(queryVO.getBeginTime(), anEnum, Boolean.TRUE);
|
String endTime = DateCycleUtil.getDateByDateCycle(queryVO.getEndTime(), anEnum, Boolean.FALSE);
|
List<SuperAggregateOutput> outputs = multithreadingTask(beginTime, endTime, ids, queryVO.getStatisticsType());
|
Map<String, List<SuperAggregateOutput>> workstationOutMap = outputs.parallelStream().collect(Collectors.groupingBy(s -> {
|
return s.getWorkstationId() + "-" + s.getShiftIndex();
|
}));
|
//Map<String, OutputShiftResultVO> voMap2 = (Map<String, OutputShiftResultVO>)result.parallelStream().collect(LinkedHashMap::new, (map, c) -> {map.put(c.getWorkstationId() + "-" + c.getShiftIndex() + "-" + c.getDateCycle(), c)}, Map::putAll);
|
|
Map<String, OutputShiftResultVO> voMap = result.parallelStream().collect(LinkedHashMap::new, (map, c) -> {
|
|
OutputShiftResultVO outputShiftResultVO = (OutputShiftResultVO) map.put(c.getWorkstationId() + "-" + c.getShiftIndex() + "-" + c.getDateCycle(), c);
|
}, (v0, v1) -> {
|
v0.putAll(v1);
|
}); /**/
|
resultCount(workstationOutMap, anEnum, voMap);
|
return ResultUtil.dataToJsonObject(voMap.values(), Long.valueOf(iPage.getTotal()), queryVO.getPageSize());
|
}
|
|
private List<OutputShiftResultVO> settingResult(List<String> fillDateCol, List<? extends WorkstationDataDTO> filter) {
|
List<OutputShiftResultVO> result = new ArrayList<>();
|
fillDateCol.forEach(f -> {
|
filter.forEach(shift -> {
|
String key = f + "-" + shift.getWorkstationId();
|
String key2 = shift instanceof WorkstationShiftDTO ? SHIFT_KYE + ((WorkstationShiftDTO) shift).getShiftIndex() + key : DATE_KYE + key;
|
OutputShiftResultVO resultVO = (OutputShiftResultVO) RESULT_TIMED_CACHE.get(key2);
|
if (resultVO == null) {
|
resultVO = new OutputShiftResultVO();
|
RESULT_TIMED_CACHE.put(key2, resultVO);
|
}
|
BeanUtil.copyProperties(shift, resultVO);
|
resultVO.setDateCycle(f);
|
resultVO.setOutputCount(0L);
|
result.add(resultVO);
|
});
|
});
|
return result;
|
}
|
|
private <T, R extends OutputResultVO> void resultCount(Map<T, List<SuperAggregateOutput>> workstationOutMap, StatisticalMethodEnum anEnum, Map<String, R> voMap) {
|
workstationOutMap.forEach((outputKey, outputList) -> {
|
Map<String, Long> output = outputList.parallelStream().collect(Collectors.groupingBy(groupKey(anEnum), Collectors.mapping((v0) -> {
|
return v0.getOutput();
|
}, Collectors.reducing(0L, (v0, v1) -> {
|
return Long.sum(v0, v1);
|
}))));
|
output.forEach((k, v) -> {
|
OutputResultVO vo = (OutputResultVO) voMap.get(outputKey + "-" + k);
|
if (!Objects.isNull(vo)) {
|
vo.setOutputCount(v);
|
}
|
});
|
});
|
}
|
|
private IPage<WorkstationDataDTO> workstations(StatisticsQueryVO queryVO) {
|
IPage<WorkstationDataDTO> workstationData;
|
IPage<WorkstationDataDTO> workstationData2 = CommonUtil.getIPage(WorkstationDataDTO.class, queryVO.getPageSize(), queryVO.getPageNo(), this.workstationMapper);
|
if (Func.isEmpty(queryVO.getShiftName())) {
|
workstationData = this.workstationMapper.getWorkstationData(workstationData2, queryVO.getKeyword(), queryVO.getWorkstationIds());
|
} else {
|
workstationData = this.workstationMapper.getWorkstationDataWithIndexName(workstationData2, queryVO.getKeyword(), queryVO.getShiftName(), queryVO.getBeginTime(), queryVO.getEndTime(), queryVO.getWorkstationIds());
|
}
|
CommonUtil.fillWorkStationGroup(workstationData);
|
return workstationData;
|
}
|
|
@Override // org.springblade.modules.report.service.IOutputStatisticsReportService
|
public JSONObject outputStatisticsByDate(StatisticsQueryVO queryVO) {
|
queryVO.setBeginTime(DateCycleUtil.setTimeCondition(TIME_CONDITION, Boolean.TRUE));
|
queryVO.setEndTime(DateCycleUtil.setTimeCondition(TIME_CONDITION, Boolean.FALSE));
|
StatisticalMethodEnum anEnum = StatisticalMethodEnum.of(queryVO.getDateCycle());
|
List<String> fillDateCol = DateCycleUtil.fillDateCol(queryVO.getBeginTime(), queryVO.getEndTime(), anEnum);
|
String beginTime = DateCycleUtil.getDateByDateCycle(queryVO.getBeginTime(), anEnum, Boolean.TRUE);
|
String endTime = DateCycleUtil.getDateByDateCycle(queryVO.getEndTime(), anEnum, Boolean.FALSE);
|
IPage<WorkstationDataDTO> iPage = workstations(queryVO);
|
List<WorkstationDataDTO> workstationData = iPage.getRecords();
|
if (CollectionUtil.isEmpty(workstationData)) {
|
return new JSONObject();
|
}
|
List<OutputResultVO> result = Convert.toList(OutputResultVO.class, settingResult(fillDateCol, workstationData));
|
Map<String, OutputResultVO> voMap = result.parallelStream().collect(Collectors.toMap(c -> {
|
return c.getWorkstationId() + "-" + c.getDateCycle();
|
}, o -> {
|
return o;
|
}));
|
List<Long> ids = workstationData.parallelStream().map((v0) -> {
|
return v0.getWorkstationId();
|
}).collect(Collectors.toList());
|
List<SuperAggregateOutput> outputs = multithreadingTask(beginTime, endTime, ids, queryVO.getStatisticsType());
|
Map<Long, List<SuperAggregateOutput>> workstationOutMap = outputs.parallelStream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getWorkstationId();
|
}));
|
resultCount(workstationOutMap, anEnum, voMap);
|
return ResultUtil.dataToJsonObject(voMap.values(), Long.valueOf(iPage.getTotal()), queryVO.getPageSize());
|
}
|
|
private Function<SuperAggregateOutput, String> groupKey(StatisticalMethodEnum statisticalMethodEnum) {
|
switch (statisticalMethodEnum) {
|
case DAY:
|
return output -> {
|
return DateCycleUtil.getDateCycle(statisticalMethodEnum, String.valueOf(output.getFactoryDate()));
|
};
|
case WEEK:
|
return output2 -> {
|
return DateCycleUtil.getDateCycle(statisticalMethodEnum, String.valueOf(output2.getFactoryWeek()));
|
};
|
case MONTH:
|
return output3 -> {
|
return DateCycleUtil.getDateCycle(statisticalMethodEnum, String.valueOf(output3.getFactoryMonth()));
|
};
|
default:
|
return output4 -> {
|
return DateCycleUtil.getDateCycle(statisticalMethodEnum, String.valueOf(output4.getWorkstationId()));
|
};
|
}
|
}
|
|
private List<SuperAggregateOutput> multithreadingTask(String beginTime, String endTime, List<Long> workstationIds, Integer statisticsType) {
|
List<String> childOutputTables = this.commonMapper.getItemBySuperTable(OUTPUT_TABLE_NAME, workstationIds);
|
if (CollectionUtil.isEmpty(childOutputTables)) {
|
return new ArrayList();
|
}
|
List<Callable<List<SuperAggregateOutput>>> callables = new ArrayList<>();
|
workstationIds.forEach(id -> {
|
callables.add(() -> {
|
if (!childOutputTables.contains("aggregate_output_" + id)) {
|
return new ArrayList();
|
}
|
List<SuperAggregateOutput> output = this.aggregateOutputMapper.getOutputByDateCycleAndWorkstationId(beginTime, endTime, id, statisticsType);
|
return FilterOffUtils.filterOffDay(output, OpenTypeEnums.OUT_PUT);
|
});
|
});
|
return ThreadPoolUtil.createTaskList(callables);
|
}
|
}
|
