package com.mes.bigstorage.service.impl;
|
|
import cn.hutool.core.lang.Assert;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
|
import com.github.yulichang.base.MPJBaseServiceImpl;
|
import com.github.yulichang.toolkit.JoinWrappers;
|
import com.github.yulichang.wrapper.MPJLambdaWrapper;
|
import com.mes.base.entity.BigStorageCageBaseInfo;
|
import com.mes.bigstorage.entity.BigStorageCage;
|
import com.mes.bigstorage.entity.BigStorageCageDetails;
|
import com.mes.bigstorage.entity.BigStorageDTO;
|
import com.mes.bigstorage.entity.dto.FlowCardDTO;
|
import com.mes.bigstorage.entity.dto.SlotSequenceDTO;
|
import com.mes.bigstorage.entity.dto.TemperingLayoutDTO;
|
import com.mes.bigstorage.mapper.BigStorageCageDetailsMapper;
|
import com.mes.bigstorage.service.BigStorageCageDetailsService;
|
import com.mes.bigstorage.service.BigStorageCageService;
|
import com.mes.bigstoragetask.entity.BigStorageCageFeedTask;
|
import com.mes.bigstoragetask.entity.BigStorageCageOutTask;
|
import com.mes.bigstoragetask.entity.UpdateBigStorageCageDTO;
|
import com.mes.bigstoragetask.mapper.BigStorageCageFeedTaskMapper;
|
import com.mes.bigstoragetask.mapper.BigStorageCageOutTaskMapper;
|
import com.mes.bigstoragetask.service.BigStorageCageOutTaskService;
|
import com.mes.common.config.Const;
|
import com.mes.damage.entity.Damage;
|
import com.mes.damage.service.DamageService;
|
import com.mes.glassinfo.entity.GlassInfo;
|
import com.mes.glassinfo.mapper.GlassInfoMapper;
|
import com.mes.glassinfo.service.GlassInfoService;
|
import com.mes.job.PlcStorageCageTask;
|
import com.mes.temperingglass.entity.TemperingGlassInfo;
|
import com.mes.temperingglass.mapper.TemperingGlassInfoMapper;
|
import com.mes.temperingglass.service.TemperingGlassInfoService;
|
import com.mes.utils.RedisUtil;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
|
import javax.annotation.Resource;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* <p>
|
* 服务实现类
|
* </p>
|
*
|
* @author zhoush
|
* @since 2024-03-27
|
*/
|
@Slf4j
|
@Service
|
public class BigStorageCageDetailsServiceImpl extends MPJBaseServiceImpl<BigStorageCageDetailsMapper, BigStorageCageDetails> implements BigStorageCageDetailsService {
|
|
@Resource
|
private BigStorageCageOutTaskMapper bigStorageCageOutTaskMapper;
|
@Resource
|
private BigStorageCageFeedTaskMapper bigStorageCageFeedTaskMapper;
|
@Resource
|
private TemperingGlassInfoMapper temperingGlassInfoMapper;
|
@Resource
|
private BigStorageCageService bigStorageCageService;
|
@Resource
|
private GlassInfoMapper glassInfoMapper;
|
|
@Resource
|
private GlassInfoService glassInfoService;
|
|
@Resource
|
private TemperingGlassInfoService temperingGlassInfoService;
|
|
@Resource
|
private PlcStorageCageTask plcStorageCageTask;
|
|
@Resource
|
private DamageService damageService;
|
@Resource
|
private RedisUtil redisUtil;
|
@Resource
|
private BigStorageCageOutTaskService bigStorageCageOutTaskService;
|
@Resource
|
private BigStorageCageDetailsService bigStorageCageDetailsService;
|
|
@Value("${mes.minCount}")
|
private int minCount;
|
|
@Value("${mes.slotWidth}")
|
private Integer slotWidth;
|
|
@Value("${mes.glassGap}")
|
private Integer glassGap;
|
|
@Value("${mes.sequence.order}")
|
private boolean sequenceOrder;
|
|
|
@Override
|
public List<BigStorageCageDetails> selectFeedTask() {
|
//进片任务数据
|
LambdaQueryWrapper<BigStorageCageDetails> feedWrapper = new LambdaQueryWrapper<>();
|
feedWrapper.eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW);
|
List<BigStorageCageDetails> bigStorageCageDetailsList = baseMapper.selectList(feedWrapper);
|
|
LambdaQueryWrapper<BigStorageCageFeedTask> feedTaskWrapper = new LambdaQueryWrapper<>();
|
feedTaskWrapper
|
.lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
|
.isNotNull(BigStorageCageFeedTask::getTargetSlot);
|
List<BigStorageCageFeedTask> bigStorageCageFeedTaskList = bigStorageCageFeedTaskMapper.selectList(feedTaskWrapper);
|
|
List<String> glassIds = bigStorageCageDetailsList.stream().map(BigStorageCageDetails::getGlassId).collect(Collectors.toList());
|
List<BigStorageCageFeedTask> feedTasks = bigStorageCageFeedTaskList.stream()
|
.filter(task -> !glassIds.contains(task.getGlassId()))
|
.collect(Collectors.toList());
|
|
|
Map<String, BigStorageCageFeedTask> listMap = bigStorageCageFeedTaskList.stream()
|
.collect(Collectors.toMap(BigStorageCageFeedTask::getGlassId, task -> task));
|
Iterator<BigStorageCageDetails> iterator = bigStorageCageDetailsList.iterator();
|
while (iterator.hasNext()) {
|
BigStorageCageDetails bigStorageCageDetails = iterator.next();
|
BigStorageCageFeedTask bigStorageCageFeedTask = listMap.get(bigStorageCageDetails.getGlassId());
|
bigStorageCageDetails.setBigStorageCageFeedTask(bigStorageCageFeedTask);
|
}
|
for (BigStorageCageFeedTask bigStorageCageFeedTask : feedTasks
|
) {
|
BigStorageCageDetails bigStorageCageDetails = new BigStorageCageDetails();
|
bigStorageCageDetails.setBigStorageCageFeedTask(bigStorageCageFeedTask);
|
bigStorageCageDetailsList.add(bigStorageCageDetails);
|
}
|
bigStorageCageDetailsList.sort(Comparator
|
.comparing((BigStorageCageDetails detail) -> detail.getBigStorageCageFeedTask().getId()));
|
return bigStorageCageDetailsList;
|
}
|
|
@Override
|
public List<BigStorageCageDetails> selectOutTask() {
|
LambdaQueryWrapper<BigStorageCageDetails> outWrapper = new LambdaQueryWrapper<>();
|
outWrapper.in(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING, Const.GLASS_STATE_SCHEDULE_ING);
|
List<BigStorageCageDetails> bigStorageCageDetailsList = baseMapper.selectList(outWrapper);
|
LambdaQueryWrapper<BigStorageCageOutTask> outTaskWrapper = new LambdaQueryWrapper<>();
|
outTaskWrapper.lt(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_SUCCESS)
|
.orderByAsc(BigStorageCageOutTask::getId);
|
List<BigStorageCageOutTask> bigStorageCageOutTaskList = bigStorageCageOutTaskMapper.selectList(outTaskWrapper);
|
|
Map<String, BigStorageCageOutTask> listMap = bigStorageCageOutTaskList.stream()
|
.collect(Collectors.toMap(BigStorageCageOutTask::getGlassId, task -> task));
|
for (BigStorageCageDetails bigStorageCageDetails : bigStorageCageDetailsList) {
|
BigStorageCageOutTask bigStorageCageOutTask = listMap.get(bigStorageCageDetails.getGlassId());
|
bigStorageCageDetails.setBigStorageCageOutTask(bigStorageCageOutTask);
|
}
|
Iterator<BigStorageCageDetails> iterator = bigStorageCageDetailsList.iterator();
|
while (iterator.hasNext()) {
|
BigStorageCageDetails bigStorageCageDetails = iterator.next();
|
BigStorageCageOutTask bigStorageCageOutTask = listMap.get(bigStorageCageDetails.getGlassId());
|
bigStorageCageDetails.setBigStorageCageOutTask(bigStorageCageOutTask);
|
}
|
bigStorageCageDetailsList.sort(Comparator
|
.comparing((BigStorageCageDetails detail) -> detail.getBigStorageCageOutTask().getTrainNumber())
|
.thenComparingInt((BigStorageCageDetails detail) -> detail.getBigStorageCageOutTask().getSerialNumber()));
|
|
return bigStorageCageDetailsList;
|
}
|
|
|
/**
|
* 判断当前玻璃是否能上车
|
*/
|
@Override
|
public double selectGetBoard(String plcFeedReqLine) {
|
double carWidth = 5000;
|
LambdaQueryWrapper<BigStorageCageDetails> feedWrapper = new LambdaQueryWrapper<>();
|
feedWrapper.eq(BigStorageCageDetails::getState, plcFeedReqLine);
|
List<BigStorageCageDetails> bigStorageCageDetailsList = baseMapper.selectList(feedWrapper);
|
|
LambdaQueryWrapper<BigStorageCageFeedTask> bigStorageCageFeedTaskWrapper = new LambdaQueryWrapper<>();
|
bigStorageCageFeedTaskWrapper
|
.eq(BigStorageCageFeedTask::getTaskState, plcFeedReqLine)
|
.eq(BigStorageCageFeedTask::getLine, plcFeedReqLine);
|
|
List<BigStorageCageFeedTask> bigStorageCageFeedTaskList = bigStorageCageFeedTaskMapper.selectList(bigStorageCageFeedTaskWrapper);
|
Map<String, BigStorageCageFeedTask> listMap = bigStorageCageFeedTaskList.stream()
|
.collect(Collectors.toMap(BigStorageCageFeedTask::getGlassId, task -> task));
|
for (BigStorageCageDetails bigStorageCageDetails : bigStorageCageDetailsList) {
|
BigStorageCageFeedTask bigStorageCageFeedTask = listMap.get(bigStorageCageDetails.getGlassId());
|
bigStorageCageDetails.setBigStorageCageFeedTask(bigStorageCageFeedTask);
|
}
|
for (BigStorageCageDetails bigStorageCageDetails : bigStorageCageDetailsList
|
) {
|
if (bigStorageCageDetails.getBigStorageCageFeedTask().getTaskState() == 0) {
|
carWidth = carWidth - bigStorageCageDetails.getWidth() - glassGap;
|
}
|
}
|
return carWidth;
|
|
}
|
|
|
//栓除出片任务.更新格子宽度
|
@Override
|
public void deleteBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails) {
|
baseMapper.deleteById(bigStorageCageDetails.getId());
|
bigStorageCageService.updateRemainWidth(bigStorageCageDetails.getSlot());
|
}
|
|
//理片笼详情破损
|
@Override
|
public void damageBigStorageCageDetails(String glassId, int status) {
|
|
LambdaQueryWrapper<TemperingGlassInfo> temperingGlassInfoWrapper = new LambdaQueryWrapper<>();
|
temperingGlassInfoWrapper.eq(TemperingGlassInfo::getGlassId, glassId);
|
TemperingGlassInfo temperingGlassInfo = temperingGlassInfoMapper.selectOne(temperingGlassInfoWrapper);
|
|
LambdaQueryWrapper<BigStorageCageDetails> bigStorageCageDetailsWrapper = new LambdaQueryWrapper<>();
|
bigStorageCageDetailsWrapper
|
.eq(BigStorageCageDetails::getGlassId, glassId)
|
.eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN);
|
BigStorageCageDetails bigStorageCageDetails = baseMapper.selectOne(bigStorageCageDetailsWrapper);
|
|
if (temperingGlassInfo != null) {
|
if (status == 8) {
|
temperingGlassInfo.setState(Const.GLASS_STATE_DAMAGE);
|
} else {
|
temperingGlassInfo.setState(Const.GLASS_STATE_TAKE);
|
}
|
temperingGlassInfoMapper.deleteById(temperingGlassInfo);
|
}
|
Damage damage = new Damage();
|
if (status == 8) {
|
bigStorageCageDetails.setState(Const.GLASS_STATE_DAMAGE);
|
damage.setType(Const.GLASS_STATE_DAMAGE);
|
} else {
|
bigStorageCageDetails.setState(Const.GLASS_STATE_TAKE);
|
damage.setType(Const.GLASS_STATE_TAKE);
|
}
|
baseMapper.updateById(bigStorageCageDetails);
|
bigStorageCageService.updateRemainWidth(bigStorageCageDetails.getSlot());
|
damage.setGlassId(bigStorageCageDetails.getGlassId());
|
damage.setWorkingProcedure("钢化");
|
damage.setLine(4001);
|
damage.setRemark("大理片笼");
|
damage.setStatus(1);
|
damageService.insertDamage(damage);
|
}
|
|
//查询玻璃信息
|
@Override
|
public List<BigStorageCageDetails> selectBigStorageCageDetails(String glassId) {
|
LambdaQueryWrapper<GlassInfo> glassInfoWrapper = new LambdaQueryWrapper<>();
|
List<BigStorageCageDetails> bigStorageCageDetailsList = new ArrayList<>();
|
glassInfoWrapper.eq(GlassInfo::getGlassId, glassId);
|
GlassInfo glassInfo = glassInfoMapper.selectOne(glassInfoWrapper);
|
BigStorageCageDetails bigStorageCageDetails = new BigStorageCageDetails();
|
if (glassInfo != null) {
|
BeanUtils.copyProperties(glassInfo, bigStorageCageDetails);
|
bigStorageCageDetails.setState(1);
|
bigStorageCageDetails.setGap(glassGap);
|
bigStorageCageDetailsList = new ArrayList<>();
|
bigStorageCageDetailsList.add(bigStorageCageDetails);
|
}
|
return bigStorageCageDetailsList;
|
}
|
|
//理片笼详情添加
|
@Override
|
public void insertBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails) {
|
bigStorageCageDetails.setState(100);
|
baseMapper.insert(bigStorageCageDetails);
|
bigStorageCageService.updateRemainWidth(bigStorageCageDetails.getSlot());
|
}
|
|
//理片笼详情完成
|
@Override
|
public void finishBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails) {
|
// if (bigStorageCageDetails.getBigStorageCageFeedTask() != null) {
|
// bigStorageCageDetails.setState(Const.BIG_STORAGE_INSIDE);
|
// baseMapper.updateById(bigStorageCageDetails);
|
// } else {
|
// bigStorageCageDetails.setState(Const.BIG_STORAGE_OUTSIDE);
|
// baseMapper.updateById(bigStorageCageDetails);
|
// bigStorageCageService.updateRemainWidth(bigStorageCageDetails.getSlot());
|
// }
|
}
|
|
//手动出片
|
@Override
|
public void outBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails) {
|
bigStorageCageDetails.setState(Const.GLASS_STATE_ARTIFICIAL);
|
baseMapper.updateById(bigStorageCageDetails);
|
}
|
|
@Override
|
public BigStorageDTO queryTargetSlotByTempering(GlassInfo glassInfo) {
|
List<GlassInfo> glassInfoList = glassInfoService.list(
|
new LambdaQueryWrapper<GlassInfo>()
|
.eq(GlassInfo::getEngineerId, glassInfo.getEngineerId())
|
.eq(GlassInfo::getTemperingLayoutId, glassInfo.getTemperingLayoutId())
|
.eq(GlassInfo::getTargetSlot, glassInfo.getTargetSlot())
|
);
|
List<String> glassIds = glassInfoList.stream().map(GlassInfo::getGlassId).collect(Collectors.toList());
|
BigStorageDTO bigStorageDTO = null;
|
MPJLambdaWrapper<BigStorageCage> wrapper = new MPJLambdaWrapper<>(BigStorageCage.class)
|
.selectAll(BigStorageCage.class)
|
.leftJoin(BigStorageCageDetails.class, BigStorageCageDetails::getSlot, BigStorageCage::getSlot)
|
.eq(BigStorageCage::getEnableState, Const.SLOT_ON)
|
.in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL_ZERO)
|
.eq(BigStorageCageDetails::getEngineerId, glassInfo.getEngineerId())
|
.eq(BigStorageCageDetails::getTemperingLayoutId, glassInfo.getTemperingLayoutId())
|
.gt(BigStorageCage::getRemainWidth, Math.max(glassInfo.getWidth(), glassInfo.getHeight()))
|
.gt(BigStorageCage::getSlotHeight, Math.min(glassInfo.getWidth(), glassInfo.getHeight()))
|
.in(BigStorageCageDetails::getGlassId, glassIds)
|
.last("limit 1");
|
if (glassInfo.getTemperingLayoutId() == 0) {
|
wrapper.eq(BigStorageCageDetails::getFlowCardId, glassInfo.getFlowCardId())
|
.eq(BigStorageCageDetails::getLayer, glassInfo.getLayer());
|
// wrapper.eq(BigStorageCageDetails::getWidth, glassInfo.getWidth()).eq(BigStorageCageDetails::getHeight, glassInfo.getHeight());
|
} else {
|
wrapper.eq(BigStorageCageDetails::getTemperingFeedSequence, glassInfo.getTemperingFeedSequence() - 1);
|
}
|
BigStorageCage bigStorageCage = bigStorageCageService.selectJoinOne(BigStorageCage.class, wrapper);
|
if (null != bigStorageCage) {
|
log.info("无钢化版图id或根据当前玻璃片序+1找到目标格子：{},玻璃id：{}", bigStorageCage.getSlot(), glassInfo.getGlassId());
|
bigStorageDTO = new BigStorageDTO();
|
bigStorageDTO.setWidth(bigStorageCage.getRemainWidth());
|
bigStorageDTO.setSlot(bigStorageCage.getSlot());
|
bigStorageDTO.setDeviceId(bigStorageCage.getDeviceId());
|
return bigStorageDTO;
|
}
|
bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
|
.eq(BigStorageCage::getEnableState, Const.SLOT_ON)
|
.eq(BigStorageCage::getRemainWidth, slotWidth)
|
.lt(BigStorageCage::getSlotHeight, Math.min(glassInfo.getWidth(), glassInfo.getHeight()))
|
// .notInSql(BigStorageCage::getSlot, "select distinct slot from big_storage_cage_details where state = 0")
|
.inSql(BigStorageCage::getDeviceId,
|
"select distinct device_id from big_storage_cage_details where state!=101 and engineer_id = '" + glassInfo.getEngineerId() + "' and tempering_layout_id = " + glassInfo.getTemperingLayoutId())
|
.last("limit 1"));
|
if (null != bigStorageCage) {
|
log.info("根据版图id找到笼子内的目标格子：{},玻璃id：{}", bigStorageCage.getSlot(), glassInfo.getGlassId());
|
bigStorageDTO = new BigStorageDTO();
|
bigStorageDTO.setWidth(bigStorageCage.getRemainWidth());
|
bigStorageDTO.setSlot(bigStorageCage.getSlot());
|
bigStorageDTO.setDeviceId(bigStorageCage.getDeviceId());
|
return bigStorageDTO;
|
}
|
|
//获取玻璃的厚度：重新选笼子需要按照笼子可放玻璃厚度进行选择 因为子查询排序对主sql无影响，所以先执行子查询获取顺序，然后一次去查询
|
List<Integer> deviceUsedList = bigStorageCageService.queryFreeDeviceByUsed(glassInfo.getThickness(), Math.min(glassInfo.getWidth(), glassInfo.getHeight()));
|
List<Integer> deviceUseds = bigStorageCageService.queryFreeDeviceByUsed(glassInfo.getThickness(), Math.min(glassInfo.getWidth(), glassInfo.getHeight()));
|
List<BigStorageCageDetails> engineerCount1 = baseMapper.selectList(
|
new LambdaQueryWrapper<BigStorageCageDetails>()
|
.notIn(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT, Const.GLASS_STATE_DAMAGE, Const.GLASS_STATE_TAKE)
|
.select(BigStorageCageDetails::getEngineerId)
|
.groupBy(BigStorageCageDetails::getEngineerId)
|
.between(BigStorageCageDetails::getDeviceId, 1, 5)
|
);
|
List<BigStorageCageDetails> engineerCount2 = baseMapper.selectList(
|
new LambdaQueryWrapper<BigStorageCageDetails>()
|
.notIn(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT, Const.GLASS_STATE_DAMAGE, Const.GLASS_STATE_TAKE)
|
.select(BigStorageCageDetails::getEngineerId)
|
.groupBy(BigStorageCageDetails::getEngineerId)
|
.between(BigStorageCageDetails::getDeviceId, 6, 8)
|
);
|
BigStorageCageDetails bigStorageCageDetails = baseMapper.selectOne(
|
new LambdaQueryWrapper<BigStorageCageDetails>()
|
.eq(BigStorageCageDetails::getEngineerId, glassInfo.getEngineerId())
|
.orderByAsc(BigStorageCageDetails::getSlot)
|
.last("limit 1")
|
);
|
if (bigStorageCageDetails == null) {
|
if (glassInfo.getThickness() == 8) {
|
deviceUsedList.removeIf(device -> device < 6);
|
} else {
|
if (engineerCount1.size() > engineerCount2.size()) {
|
deviceUsedList.removeIf(device -> device < 6);
|
} else {
|
deviceUsedList.removeIf(device -> device > 5);
|
}
|
}
|
} else {
|
if (bigStorageCageDetails.getDeviceId() >= 1 && bigStorageCageDetails.getDeviceId() <= 5) {
|
deviceUsedList.removeIf(device -> device > 5);
|
} else {
|
deviceUsedList.removeIf(device -> device < 6);
|
}
|
}
|
|
if (CollectionUtils.isEmpty(deviceUsedList)) {
|
deviceUsedList = deviceUseds;
|
}
|
|
for (Integer item : deviceUsedList) {
|
bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
|
.eq(BigStorageCage::getRemainWidth, slotWidth)
|
.eq(BigStorageCage::getEnableState, Const.SLOT_ON)
|
.eq(BigStorageCage::getDeviceId, item)
|
.last("limit 1"));
|
if (null != bigStorageCage) {
|
log.info("按照存笼玻璃格子数占用最少方式获取信息格子为：{},玻璃id：{}", bigStorageCage.getSlot(), glassInfo.getGlassId());
|
bigStorageDTO = new BigStorageDTO();
|
bigStorageDTO.setWidth(bigStorageCage.getRemainWidth());
|
bigStorageDTO.setSlot(bigStorageCage.getSlot());
|
bigStorageDTO.setDeviceId(bigStorageCage.getDeviceId());
|
return bigStorageDTO;
|
}
|
}
|
|
//获取玻璃的厚度：重新选笼子需要按照笼子可放玻璃厚度进行选择
|
// List<Integer> deviceNotUsedList = bigStorageCageService.queryFreeDeviceByNotUsed(glassInfo.getThickness());
|
// for (Integer item : deviceNotUsedList) {
|
// bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
|
// .eq(BigStorageCage::getRemainWidth, slotWidth)
|
// .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
|
// .eq(BigStorageCage::getDeviceId, item)
|
// .last("limit 1"));
|
// if (null != bigStorageCage) {
|
// log.info("按照存笼玻璃格子数剩余最多得方式获取信息版图id:{},格子：{},玻璃id：{}", glassInfo.getTemperingLayoutId(), bigStorageCage.getSlot(), glassInfo.getGlassId());
|
// bigStorageDTO = new BigStorageDTO();
|
// bigStorageDTO.setWidth(bigStorageCage.getRemainWidth());
|
// bigStorageDTO.setSlot(bigStorageCage.getSlot());
|
// bigStorageDTO.setDeviceId(bigStorageCage.getDeviceId());
|
// return bigStorageDTO;
|
// }
|
// }
|
Assert.isTrue(null != bigStorageCage, "没有空余的笼子存放玻璃");
|
return bigStorageDTO;
|
}
|
|
@Override
|
public List<TemperingLayoutDTO> temperingIsAll() {
|
return baseMapper.temperingIsAll();
|
}
|
|
|
@Override
|
public List<TemperingLayoutDTO> queryTemperingOccupySlot() {
|
return baseMapper.queryTemperingOccupySlot(minCount);
|
}
|
|
@Override
|
public List<SlotSequenceDTO> queryGlassMaxAndMin(String engineerId, Integer temperingLayoutId) {
|
return baseMapper.queryGlassMaxAndMin(engineerId, temperingLayoutId);
|
}
|
|
@Override
|
public boolean temperingGlass(String temperingLayoutId, String engineerId, String temperingFeedSequence) {
|
LambdaQueryWrapper<TemperingGlassInfo> temperingGlassInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
|
temperingGlassInfoLambdaQueryWrapper
|
.eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW);
|
List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoMapper.selectList(temperingGlassInfoLambdaQueryWrapper);
|
if (temperingGlassInfoList.size() == 0) {
|
List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, JoinWrappers.lambda(GlassInfo.class)
|
.selectAll(GlassInfo.class)
|
.select("-1 as state")
|
.selectAs(BigStorageCageDetails::getSlot, TemperingGlassInfo::getSlot)
|
.innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)
|
.eq(GlassInfo::getTemperingLayoutId, temperingLayoutId)
|
.eq(GlassInfo::getEngineerId, engineerId)
|
.in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
|
.orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));
|
if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
|
if ("0".equals(temperingFeedSequence)) {
|
if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
|
plcStorageCageTask.computeOutMoreGlassInfo(temperingGlassInfos, Boolean.FALSE, 1);
|
}
|
} else {
|
temperingGlassInfoService.saveBatch(temperingGlassInfos);
|
}
|
return true;
|
}
|
}
|
return false;
|
}
|
|
|
@Override
|
public List<Map<String, Object>> selectTemperingGlass() {
|
List<Map<String, Object>> temperingGlass = baseMapper.selectTemperingGlassCount();
|
return temperingGlass;
|
}
|
|
@Override
|
public void updateBySlot(List<UpdateBigStorageCageDTO> glassList, int state) {
|
baseMapper.updateBySlot(glassList, state);
|
}
|
|
@Override
|
public String temperingSwitch(Boolean flag) {
|
redisUtil.setCacheObject("temperingSwitch", flag);
|
return "success";
|
}
|
|
@Override
|
public void appointEngineerId(String engineerId) {
|
redisUtil.setCacheObject("temperingengineerId", engineerId);
|
}
|
|
@Override
|
public long scheduleTime() {
|
//执行内部调度任务
|
List<TemperingLayoutDTO> temperingOccupySlotList = bigStorageCageDetailsService.queryTemperingOccupySlot();
|
List<BigStorageCageOutTask> bigStorageCageOutTasks = new ArrayList<>();
|
if (CollectionUtils.isNotEmpty(temperingOccupySlotList)) {
|
for (TemperingLayoutDTO temperingOccupySlot : temperingOccupySlotList) {
|
List<GlassInfo> glassInfos = glassInfoService.list(
|
new LambdaQueryWrapper<GlassInfo>()
|
.eq(GlassInfo::getEngineerId, temperingOccupySlot.getEngineerId())
|
.eq(GlassInfo::getTemperingLayoutId, temperingOccupySlot.getTemperingLayoutId())
|
.notInSql(GlassInfo::getGlassId, "select glass_id from damage where type=8 and engineer_id='"
|
+ temperingOccupySlot.getEngineerId() + "' and tempering_layout_id = '" + temperingOccupySlot.getTemperingLayoutId() + "'")
|
.orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence)
|
);
|
Map<Integer, List<GlassInfo>> listMap = glassInfos.stream().collect(Collectors.groupingBy(item -> item.getTargetSlot()));
|
for (Map.Entry<Integer, List<GlassInfo>> entry : listMap.entrySet()) {
|
List<GlassInfo> valueList = entry.getValue();
|
List<String> glassIds = valueList.stream().map(GlassInfo::getGlassId).collect(Collectors.toList());
|
List<BigStorageCageDetails> bigStorageCageDetailsList = bigStorageCageDetailsService.list(
|
new LambdaQueryWrapper<BigStorageCageDetails>()
|
.in(BigStorageCageDetails::getGlassId, glassIds)
|
.eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
|
.orderBy(Boolean.TRUE, sequenceOrder, BigStorageCageDetails::getTemperingFeedSequence)
|
);
|
//当一格玻璃都到齐时
|
if (bigStorageCageDetailsList.size() == valueList.size()) {
|
long distinctSlotCount = bigStorageCageDetailsList.stream()
|
.map(BigStorageCageDetails::getSlot)
|
.distinct()
|
.count();
|
//当玻璃不在同一格时
|
if (distinctSlotCount > 1) {
|
BigStorageCageDetails maxSequenceDetail = bigStorageCageDetailsList.stream()
|
.max(Comparator.comparingInt(BigStorageCageDetails::getTemperingFeedSequence))
|
.orElse(null); // 如果没有元素，返回 null
|
int maxSlot = maxSequenceDetail.getSlot();
|
int serialNumber = 1;
|
for (BigStorageCageDetails bigStorageCageDetails : bigStorageCageDetailsList
|
) {
|
if (bigStorageCageDetails.getSlot() != maxSlot) {
|
bigStorageCageOutTasks.add(new BigStorageCageOutTask(bigStorageCageDetails.getGlassId(), bigStorageCageDetails.getSlot(), maxSlot,
|
bigStorageCageDetails.getWidth() * 10, bigStorageCageDetails.getHeight() * 10, 1, serialNumber++, Const.BIG_STORAGE_OUT_NEW, new Date()));
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
long startSlotCount = bigStorageCageOutTasks.stream().map(BigStorageCageOutTask::getStartSlot).distinct().count();
|
long endSlotCount = bigStorageCageOutTasks.stream().map(BigStorageCageOutTask::getEndSlot).distinct().count();
|
long time = (startSlotCount * 30 + endSlotCount * 20) / 60;
|
return time;
|
}
|
|
@Override
|
public void cancelOutTask() {
|
List<BigStorageCageOutTask> bigStorageCageOutTasks = bigStorageCageOutTaskService.list(
|
new LambdaQueryWrapper<BigStorageCageOutTask>()
|
.in(BigStorageCageOutTask::getEndSlot, Const.OUT_TARGET_POSITION_ALL)
|
.eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_NEW)
|
);
|
if(bigStorageCageOutTasks.size()>0){
|
List<String> outGlassId = bigStorageCageOutTasks.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
|
temperingGlassInfoService.remove(
|
new LambdaUpdateWrapper<TemperingGlassInfo>()
|
.in(TemperingGlassInfo::getGlassId, outGlassId)
|
);
|
bigStorageCageDetailsService.update(
|
new LambdaUpdateWrapper<BigStorageCageDetails>()
|
.set(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
|
.eq(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING)
|
.in(BigStorageCageDetails::getGlassId, outGlassId)
|
);
|
bigStorageCageOutTaskService.deleteTask(bigStorageCageOutTasks);
|
}
|
}
|
|
@Override
|
public List<FlowCardDTO> selectFlowCardCount(){
|
return baseMapper.selectFlowCardCount();
|
}
|
}
|
