package com.qianwen.smartman.modules.mdc.service.impl;
|
|
import java.math.BigDecimal;
|
import java.time.DayOfWeek;
|
import java.time.LocalDate;
|
import java.time.temporal.WeekFields;
|
import java.util.ArrayList;
|
import java.util.Collection;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.stream.Collectors;
|
|
import javax.servlet.http.HttpServletResponse;
|
|
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.MdcConstant;
|
import com.qianwen.smartman.common.utils.LocalDateTimeUtils;
|
import com.qianwen.smartman.common.utils.LocalDateUtil;
|
import com.qianwen.smartman.common.utils.MessageUtils;
|
import com.qianwen.smartman.modules.smis.convert.WorkstationConvert;
|
import com.qianwen.smartman.modules.smis.dto.ShiftInfoDTO;
|
import com.qianwen.smartman.modules.smis.entity.Workstation;
|
import com.qianwen.smartman.modules.smis.enums.WorkstationTypeEnum;
|
import com.qianwen.smartman.modules.smis.mapper.WorkstationMapper;
|
import com.qianwen.smartman.modules.smis.service.IShiftDetailService;
|
import com.qianwen.smartman.modules.smis.service.IWorkstationService;
|
import com.qianwen.smartman.modules.smis.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.SuperAggregateState;
|
import com.qianwen.smartman.modules.mdc.enums.ProductivityTypeEnum;
|
import com.qianwen.smartman.modules.mdc.enums.StatisticalMethodEnum;
|
import com.qianwen.smartman.modules.mdc.excel.EfficiencyAnalysisExport;
|
import com.qianwen.smartman.modules.mdc.service.IEfficiencyAnalysisService;
|
import com.qianwen.smartman.modules.mdc.service.IStatisticsService;
|
import com.qianwen.smartman.modules.mdc.service.ISuperAggregateStateService;
|
import com.qianwen.smartman.modules.mdc.utils.EifficiencyUtils;
|
import com.qianwen.smartman.modules.mdc.utils.ExcelStrategyUtil;
|
import com.qianwen.smartman.modules.mdc.vo.AnalysisFilterVO;
|
import com.qianwen.smartman.modules.mdc.vo.ColumnInfoVO;
|
import com.qianwen.smartman.modules.mdc.vo.QueryIntervalDateVO;
|
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
|
public class EfficiencyAnalysisServiceImpl implements IEfficiencyAnalysisService {
|
private static final Logger log = LoggerFactory.getLogger(EfficiencyAnalysisServiceImpl.class);
|
private static final String ZERO = "0.00%";
|
private final ISuperAggregateStateService superAggregateStateService;
|
private final IWorkstationService workstationService;
|
private final StatisticsWrapper wrapper;
|
private final WorkstationMapper workstationMapper;
|
private final OssBuilder ossBuilder;
|
private final IShiftDetailService shiftDetailService;
|
private final IStatisticsService statisticsService;
|
private final Integer SHIFT1 = 1;
|
private final Integer SHIFT2 = 2;
|
private final Integer SHIFT3 = 3;
|
private final Integer SHIFT4 = 4;
|
|
public EfficiencyAnalysisServiceImpl(final ISuperAggregateStateService superAggregateStateService, final IWorkstationService workstationService, final StatisticsWrapper wrapper, final WorkstationMapper workstationMapper, final OssBuilder ossBuilder, final IShiftDetailService shiftDetailService, final IStatisticsService statisticsService) {
|
this.superAggregateStateService = superAggregateStateService;
|
this.workstationService = workstationService;
|
this.wrapper = wrapper;
|
this.workstationMapper = workstationMapper;
|
this.ossBuilder = ossBuilder;
|
this.shiftDetailService = shiftDetailService;
|
this.statisticsService = statisticsService;
|
}
|
|
@Override
|
public StatisticsVO efficiencyAnalysis(StatisticsAnalysisQueryVO statisticsAnalysisQueryVO, Query query) {
|
List<SuperAggregateState> superAggregateStates;
|
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());
|
}
|
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(Workstation::getId).collect(Collectors.toList());
|
List<IntervalDateDto> intervalDates = LocalDateTimeUtils.getIntervalDate(statisticsAnalysisQueryVO.getStartDate(), statisticsAnalysisQueryVO.getEndDate());
|
|
//都是用采集的数据（getStatusData），不用反馈的。计划内外所有状态都能设置。
|
if (statisticsAnalysisQueryVO.getProductivityType() == ProductivityTypeEnum.OEE) {
|
//superAggregateStates = this.superAggregateStateService.getStatusDataWithFeedback(workstationIds, statisticsAnalysisQueryVO.getStatisticalMethod(), statisticsAnalysisQueryVO.getStartDate(), statisticsAnalysisQueryVO.getEndDate());
|
} else {
|
//superAggregateStates = this.superAggregateStateService.getStatusData(workstationIds, statisticsAnalysisQueryVO.getStatisticalMethod(), statisticsAnalysisQueryVO.getStartDate(), statisticsAnalysisQueryVO.getEndDate());
|
}
|
superAggregateStates = this.superAggregateStateService.getStatusData(workstationIds, statisticsAnalysisQueryVO.getStatisticalMethod(), statisticsAnalysisQueryVO.getStartDate(), statisticsAnalysisQueryVO.getEndDate());
|
List<SuperAggregate> superAggregateList = superAggregateStates.stream().filter(x -> {
|
return x.getWcs() > 0;
|
}).collect(Collectors.toList());
|
StatisticsWrapperDto statisticsWrapperDto = new StatisticsWrapperDto(superAggregateList, statisticsAnalysisQueryVO, intervalDates, workstationPage, MdcConstant.STATE);
|
return this.wrapper.entityVO(statisticsWrapperDto);
|
}
|
|
@Override
|
public List<ColumnInfoVO> getIntervalDate(QueryIntervalDateVO queryIntervalDateVO) {
|
List<IntervalDateDto> intervalDate = LocalDateTimeUtils.getIntervalDate(queryIntervalDateVO.getStartDate(), queryIntervalDateVO.getEndDate());
|
List<ColumnInfoVO> columnInfoVOList = new ArrayList<>();
|
String theMessage = MessageUtils.message("mdc.efficiency.analysis.the", new Object[0]);
|
String weekMessage = MessageUtils.message("mdc.efficiency.analysis.week", new Object[0]);
|
switch (queryIntervalDateVO.getStatisticalMethod()) {
|
case MONTH:
|
intervalDate.forEach(intervalDateDto -> {
|
intervalDateDto.getMonthList().forEach(month -> {
|
ColumnInfoVO columnInfoVO = new ColumnInfoVO();
|
columnInfoVO.setId(intervalDateDto.getYear() + "-" + month);
|
columnInfoVO.setTitle(intervalDateDto.getYear() + "-" + month);
|
columnInfoVOList.add(columnInfoVO);
|
});
|
});
|
break;
|
case WEEK:
|
WeekFields weekFields = WeekFields.of(DayOfWeek.MONDAY, 1);
|
intervalDate.forEach(intervalDateDto2 -> {
|
intervalDateDto2.getWeekList().forEach(week -> {
|
ColumnInfoVO columnInfoVO = new ColumnInfoVO();
|
columnInfoVO.setId(intervalDateDto2.getYear() + "-" + week);
|
columnInfoVO.setTitle(intervalDateDto2.getYear() + "-" + theMessage + week + weekMessage);
|
LocalDate localDate = LocalDate.now().withYear(intervalDateDto2.getYear().intValue()).with(weekFields.weekOfYear(), week.intValue());
|
columnInfoVO.setStartDate(localDate.with(weekFields.dayOfWeek(), 1L));
|
columnInfoVO.setEndDate(localDate.with(weekFields.dayOfWeek(), 7L));
|
if (columnInfoVO.getEndDate().getYear() != columnInfoVO.getStartDate().getYear()) {
|
if (week.equals(CommonConstant.ONE)) {
|
columnInfoVO.setStartDate(LocalDateUtil.dateToLocalDate(LocalDateTimeUtils.getFirstDayDateOfYear(LocalDateUtil.localToDate(columnInfoVO.getEndDate()))));
|
} else {
|
columnInfoVO.setEndDate(LocalDateUtil.dateToLocalDate(LocalDateTimeUtils.getLastDayOfYear(LocalDateUtil.localToDate(columnInfoVO.getStartDate()))));
|
}
|
}
|
columnInfoVOList.add(columnInfoVO);
|
});
|
});
|
break;
|
default:
|
intervalDate.get(0).getDayList().forEach(day -> {
|
ColumnInfoVO columnInfoVO = new ColumnInfoVO();
|
columnInfoVO.setId(day);
|
columnInfoVO.setTitle(day);
|
columnInfoVOList.add(columnInfoVO);
|
});
|
break;
|
}
|
return columnInfoVOList;
|
}
|
|
@Override
|
public BladeFile exportEfficiencyAnalysis(StatisticsAnalysisQueryVO statisticsAnalysisQueryVO, HttpServletResponse response) {
|
List<SuperAggregateState> superAggregateStates;
|
List<String> workStationIdList = statisticsAnalysisQueryVO.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(statisticsAnalysisQueryVO.getStatisticalMethod(), statisticsAnalysisQueryVO.getProductivityType());
|
}
|
List<IntervalDateDto> intervalDates = LocalDateTimeUtils.getIntervalDate(statisticsAnalysisQueryVO.getStartDate(), statisticsAnalysisQueryVO.getEndDate());
|
if (statisticsAnalysisQueryVO.getProductivityType() == ProductivityTypeEnum.OEE) {
|
superAggregateStates = this.superAggregateStateService.getStatusDataWithFeedback(workstationIds, statisticsAnalysisQueryVO.getStatisticalMethod(), statisticsAnalysisQueryVO.getStartDate(), statisticsAnalysisQueryVO.getEndDate());
|
} else {
|
superAggregateStates = this.superAggregateStateService.getStatusData(workstationIds, statisticsAnalysisQueryVO.getStatisticalMethod(), statisticsAnalysisQueryVO.getStartDate(), statisticsAnalysisQueryVO.getEndDate());
|
}
|
List<SuperAggregateState> superAggregateStates2 = superAggregateStates.stream().filter(x -> {
|
return x.getWcs().intValue() > 0;
|
}).collect(Collectors.toList());
|
List<WorkstationVO> workstationVOList = this.workstationMapper.queryWorkstationAndGroup(Condition.getPage(new Query().setSize(-1)), workstationIds).getRecords();
|
if (StatisticalMethodEnum.SHIFT.equals(statisticsAnalysisQueryVO.getStatisticalMethod())) {
|
List<ShiftInfoDTO> shiftInfoDtoList = this.shiftDetailService.getShiftInfoDtoList(workstationIds, statisticsAnalysisQueryVO.getStartDate(), statisticsAnalysisQueryVO.getEndDate());
|
Map<String, String> shiftInfoMap = shiftInfoDtoList.stream().collect(Collectors.toMap(s2 -> {
|
return s2.getDate() + "-" + s2.getWorkstationId() + "-" + s2.getShiftIndex();
|
}, (v0) -> {
|
return v0.getIndexName();
|
}));
|
return exportShift(intervalDates, superAggregateStates2, workstationVOList, statisticsAnalysisQueryVO.getShiftIndexList(), statisticsAnalysisQueryVO.getProductivityType(), shiftInfoMap);
|
}
|
return export(superAggregateStates2, workstationVOList, statisticsAnalysisQueryVO);
|
}
|
|
private BladeFile exportEmpty(StatisticalMethodEnum statisticalMethod, ProductivityTypeEnum productivityTypeEnum) {
|
String name = getName(productivityTypeEnum);
|
if (StatisticalMethodEnum.SHIFT.equals(statisticalMethod)) {
|
List<EfficiencyAnalysisExport> efficiencyAnalysisExportList = new ArrayList<>();
|
String fileName = String.format("%s-%s.xlsx", name, DateUtil.time());
|
MultipartFile multipartFile = ExcelUtil.exportToMultipartFile(fileName, name, efficiencyAnalysisExportList, EfficiencyAnalysisExport.class);
|
return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
|
}
|
List<List<String>> head = new ArrayList<>();
|
List<List<Object>> data = new ArrayList<>();
|
String fileName2 = String.format("%s-%s.xlsx", name, DateUtil.time());
|
MultipartFile multipartFile2;
|
try {
|
multipartFile2 = ExcelStrategyUtil.customerExport(fileName2, name, head, data);
|
return this.ossBuilder.tempTemplate().putFile(multipartFile2.getOriginalFilename(), multipartFile2);
|
} catch (Exception e) {
|
log.error("导出错误",e);
|
e.printStackTrace();
|
throw new RuntimeException(e);
|
}
|
|
}
|
|
private BladeFile export(List<SuperAggregateState> superAggregateList, List<WorkstationVO> workstationVOList, StatisticsAnalysisQueryVO statisticsAnalysisQueryVO) {
|
List<List<String>> head = new ArrayList<>();
|
List<List<Object>> data = 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();
|
buildHead(head, items, statisticalMethod);
|
buildData(data, workstationVOList, statisticsAnalysisQueryVO, items, superAggregateList);
|
String name = getName(statisticsAnalysisQueryVO.getProductivityType());
|
String fileName = String.format("%s-%s.xlsx", name, DateUtil.time());
|
try {
|
MultipartFile multipartFile = ExcelStrategyUtil.customerExport(fileName, name, head, data);
|
return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
|
} catch (Exception e) {
|
log.error("导出错误",e);
|
e.printStackTrace();
|
throw new RuntimeException(e);
|
}
|
}
|
|
private void buildData(List<List<Object>> data, List<WorkstationVO> workstationVOList, StatisticsAnalysisQueryVO statisticsAnalysisQueryVO, Collection<SplitFilterVO> items, List<SuperAggregateState> superAggregateList) {
|
workstationVOList.forEach(workstationVO -> {
|
//List<Long> keyList;
|
//Map<Long, List<SuperAggregateState>> map;
|
ArrayList<Object> arrayList = new ArrayList<>();
|
arrayList.add(workstationVO.getGroupName());
|
arrayList.add(workstationVO.getCode());
|
arrayList.add(workstationVO.getName());
|
|
List<Long> keyList = new ArrayList<>();
|
Map<Long, List<SuperAggregateState>> map = new HashMap<>();
|
/*new ArrayList();
|
new HashMap();*/
|
Long workstationId = workstationVO.getId();
|
switch (statisticsAnalysisQueryVO.getStatisticalMethod()) {
|
case WEEK:
|
keyList = items.stream().map(s -> {
|
return Long.valueOf(workstationId.longValue() + s.getYear().intValue() + s.getWeek().intValue());
|
}).collect(Collectors.toList());
|
map = superAggregateList.stream().collect(Collectors.groupingBy(s2 -> {
|
return Long.valueOf(s2.getWorkstationId().longValue() + s2.getFactoryYear().intValue() + s2.getFactoryWeek().intValue());
|
}));
|
break;
|
case DAY:
|
keyList = items.stream().map(s3 -> {
|
return Long.valueOf(workstationId.longValue() + Integer.parseInt(s3.getDate().replace("-", "")));
|
}).collect(Collectors.toList());
|
map = superAggregateList.stream().collect(Collectors.groupingBy(s4 -> {
|
return Long.valueOf(s4.getWorkstationId().longValue() + s4.getFactoryDate().intValue());
|
}));
|
break;
|
default:
|
keyList = items.stream().map(s5 -> {
|
return Long.valueOf(workstationId.longValue() + s5.getYear().intValue() + s5.getMonth().intValue());
|
}).collect(Collectors.toList());
|
map = superAggregateList.stream().collect(Collectors.groupingBy(s6 -> {
|
return Long.valueOf(s6.getWorkstationId().longValue() + s6.getFactoryYear().intValue() + s6.getFactoryMonth().intValue());
|
}));
|
break;
|
}
|
Map<Long, List<SuperAggregateState>> finalMap = map;
|
keyList.forEach(key -> {
|
List<SuperAggregateState> superAggregateStates = finalMap.get(key);
|
if (Func.isEmpty(superAggregateStates)) {
|
arrayList.add(ZERO);
|
return;
|
}
|
Double value = EifficiencyUtils.calculationResults(superAggregateStates, statisticsAnalysisQueryVO.getProductivityType());
|
double v = BigDecimal.valueOf(value.doubleValue()).multiply(BigDecimal.valueOf(100L)).doubleValue();
|
arrayList.add(v + "%");
|
});
|
data.add(arrayList);
|
});
|
}
|
|
private void buildHead(List<List<String>> head, Collection<SplitFilterVO> items, StatisticalMethodEnum statisticalMethodEnum) {
|
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 (statisticalMethodEnum) {
|
case WEEK:
|
head.add(Lists.newArrayList(new String[]{StrUtil.format("{}-{}{}{}", new Object[]{splitFilterVO.getYear(), the, splitFilterVO.getWeek(), week})}));
|
return;
|
case DAY:
|
head.add(Lists.newArrayList(new String[]{splitFilterVO.getDate()}));
|
return;
|
default:
|
head.add(Lists.newArrayList(new String[]{splitFilterVO.getTitle()}));
|
return;
|
}
|
});
|
}
|
|
public BladeFile exportShift(List<IntervalDateDto> intervalDates, List<SuperAggregateState> superAggregateList, List<WorkstationVO> workstationVOList, List<Integer> shiftIndexList, ProductivityTypeEnum productivityTypeEnum, Map<String, String> shiftInfoMap) {
|
String message = MessageUtils.message("mdc.not.schedule", new Object[0]);
|
Map<String, List<SuperAggregateState>> map = superAggregateList.stream().collect(Collectors.groupingBy(s -> {
|
return s.getFactoryDate() + "-" + s.getWorkstationId() + "-" + s.getShiftIndex();
|
}));
|
List<EfficiencyAnalysisExport> efficiencyAnalysisExportList = new ArrayList<>();
|
IntervalDateDto intervalDateDto = intervalDates.get(0);
|
intervalDateDto.getDayList().forEach(dateString -> {
|
workstationVOList.forEach(w -> {
|
EfficiencyAnalysisExport efficiencyAnalysisExport = new EfficiencyAnalysisExport();
|
efficiencyAnalysisExport.setDate(dateString).setGroupName(w.getGroupName()).setWorkstationCode(w.getCode()).setWorkstationName(w.getName());
|
shiftIndexList.forEach(index -> {
|
String stringDateKey = StrUtil.format("{}-{}-{}", new Object[]{dateString, w.getId(), index});
|
String intDateKey = StrUtil.format("{}-{}-{}", new Object[]{dateString.replace("-", ""), w.getId(), index});
|
String shiftName = (String) shiftInfoMap.get(stringDateKey);
|
if (Func.isEmpty(shiftName)) {
|
buildEmptyData(index, efficiencyAnalysisExport, message);
|
return;
|
}
|
List<SuperAggregateState> superAggregateStates = (List) map.get(intDateKey);
|
if (Func.isEmpty(superAggregateStates)) {
|
buildData(index, efficiencyAnalysisExport, shiftName, ZERO);
|
return;
|
}
|
Double value = EifficiencyUtils.calculationResults(superAggregateStates, productivityTypeEnum);
|
String efficiency = BigDecimal.valueOf(value.doubleValue()).multiply(BigDecimal.valueOf(100L)).doubleValue() + "%";
|
buildData(index, efficiencyAnalysisExport, shiftName, efficiency);
|
});
|
efficiencyAnalysisExportList.add(efficiencyAnalysisExport);
|
});
|
});
|
String name = getName(productivityTypeEnum);
|
String fileName = String.format("%s-%s.xlsx", name, DateUtil.time());
|
MultipartFile multipartFile = ExcelUtil.exportToMultipartFile(fileName, name, efficiencyAnalysisExportList, EfficiencyAnalysisExport.class);
|
return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
|
}
|
|
private String getName(ProductivityTypeEnum productivityTypeEnum) {
|
String name;
|
switch (productivityTypeEnum) {
|
case RUNNING:
|
name = ProductivityTypeEnum.RUNNING.getMessage();
|
break;
|
case ALARM:
|
name = ProductivityTypeEnum.ALARM.getMessage();
|
break;
|
default:
|
name = ProductivityTypeEnum.OEE.getMessage();
|
break;
|
}
|
return name;
|
}
|
|
public void buildEmptyData(Integer shiftIndex, EfficiencyAnalysisExport efficiencyAnalysisExport, String message) {
|
if (this.SHIFT1.equals(shiftIndex)) {
|
efficiencyAnalysisExport.setShift1(message);
|
efficiencyAnalysisExport.setEfficiency1("-");
|
} else if (this.SHIFT2.equals(shiftIndex)) {
|
efficiencyAnalysisExport.setShift2(message);
|
efficiencyAnalysisExport.setEfficiency2("-");
|
} else if (this.SHIFT3.equals(shiftIndex)) {
|
efficiencyAnalysisExport.setShift3(message);
|
efficiencyAnalysisExport.setEfficiency3("-");
|
} else {
|
efficiencyAnalysisExport.setShift4(message);
|
efficiencyAnalysisExport.setEfficiency4("-");
|
}
|
}
|
|
public void buildData(Integer shiftIndex, EfficiencyAnalysisExport efficiencyAnalysisExport, String shiftName, String value) {
|
if (this.SHIFT1.equals(shiftIndex)) {
|
efficiencyAnalysisExport.setShift1(shiftName);
|
efficiencyAnalysisExport.setEfficiency1(value);
|
} else if (this.SHIFT2.equals(shiftIndex)) {
|
efficiencyAnalysisExport.setShift2(shiftName);
|
efficiencyAnalysisExport.setEfficiency2(value);
|
} else if (this.SHIFT3.equals(shiftIndex)) {
|
efficiencyAnalysisExport.setShift3(shiftName);
|
efficiencyAnalysisExport.setEfficiency3(value);
|
} else {
|
efficiencyAnalysisExport.setShift4(shiftName);
|
efficiencyAnalysisExport.setEfficiency4(value);
|
}
|
}
|
}
|
