package com.qianwen.smartman.modules.mdc.service.impl;
|
|
import java.util.ArrayList;
|
import java.util.Collection;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.stream.Collectors;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.stereotype.Service;
|
import org.springframework.web.multipart.MultipartFile;
|
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.google.common.collect.Lists;
|
import com.qianwen.core.excel.util.ExcelUtil;
|
import com.qianwen.core.mp.support.Condition;
|
import com.qianwen.core.mp.support.Query;
|
import com.qianwen.core.oss.model.BladeFile;
|
import com.qianwen.core.tool.utils.DateUtil;
|
import com.qianwen.core.tool.utils.Func;
|
import com.qianwen.smartman.common.constant.CommonConstant;
|
import com.qianwen.smartman.common.constant.ExcelConstant;
|
import com.qianwen.smartman.common.constant.MdcConstant;
|
import com.qianwen.smartman.common.constant.ShiftConstant;
|
import com.qianwen.smartman.common.utils.LocalDateTimeUtils;
|
import com.qianwen.smartman.common.utils.MessageUtils;
|
import com.qianwen.smartman.modules.cps.convert.WorkstationConvert;
|
import com.qianwen.smartman.modules.cps.dto.ShiftInfoDTO;
|
import com.qianwen.smartman.modules.cps.entity.Workstation;
|
import com.qianwen.smartman.modules.cps.enums.WorkstationTypeEnum;
|
import com.qianwen.smartman.modules.cps.mapper.WorkstationMapper;
|
import com.qianwen.smartman.modules.cps.service.IShiftDetailService;
|
import com.qianwen.smartman.modules.cps.service.IWorkstationService;
|
import com.qianwen.smartman.modules.cps.vo.WorkstationVO;
|
import com.qianwen.smartman.modules.mdc.dto.IntervalDateDto;
|
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.enums.OpenTypeEnums;
|
import com.qianwen.smartman.modules.mdc.enums.StatisticalMethodEnum;
|
import com.qianwen.smartman.modules.mdc.excel.OutputShiftIndexSheetExcel;
|
import com.qianwen.smartman.modules.mdc.service.IOutputStatisticsService;
|
import com.qianwen.smartman.modules.mdc.service.IStatisticsService;
|
import com.qianwen.smartman.modules.mdc.service.ISuperAggregateOutputService;
|
import com.qianwen.smartman.modules.mdc.utils.ExcelStrategyUtil;
|
import com.qianwen.smartman.modules.mdc.utils.FilterOffUtils;
|
import com.qianwen.smartman.modules.mdc.vo.AnalysisFilterVO;
|
import com.qianwen.smartman.modules.mdc.vo.SplitFilterListVO;
|
import com.qianwen.smartman.modules.mdc.vo.SplitFilterVO;
|
import com.qianwen.smartman.modules.mdc.vo.StatisticsAnalysisQueryVO;
|
import com.qianwen.smartman.modules.mdc.vo.StatisticsVO;
|
import com.qianwen.smartman.modules.mdc.wrapper.StatisticsWrapper;
|
import com.qianwen.smartman.modules.resource.builder.oss.OssBuilder;
|
|
import cn.hutool.core.util.StrUtil;
|
|
@Service
|
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/mdc/service/impl/OutputStatisticsServiceImpl.class */
|
public class OutputStatisticsServiceImpl implements IOutputStatisticsService {
|
private static final String ZERO = "0";
|
private final IWorkstationService workstationService;
|
private final ISuperAggregateOutputService superAggregateOutputService;
|
private final StatisticsWrapper wrapper;
|
private final WorkstationMapper workstationMapper;
|
private final IShiftDetailService shiftDetailService;
|
private final OssBuilder ossBuilder;
|
private final IStatisticsService statisticsService;
|
private static final Logger log = LoggerFactory.getLogger(OutputStatisticsServiceImpl.class);
|
private static final String FILENAME = String.format("%s-%s.xlsx", ExcelConstant.OUTPUT_ACCOUNT, DateUtil.time());
|
|
public OutputStatisticsServiceImpl(final IWorkstationService workstationService, final ISuperAggregateOutputService superAggregateOutputService, final StatisticsWrapper wrapper, final WorkstationMapper workstationMapper, final IShiftDetailService shiftDetailService, final OssBuilder ossBuilder, final IStatisticsService statisticsService) {
|
this.workstationService = workstationService;
|
this.superAggregateOutputService = superAggregateOutputService;
|
this.wrapper = wrapper;
|
this.workstationMapper = workstationMapper;
|
this.shiftDetailService = shiftDetailService;
|
this.ossBuilder = ossBuilder;
|
this.statisticsService = statisticsService;
|
}
|
|
@Override // org.springblade.modules.mdc.service.IOutputStatisticsService
|
public StatisticsVO outputStatistics(StatisticsAnalysisQueryVO statisticsAnalysisQueryVO, Query query) {
|
List<String> workStationIdList = statisticsAnalysisQueryVO.getWorkStationIdList();
|
if (Func.isEmpty(workStationIdList)) {
|
workStationIdList = this.workstationService.list(Wrappers.<Workstation>lambdaQuery().eq(Workstation::getType, WorkstationTypeEnum.MACHINE.getCode())
|
.eq(Workstation::getStatus, CommonConstant.ENABLE)).stream().map(s -> Func.toStr(s.getId())).collect(Collectors.toList());
|
/*
|
workStationIdList = (List) this.workstationService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getType();
|
}, WorkstationTypeEnum.MACHINE.getCode())).eq((v0) -> {
|
return v0.getStatus();
|
}, CommonConstant.ENABLE)).stream().map(s -> {
|
return Func.toStr(s.getId());
|
}).collect(Collectors.toList());*/
|
}
|
IPage<WorkstationVO> workstationVOPage = this.workstationMapper.queryWorkstationAndGroup(Condition.getPage(query), Func.toLongList(workStationIdList));
|
IPage<Workstation> workstationPage = WorkstationConvert.INSTANCE.convert(workstationVOPage);
|
List<Long> workstationIds = workstationPage.getRecords().stream().map((v0) -> {
|
return v0.getId();
|
}).collect(Collectors.toList());
|
List<IntervalDateDto> intervalDates = LocalDateTimeUtils.getIntervalDate(statisticsAnalysisQueryVO.getStartDate(), statisticsAnalysisQueryVO.getEndDate());
|
List<SuperAggregateOutput> superAggregateOutputByNaturalDate = this.superAggregateOutputService.getOutputData(workstationIds, statisticsAnalysisQueryVO.getStatisticalMethod(), statisticsAnalysisQueryVO.getStartDate(), statisticsAnalysisQueryVO.getEndDate());
|
List<SuperAggregateOutput> superAggregateList = FilterOffUtils.filterOffDay(superAggregateOutputByNaturalDate, OpenTypeEnums.OUT_PUT);
|
StatisticsWrapperDto statisticsWrapperDto = new StatisticsWrapperDto(superAggregateList, statisticsAnalysisQueryVO, intervalDates, workstationPage, MdcConstant.OUTPUT);
|
return this.wrapper.entityVO(statisticsWrapperDto);
|
}
|
|
@Override // org.springblade.modules.mdc.service.IOutputStatisticsService
|
public BladeFile export(StatisticsAnalysisQueryVO analysisQueryVO) {
|
StatisticalMethodEnum statisticalMethod = analysisQueryVO.getStatisticalMethod();
|
List<String> workStationIdList = analysisQueryVO.getWorkStationIdList();
|
if (Func.isEmpty(workStationIdList)) {
|
workStationIdList = (List<String>)this.workstationService.list(Wrappers.<Workstation>lambdaQuery()
|
.eq(Workstation::getType, WorkstationTypeEnum.MACHINE.getCode())
|
.eq(Workstation::getStatus, CommonConstant.ENABLE)).stream().map(s -> Func.toStr(s.getId())).collect(Collectors.toList());
|
/*
|
workStationIdList = (List) this.workstationService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getType();
|
}, WorkstationTypeEnum.MACHINE.getCode())).eq((v0) -> {
|
return v0.getStatus();
|
}, CommonConstant.ENABLE)).stream().map(s -> {
|
return Func.toStr(s.getId());
|
}).collect(Collectors.toList());*/
|
}
|
List<Long> workstationIds = workStationIdList.stream().map(Long::valueOf).collect(Collectors.toList());
|
if (Func.isEmpty(workstationIds)) {
|
return exportEmpty(statisticalMethod);
|
}
|
List<IntervalDateDto> intervalDates = LocalDateTimeUtils.getIntervalDate(analysisQueryVO.getStartDate(), analysisQueryVO.getEndDate());
|
List<SuperAggregateOutput> superAggregateOutputByNaturalDate = this.superAggregateOutputService.getOutputData(workstationIds, analysisQueryVO.getStatisticalMethod(), analysisQueryVO.getStartDate(), analysisQueryVO.getEndDate());
|
List<SuperAggregate> superAggregateList = new ArrayList<>(superAggregateOutputByNaturalDate);
|
List<WorkstationVO> workstationVOList = this.workstationMapper.queryWorkstationAndGroup(Condition.getPage(new Query().setSize(-1)), workstationIds).getRecords();
|
if (StatisticalMethodEnum.SHIFT.equals(statisticalMethod)) {
|
List<ShiftInfoDTO> shiftInfoDtoList = this.shiftDetailService.getShiftInfoDtoList(workstationIds, analysisQueryVO.getStartDate(), analysisQueryVO.getEndDate());
|
Map<String, String> shiftInfoMap = shiftInfoDtoList.stream().collect(Collectors.toMap(s2 -> {
|
return s2.getDate() + "-" + s2.getWorkstationId() + "-" + s2.getShiftIndex();
|
}, (v0) -> {
|
return v0.getIndexName();
|
}));
|
return exportOutputShift(intervalDates, superAggregateList, workstationVOList, analysisQueryVO.getShiftIndexList(), shiftInfoMap);
|
}
|
return exportOutputs(superAggregateOutputByNaturalDate, workstationVOList, analysisQueryVO);
|
}
|
|
private BladeFile exportEmpty(StatisticalMethodEnum statisticalMethodEnum) {
|
if (statisticalMethodEnum == StatisticalMethodEnum.SHIFT) {
|
List<OutputShiftIndexSheetExcel> sheetExcels = new ArrayList<>();
|
MultipartFile shiftMultipartFile = ExcelUtil.exportToMultipartFile(FILENAME, ExcelConstant.OUTPUT_ACCOUNT, sheetExcels, OutputShiftIndexSheetExcel.class);
|
return this.ossBuilder.tempTemplate().putFile(shiftMultipartFile.getOriginalFilename(), shiftMultipartFile);
|
}
|
List<List<String>> heads = new ArrayList<>();
|
List<List<Object>> columnData = new ArrayList<>();
|
MultipartFile multipartFile;
|
try {
|
multipartFile = ExcelStrategyUtil.customerExport(FILENAME, ExcelConstant.OUTPUT_ACCOUNT, heads, columnData);
|
return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
|
} catch (Exception e) {
|
log.error("导出错误",e);
|
throw new RuntimeException(e);
|
}
|
|
}
|
|
private BladeFile exportOutputs(List<SuperAggregateOutput> aggregateOutputs, List<WorkstationVO> workstationVOList, StatisticsAnalysisQueryVO statisticsAnalysisQueryVO) {
|
List<List<String>> heads = new ArrayList<>();
|
List<List<Object>> columnData = new ArrayList<>();
|
AnalysisFilterVO analysisFilterVO = new AnalysisFilterVO();
|
StatisticalMethodEnum statisticalMethod = statisticsAnalysisQueryVO.getStatisticalMethod();
|
analysisFilterVO.setStatisticalMethod(statisticalMethod);
|
analysisFilterVO.setStartDate(statisticsAnalysisQueryVO.getStartDate());
|
analysisFilterVO.setEndDate(statisticsAnalysisQueryVO.getEndDate());
|
analysisFilterVO.setIsReverse(true);
|
SplitFilterListVO splitFilterListVO = this.statisticsService.organizeQueryConditions(analysisFilterVO);
|
Collection<SplitFilterVO> items = splitFilterListVO.getItems();
|
buildExcelHeads(heads, items, statisticalMethod);
|
buildExcelData(columnData, workstationVOList, statisticsAnalysisQueryVO, items, aggregateOutputs);
|
try {
|
MultipartFile multipartFile = ExcelStrategyUtil.customerExport(FILENAME, ExcelConstant.OUTPUT_ACCOUNT, heads, columnData);
|
return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
|
} catch (Exception e) {
|
log.error("导出错误",e);
|
throw new RuntimeException(e);
|
}
|
}
|
|
public BladeFile exportOutputShift(List<IntervalDateDto> intervalDates, List<SuperAggregate> superAggregates, List<WorkstationVO> workstationVOList, List<Integer> shiftIndexList, Map<String, String> shiftInfoMap) {
|
Map<String, List<SuperAggregate>> map =superAggregates.stream().collect(Collectors.groupingBy(s -> {
|
return s.getFactoryDate() + "-" + s.getWorkstationId() + "-" + s.getShiftIndex();
|
}));
|
List<OutputShiftIndexSheetExcel> sheetExcels = new ArrayList<>();
|
IntervalDateDto intervalDateDto = intervalDates.get(0);
|
intervalDateDto.getDayList().forEach(dayString -> {
|
workstationVOList.forEach(wId -> {
|
OutputShiftIndexSheetExcel excel = new OutputShiftIndexSheetExcel();
|
excel.setDate(dayString).setGroupName(wId.getGroupName()).setWorkstationCode(wId.getCode()).setWorkstationName(wId.getName());
|
shiftIndexList.forEach(index -> {
|
String stringDayKey = StrUtil.format("{}-{}-{}", new Object[]{dayString, wId.getId(), index});
|
String intDayKey = StrUtil.format("{}-{}-{}", new Object[]{dayString.replace("-", ""), wId.getId(), index});
|
String shiftName = (String) shiftInfoMap.get(stringDayKey);
|
if (Func.isBlank(shiftName)) {
|
buildEmptyData(index, excel, MessageUtils.message("mdc.not.schedule", new Object[0]));
|
return;
|
}
|
List<SuperAggregate> superAggregateList = map.get(intDayKey);
|
if (Func.isEmpty(superAggregateList)) {
|
buildData(index, excel, shiftName, ZERO);
|
return;
|
}
|
String value = this.wrapper.getValue(superAggregateList, MdcConstant.OUTPUT, null);
|
buildData(index, excel, shiftName, value);
|
});
|
sheetExcels.add(excel);
|
});
|
});
|
MultipartFile multipartFile = ExcelUtil.exportToMultipartFile(FILENAME, ExcelConstant.OUTPUT_ACCOUNT, sheetExcels, OutputShiftIndexSheetExcel.class);
|
return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
|
}
|
|
private void buildExcelData(List<List<Object>> data, List<WorkstationVO> workstationVOList, StatisticsAnalysisQueryVO statisticsAnalysisQueryVO, Collection<SplitFilterVO> items, List<SuperAggregateOutput> aggregateOutputs) {
|
StatisticalMethodEnum statisticalMethod = statisticsAnalysisQueryVO.getStatisticalMethod();
|
workstationVOList.forEach(workstationVO -> {
|
List<Long> keyList;
|
Map<Long, List<SuperAggregateOutput>> map;
|
List<Object> arrayList = new ArrayList<>();
|
arrayList.add(workstationVO.getGroupName());
|
arrayList.add(workstationVO.getCode());
|
arrayList.add(workstationVO.getName());
|
|
Long workstationId = workstationVO.getId();
|
switch (statisticalMethod) {
|
case DAY:
|
keyList = items.stream().map(s -> {
|
return Long.valueOf(workstationId.longValue() + Integer.parseInt(s.getDate().replace("-", "")));
|
}).collect(Collectors.toList());
|
map = aggregateOutputs.stream().collect(Collectors.groupingBy(s2 -> {
|
return Long.valueOf(s2.getWorkstationId().longValue() + s2.getFactoryDate().intValue());
|
}));
|
break;
|
case WEEK:
|
keyList = items.stream().map(s3 -> {
|
return Long.valueOf(workstationId.longValue() + s3.getYear().intValue() + s3.getWeek().intValue());
|
}).collect(Collectors.toList());
|
map = aggregateOutputs.stream().collect(Collectors.groupingBy(s4 -> {
|
return Long.valueOf(s4.getWorkstationId().longValue() + s4.getFactoryYear().intValue() + s4.getFactoryWeek().intValue());
|
}));
|
break;
|
default:
|
keyList = items.stream().map(s5 -> {
|
return Long.valueOf(workstationId.longValue() + s5.getYear().intValue() + s5.getMonth().intValue());
|
}).collect(Collectors.toList());
|
map = aggregateOutputs.stream().collect(Collectors.groupingBy(s6 -> {
|
return Long.valueOf(s6.getWorkstationId().longValue() + s6.getFactoryYear().intValue() + s6.getFactoryMonth().intValue());
|
}));
|
break;
|
}
|
Map<Long, List<SuperAggregateOutput>> finalMap = map;
|
keyList.forEach(key -> {
|
List<SuperAggregateOutput> superAggregateOutputs = finalMap.get(key);
|
if (Func.isEmpty(superAggregateOutputs)) {
|
arrayList.add(ZERO);
|
} else {
|
arrayList.add(Func.toStr(this.wrapper.calculateOutput(superAggregateOutputs)));
|
}
|
});
|
data.add(arrayList);
|
});
|
}
|
|
private void buildExcelHeads(List<List<String>> head, Collection<SplitFilterVO> items, StatisticalMethodEnum statisticalMethod) {
|
String the = MessageUtils.message("mdc.efficiency.analysis.the", new Object[0]);
|
String week = MessageUtils.message("mdc.efficiency.analysis.week", new Object[0]);
|
head.add(Lists.newArrayList(new String[]{MessageUtils.message("mdc.excel.workstationGroup", new Object[0])}));
|
head.add(Lists.newArrayList(new String[]{MessageUtils.message("mdc.excel.workstationCode", new Object[0])}));
|
head.add(Lists.newArrayList(new String[]{MessageUtils.message("mdc.excel.workstationName", new Object[0])}));
|
items.forEach(splitFilterVO -> {
|
switch (statisticalMethod) {
|
case DAY:
|
head.add(Lists.newArrayList(new String[]{splitFilterVO.getDate()}));
|
return;
|
case WEEK:
|
head.add(Lists.newArrayList(new String[]{StrUtil.format("{}-{}{}{}", new Object[]{splitFilterVO.getYear(), the, splitFilterVO.getWeek(), week})}));
|
return;
|
default:
|
head.add(Lists.newArrayList(new String[]{splitFilterVO.getTitle()}));
|
return;
|
}
|
});
|
}
|
|
private void buildEmptyData(Integer shiftIndex, OutputShiftIndexSheetExcel excel, String message) {
|
if (ShiftConstant.SHIFT1.equals(shiftIndex)) {
|
excel.setShift1(message);
|
excel.setYield1("-");
|
} else if (ShiftConstant.SHIFT2.equals(shiftIndex)) {
|
excel.setShift2(message);
|
excel.setYield2("-");
|
} else if (ShiftConstant.SHIFT3.equals(shiftIndex)) {
|
excel.setShift3(message);
|
excel.setYield3("-");
|
} else {
|
excel.setShift4(message);
|
excel.setYield4("-");
|
}
|
}
|
|
private void buildData(Integer shiftIndex, OutputShiftIndexSheetExcel excel, String shiftName, String yield) {
|
if (ShiftConstant.SHIFT1.equals(shiftIndex)) {
|
excel.setShift1(shiftName);
|
excel.setYield1(yield);
|
} else if (ShiftConstant.SHIFT2.equals(shiftIndex)) {
|
excel.setShift2(shiftName);
|
excel.setYield2(yield);
|
} else if (ShiftConstant.SHIFT3.equals(shiftIndex)) {
|
excel.setShift3(shiftName);
|
excel.setYield3(yield);
|
} else {
|
excel.setShift4(shiftName);
|
excel.setYield4(yield);
|
}
|
}
|
}
|
