package com.qianwen.smartman.modules.report.service.impl;
|
|
import cn.hutool.core.date.DateTime;
|
import cn.hutool.core.date.DateUtil;
|
import cn.hutool.core.date.LocalDateTimeUtil;
|
import cn.hutool.core.util.NumberUtil;
|
import cn.hutool.json.JSONObject;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import java.sql.Timestamp;
|
import java.time.LocalDate;
|
import java.time.temporal.ChronoUnit;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.Iterator;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.Set;
|
import java.util.function.Function;
|
import java.util.stream.Collectors;
|
import org.jetbrains.annotations.NotNull;
|
import com.qianwen.smartman.common.constant.DateConstant;
|
import com.qianwen.smartman.common.utils.LocalDateTimeUtils;
|
import com.qianwen.smartman.common.utils.LocalDateUtil;
|
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.dto.IntervalDateDto;
|
import com.qianwen.smartman.modules.mdc.entity.SuperAggregateState;
|
import com.qianwen.smartman.modules.mdc.enums.ProductivityTypeEnum;
|
import com.qianwen.smartman.modules.mdc.enums.StatisticalMethodEnum;
|
import com.qianwen.smartman.modules.mdc.mapper.SuperAggregateStateMapper;
|
import com.qianwen.smartman.modules.mdc.utils.EifficiencyUtils;
|
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.IWorkstationEfficiencyService;
|
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.vo.WorkstationEfficiencyQueryVO;
|
import com.qianwen.smartman.modules.report.vo.WorkstationEfficiencySelectVO;
|
import com.qianwen.smartman.modules.report.vo.WorkstationEfficiencyVO;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
@Service
|
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/report/service/impl/WorkstationEfficiencyServiceImpl.class */
|
public class WorkstationEfficiencyServiceImpl implements IWorkstationEfficiencyService {
|
@Autowired
|
private WorkstationMapper workstationMapper;
|
@Autowired
|
private SuperAggregateStateMapper superAggregateStateMapper;
|
@Autowired
|
private CalendarMapper calendarMapper;
|
@Autowired
|
private CommonMapper commonMapper;
|
private static final String TIME_CONDITION = "time";
|
private static final String TABLE_NAME = "aggregate_state";
|
|
@Override // org.springblade.modules.report.service.IWorkstationEfficiencyService
|
public JSONObject byTime(WorkstationEfficiencySelectVO workstationEfficiencySelectVO) {
|
workstationEfficiencySelectVO.setStartTime(DateCycleUtil.setTimeCondition(TIME_CONDITION, Boolean.TRUE));
|
workstationEfficiencySelectVO.setEndTime(DateCycleUtil.setTimeCondition(TIME_CONDITION, Boolean.FALSE));
|
DateTime parse = DateUtil.parse(workstationEfficiencySelectVO.getStartTime(), DateConstant.PATTERN_DATE);
|
DateTime parse2 = DateUtil.parse(workstationEfficiencySelectVO.getEndTime(), DateConstant.PATTERN_DATE);
|
String workstationKeyWord = workstationEfficiencySelectVO.getName();
|
List<String> workstationIdsParam = workstationEfficiencySelectVO.getWorkstationIds();
|
Integer pageSize = workstationEfficiencySelectVO.getPageSize();
|
Integer pageNo = workstationEfficiencySelectVO.getPageNo();
|
Integer dateCycle = workstationEfficiencySelectVO.getDateCycle();
|
List<Integer> productivityTypes = workstationEfficiencySelectVO.getProductivityTypes();
|
if (Func.isEmpty(productivityTypes)) {
|
productivityTypes = ProductivityTypeEnum.codes();
|
}
|
IPage<WorkstationDataDTO> workstationVOPage = this.workstationMapper.getWorkstationData(CommonUtil.getIPage(WorkstationDataDTO.class, pageSize, pageNo, this.workstationMapper), workstationKeyWord, workstationIdsParam);
|
long total = workstationVOPage.getTotal();
|
if (Func.isEmpty(workstationVOPage.getRecords())) {
|
return ResultUtil.dataToJsonObject(null, Long.valueOf(total), pageSize);
|
}
|
CommonUtil.fillWorkStationGroup(workstationVOPage);
|
List<WorkstationDataDTO> workstationVOS = workstationVOPage.getRecords();
|
List<Long> workstationIds = workstationVOS.stream().map((v0) -> {
|
return v0.getWorkstationId();
|
}).distinct().collect(Collectors.toList());
|
List<SuperAggregateState> superAggregateStates = getStatusDataByFactoryDate(workstationIds, LocalDateTimeUtil.format(LocalDateUtil.dateToLocalDate(parse), "yyyyMMdd"), LocalDateTimeUtil.format(LocalDateUtil.dateToLocalDate(parse2), "yyyyMMdd"));
|
List<WorkstationEfficiencyVO> vos = buildByTimeVO(workstationVOS, superAggregateStates, productivityTypes, dateCycle, parse, parse2);
|
return ResultUtil.dataToJsonObject(vos, Long.valueOf(total), pageSize);
|
}
|
|
@Override // org.springblade.modules.report.service.IWorkstationEfficiencyService
|
public JSONObject byShift(@NotNull WorkstationEfficiencySelectVO workstationEfficiencySelectVO) {
|
IPage<WorkstationDataDTO> iPage;
|
workstationEfficiencySelectVO.setStartTime(DateCycleUtil.setTimeCondition(TIME_CONDITION, Boolean.TRUE));
|
workstationEfficiencySelectVO.setEndTime(DateCycleUtil.setTimeCondition(TIME_CONDITION, Boolean.FALSE));
|
String startTime = workstationEfficiencySelectVO.getStartTime();
|
String endTime = workstationEfficiencySelectVO.getEndTime();
|
List<Integer> productivityTypes = workstationEfficiencySelectVO.getProductivityTypes();
|
if (Func.isEmpty(productivityTypes)) {
|
productivityTypes = ProductivityTypeEnum.codes();
|
}
|
String workstationKeyWord = workstationEfficiencySelectVO.getName();
|
List<String> workstationIdsParam = workstationEfficiencySelectVO.getWorkstationIds();
|
String shiftIndexKeyWord = workstationEfficiencySelectVO.getShiftIndex();
|
Integer pageNo = workstationEfficiencySelectVO.getPageNo();
|
Integer pageSize = workstationEfficiencySelectVO.getPageSize();
|
IPage<WorkstationDataDTO> iPage2 = CommonUtil.getIPage(WorkstationDataDTO.class, pageSize, pageNo, this.workstationMapper);
|
StatisticalMethodEnum anEnum = StatisticalMethodEnum.DAY;
|
List<String> fillDateCol = DateCycleUtil.fillDateCol(startTime, endTime, anEnum);
|
if (Func.isEmpty(shiftIndexKeyWord)) {
|
iPage = this.workstationMapper.getWorkstationData(iPage2, workstationKeyWord, workstationIdsParam);
|
} else {
|
iPage = this.workstationMapper.getWorkstationDataWithIndexName(iPage2, workstationKeyWord, shiftIndexKeyWord, startTime, endTime, workstationIdsParam);
|
}
|
CommonUtil.fillWorkStationGroup(iPage);
|
List<WorkstationDataDTO> workstationData = iPage.getRecords();
|
if (Func.isEmpty(iPage.getRecords())) {
|
return ResultUtil.dataToJsonObject(null, Long.valueOf(iPage.getTotal()), pageSize);
|
}
|
List<Long> ids = (List) workstationData.parallelStream().map((v0) -> {
|
return v0.getWorkstationId();
|
}).collect(Collectors.toList());
|
List<ShiftInfoDTO> shiftInfoDtoList = this.calendarMapper.listShiftInfo(ids, LocalDate.parse(startTime), LocalDate.parse(endTime));
|
List<WorkstationShiftDTO> workstationShifts = CommonUtil.dataMerge(workstationData, shiftInfoDtoList);
|
List<WorkstationShiftDTO> filter = (List) workstationShifts.parallelStream().filter(CommonUtil.conditionFilter(shiftIndexKeyWord, null)).collect(Collectors.toList());
|
List<WorkstationEfficiencyVO> result = new ArrayList<>();
|
List<Integer> finalProductivityTypes = productivityTypes;
|
fillDateCol.forEach(f -> {
|
filter.forEach(shift -> {
|
Iterator it = finalProductivityTypes.iterator();
|
while (it.hasNext()) {
|
Integer code = (Integer) it.next();
|
WorkstationEfficiencyVO resultVO = new WorkstationEfficiencyVO();
|
resultVO.setWorkstationId(shift.getWorkstationId());
|
resultVO.setWorkstationCode(shift.getWorkstationCode());
|
resultVO.setWorkstationName(shift.getWorkstationName());
|
resultVO.setWorkstationNameGroupName(shift.getWorkstationGroup());
|
resultVO.setShiftIndex(shift.getShiftIndex());
|
resultVO.setShiftName(shift.getShiftName());
|
resultVO.setTime(f);
|
String percentFormat = toPercent(Double.valueOf(0.0d));
|
resultVO.setValue(percentFormat);
|
resultVO.setType(ProductivityTypeEnum.byCode(code.intValue()).getMessage());
|
result.add(resultVO);
|
}
|
});
|
});
|
String start = DateCycleUtil.getDateByDateCycle(startTime, anEnum, Boolean.TRUE);
|
String end = DateCycleUtil.getDateByDateCycle(endTime, anEnum, Boolean.FALSE);
|
WorkstationEfficiencyQueryVO workstationEfficiencyQueryVO = new WorkstationEfficiencyQueryVO();
|
workstationEfficiencyQueryVO.setStartTime(start);
|
workstationEfficiencyQueryVO.setEndTime(end);
|
workstationEfficiencyQueryVO.setWorkstationIds(ids);
|
List<SuperAggregateState> superAggregateStates = getStatusDataByFactoryDate(ids, start, end);
|
Map<String, List<SuperAggregateState>> workstationAggregateStateMap = superAggregateStates.parallelStream().collect(Collectors.groupingBy(s -> {
|
return s.getWorkstationId() + "_" + s.getShiftIndex();
|
}));
|
Map<String, WorkstationEfficiencyVO> voMap = (Map) result.parallelStream().collect(LinkedHashMap::new, (map, c) -> {
|
WorkstationEfficiencyVO workstationEfficiencyVO = (WorkstationEfficiencyVO) map.put(c.getWorkstationId() + "_" + c.getShiftIndex() + "_" + c.getTime() + "_" + c.getType(), c);
|
}, (v0, v1) -> {
|
v0.putAll(v1);
|
});
|
resultCount(workstationAggregateStateMap, anEnum, voMap, productivityTypes);
|
return ResultUtil.dataToJsonObject(voMap.values(), Long.valueOf(iPage.getTotal()), pageSize);
|
}
|
|
/* JADX WARN: Multi-variable type inference failed */
|
private List<WorkstationEfficiencyVO> buildByTimeVO(List<WorkstationDataDTO> workstationVOS, List<SuperAggregateState> superAggregateStates, List<Integer> productivityTypes, Integer dateCycle, Date startTime, Date endTime) {
|
Map<Long, WorkstationDataDTO> workstationVOMap = (Map) workstationVOS.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getWorkstationId();
|
}, item -> {
|
return item;
|
}));
|
Map<Integer, List<Integer>> yearListMap = groupYear(startTime, endTime, dateCycle);
|
List<WorkstationEfficiencyVO> vos = new ArrayList<>();
|
Map<Long, List<SuperAggregateState>> workStateMap = (Map) superAggregateStates.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getWorkstationId();
|
}));
|
Set<Integer> yearSet = yearListMap.keySet();
|
Set<Long> workstationSet = workstationVOMap.keySet();
|
for (Long id : workstationSet) {
|
WorkstationDataDTO workstationVO = workstationVOMap.get(id);
|
Map<Integer, List<SuperAggregateState>> yearStateList = new HashMap<>();
|
if (workStateMap.containsKey(id)) {
|
List<SuperAggregateState> workStateList = workStateMap.get(id);
|
yearStateList = (Map) workStateList.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getFactoryYear();
|
}));
|
}
|
for (Integer year : yearSet) {
|
Map<Integer, List<SuperAggregateState>> stateTime = new HashMap<>();
|
if (yearStateList.containsKey(year)) {
|
List<SuperAggregateState> stateYear = yearStateList.get(year);
|
if (Objects.equals(dateCycle, StatisticalMethodEnum.MONTH.getCode())) {
|
stateTime = stateYear.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getFactoryMonth();
|
}));
|
} else if (Objects.equals(dateCycle, StatisticalMethodEnum.WEEK.getCode())) {
|
stateTime = stateYear.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getFactoryWeek();
|
}));
|
} else if (Objects.equals(dateCycle, StatisticalMethodEnum.DAY.getCode())) {
|
stateTime = stateYear.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getFactoryDate();
|
}));
|
}
|
}
|
List<Integer> times = yearListMap.get(year);
|
for (Integer time : times) {
|
List<SuperAggregateState> states = stateTime.get(time);
|
for (Integer productivityType : productivityTypes) {
|
WorkstationEfficiencyVO workstationEfficiencyVO = buildVO(workstationVO, time, dateCycle, year, states, productivityType);
|
vos.add(workstationEfficiencyVO);
|
}
|
}
|
}
|
}
|
return vos;
|
}
|
|
private <T, R extends WorkstationEfficiencyVO> void resultCount(Map<T, List<SuperAggregateState>> workstationAggregateStateMap, StatisticalMethodEnum anEnum, Map<String, R> voMap, List<Integer> productivityTypes) {
|
workstationAggregateStateMap.forEach((key, list) -> {
|
Map<String, List<SuperAggregateState>> aggregateState = list.parallelStream().collect(Collectors.groupingBy(groupKey(anEnum)));
|
aggregateState.forEach((k, v) -> {
|
ProductivityTypeEnum[] values = ProductivityTypeEnum.values();
|
for (ProductivityTypeEnum productivityTypeEnum : values) {
|
WorkstationEfficiencyVO vo = (WorkstationEfficiencyVO) voMap.get(key + "_" + k + "_" + productivityTypeEnum.getMessage());
|
if (!Objects.isNull(vo)) {
|
Double percent = EifficiencyUtils.openShiftTypeCalculationResults(v, productivityTypeEnum);
|
String percentFormat = toPercent(percent);
|
vo.setValue(percentFormat);
|
}
|
}
|
});
|
});
|
}
|
|
private WorkstationEfficiencyVO buildVO(WorkstationDataDTO workstationVO, Integer time, Integer dateCycle, Integer year, List<SuperAggregateState> itemValue, Integer productivityType) {
|
String name = workstationVO.getWorkstationName();
|
String code = workstationVO.getWorkstationCode();
|
String groupName = workstationVO.getWorkstationGroup();
|
WorkstationEfficiencyVO workstationEfficiencyVO = new WorkstationEfficiencyVO();
|
workstationEfficiencyVO.setWorkstationCode(code);
|
workstationEfficiencyVO.setWorkstationName(name);
|
workstationEfficiencyVO.setWorkstationNameGroupName(groupName);
|
ProductivityTypeEnum productivityTypeEnum = ProductivityTypeEnum.byCode(productivityType.intValue());
|
Double percent = Double.valueOf(0.0d);
|
if (Func.isNotEmpty(productivityTypeEnum)) {
|
percent = EifficiencyUtils.openShiftTypeCalculationResults(itemValue, productivityTypeEnum);
|
}
|
String percentFormat = toPercent(percent);
|
workstationEfficiencyVO.setType(productivityTypeEnum.getMessage());
|
workstationEfficiencyVO.setValue(percentFormat);
|
String timeText = "";
|
if (Objects.equals(dateCycle, StatisticalMethodEnum.MONTH.getCode())) {
|
if (time.intValue() < 10) {
|
timeText = year + "-0" + time;
|
} else {
|
timeText = year + "-" + time;
|
}
|
} else if (Objects.equals(dateCycle, StatisticalMethodEnum.WEEK.getCode())) {
|
if (time.intValue() < 10) {
|
timeText = year + "-第0" + time + "周";
|
} else {
|
timeText = year + "-第" + time + "周";
|
}
|
} else if (Objects.equals(dateCycle, StatisticalMethodEnum.DAY.getCode())) {
|
timeText = DateUtil.format(DateUtil.parse(String.valueOf(time), "yyyyMMdd"), DateConstant.PATTERN_DATE);
|
}
|
workstationEfficiencyVO.setTime(timeText);
|
return workstationEfficiencyVO;
|
}
|
|
private Map<Integer, List<Integer>> groupYear(Date startTime, Date endTime, Integer dateCycle) {
|
LocalDate startLocal = LocalDateTimeUtils.dateToLocalDate(startTime);
|
LocalDate endLocal = LocalDateTimeUtils.dateToLocalDate(endTime);
|
HashMap<Integer, List<Integer>> data = new HashMap<>();
|
List<IntervalDateDto> dateDtos = LocalDateTimeUtils.getIntervalDate(startLocal, endLocal);
|
for (IntervalDateDto intervalDateDto : dateDtos) {
|
if (Objects.equals(dateCycle, StatisticalMethodEnum.MONTH.getCode())) {
|
data.put(intervalDateDto.getYear(), intervalDateDto.getMonthList());
|
} else if (Objects.equals(dateCycle, StatisticalMethodEnum.WEEK.getCode())) {
|
data.put(intervalDateDto.getYear(), intervalDateDto.getWeekList());
|
} else if (Objects.equals(dateCycle, StatisticalMethodEnum.DAY.getCode())) {
|
data.put(intervalDateDto.getYear(), intervalDateDto.getDayList().stream().map(item -> {
|
return Integer.valueOf(DateUtil.format(DateUtil.parse(item, DateConstant.PATTERN_DATE), "yyyyMMdd"));
|
}).collect(Collectors.toList()));
|
}
|
}
|
return data;
|
}
|
|
private Function<SuperAggregateState, String> groupKey(StatisticalMethodEnum statisticalMethodEnum) {
|
switch (statisticalMethodEnum) {
|
case DAY:
|
return superAggregateState -> {
|
return DateCycleUtil.getDateCycle(statisticalMethodEnum, String.valueOf(superAggregateState.getFactoryDate()));
|
};
|
case WEEK:
|
return superAggregateState2 -> {
|
return DateCycleUtil.getDateCycle(statisticalMethodEnum, String.valueOf(superAggregateState2.getFactoryWeek()));
|
};
|
case MONTH:
|
return superAggregateState3 -> {
|
return DateCycleUtil.getDateCycle(statisticalMethodEnum, String.valueOf(superAggregateState3.getFactoryMonth()));
|
};
|
default:
|
return superAggregateState4 -> {
|
return DateCycleUtil.getDateCycle(statisticalMethodEnum, String.valueOf(superAggregateState4.getWorkstationId()));
|
};
|
}
|
}
|
|
private String toPercent(Double value) {
|
return NumberUtil.decimalFormat("#.##%", value.doubleValue());
|
}
|
|
private List<SuperAggregateState> getStatusDataByFactoryDate(List<Long> workstationIds, String startDate, String endDate) {
|
List<String> itemTableNames = this.commonMapper.getItemBySuperTable(TABLE_NAME, workstationIds);
|
List<SuperAggregateState> superAggregateStates = new ArrayList<>();
|
for (Long id : workstationIds) {
|
if (itemTableNames.contains("aggregate_state_" + id)) {
|
List<SuperAggregateState> statusDataByFactoryDateAndWorkstationId = this.superAggregateStateMapper.getStatusDataByFactoryDateAndWorkstationId(id, startDate, endDate);
|
superAggregateStates.addAll(statusDataByFactoryDateAndWorkstationId);
|
}
|
}
|
Date now = com.qianwen.core.tool.utils.DateUtil.now();
|
superAggregateStates.forEach(x -> {
|
if (Func.isEmpty(x.getEndTime())) {
|
x.setEndTime(new Timestamp(now.getTime()));
|
}
|
x.setDurationCollect(Long.valueOf(LocalDateTimeUtils.betweenTwoTime(x.getStartTime().toLocalDateTime(), LocalDateTimeUtils.DateToLocalDateTime(x.getEndTime()), ChronoUnit.MILLIS)));
|
});
|
return superAggregateStates.stream().filter(x2 -> {
|
return x2.getRps().intValue() > 0;
|
}).collect(Collectors.toList());
|
}
|
}
|
