package com.chinaztt.mes.aps.service.impl;
|
|
import cn.hutool.core.collection.CollectionUtil;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.chinaztt.mes.aps.core.domain.OperationBo;
|
import com.chinaztt.mes.aps.core.domain.Order;
|
import com.chinaztt.mes.aps.entity.Resource;
|
import com.chinaztt.mes.aps.entity.ResourceDuration;
|
import com.chinaztt.mes.aps.entity.SceneTask;
|
import com.chinaztt.mes.aps.mapper.ApsCoreMapper;
|
import com.chinaztt.mes.aps.mapper.ResourceDurationMapper;
|
import com.chinaztt.mes.aps.mapper.ResourceMapper;
|
import com.chinaztt.mes.aps.mapper.SceneTaskMapper;
|
import com.chinaztt.mes.aps.service.ApsCoreService;
|
import com.chinaztt.mes.aps.vo.GanttTaskVo;
|
import com.chinaztt.mes.aps.vo.ResourceVo;
|
import com.chinaztt.mes.basic.entity.Workstation;
|
import com.chinaztt.mes.basic.mapper.WorkstationMapper;
|
import com.chinaztt.mes.plan.entity.MoStructureComponent;
|
import com.chinaztt.mes.plan.mapper.MoStructureComponentMapper;
|
import com.chinaztt.mes.production.dto.OperationTaskDTO;
|
import com.chinaztt.mes.production.entity.OperationTask;
|
import com.chinaztt.mes.production.entity.OperationTaskMaterial;
|
import com.chinaztt.mes.production.entity.OperationTaskSupply;
|
import com.chinaztt.mes.production.mapper.OperationTaskMapper;
|
import com.chinaztt.mes.production.mapper.OperationTaskMaterialMapper;
|
import com.chinaztt.mes.production.mapper.OperationTaskSupplyMapper;
|
import com.chinaztt.mes.production.state.operationtask.constant.OperationTaskStateStringValues;
|
import com.chinaztt.ztt.common.core.util.R;
|
import com.chinaztt.ztt.common.sequence.sequence.Sequence;
|
import lombok.AllArgsConstructor;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* @Author: zhangxy
|
* @Date: 2020-10-09 10:35
|
*/
|
@Service
|
@AllArgsConstructor
|
public class ApsCoreServiceImpl implements ApsCoreService {
|
|
private Sequence opTaskSequence;
|
private ApsCoreMapper apsCoreMapper;
|
private ResourceMapper resourceMapper;
|
private ResourceDurationMapper resourceDurationMapper;
|
private SceneTaskMapper sceneTaskMapper;
|
private OperationTaskMapper operationTaskMapper;
|
private OperationTaskSupplyMapper operationTaskSupplyMapper;
|
private MoStructureComponentMapper moStructureComponentMapper;
|
private OperationTaskMaterialMapper operationTaskMaterialMapper;
|
private WorkstationMapper workstationMapper;
|
|
|
@Override
|
public void saveSceneTask(SceneTask task) {
|
sceneTaskMapper.insert(task);
|
}
|
|
@Override
|
public OperationBo queryOperation(Long operationId) {
|
return apsCoreMapper.queryOperation(operationId);
|
}
|
|
@Override
|
public JSONObject query(Long sceneId, Long groupId, LocalDate start, LocalDate end) {
|
List<ResourceVo> resources;
|
if (groupId == null || groupId == 0) {
|
resources = apsCoreMapper.getAllResourceVo();
|
} else {
|
resources = apsCoreMapper.queryResourceByGroupId(groupId);
|
}
|
Set<Long> resourceIds = resources.stream().map(r -> r.getId()).collect(Collectors.toSet());
|
JSONObject obj = new JSONObject();
|
obj.put("resources", resources);
|
if (sceneId != null && sceneId > 0) {
|
obj.put("sceneTasks", apsCoreMapper.querySceneTaskByTimeRange(sceneId, start, end, resourceIds));
|
}
|
obj.put("operationTasks", apsCoreMapper.queryOperationTaskByTimeRange(start, end, resourceIds));
|
return obj;
|
}
|
|
@Override
|
public JSONObject loadGantt(Long sceneId, List<Long> workStationList, String workCenter, LocalDate start, LocalDate end, List<String> stateList) {
|
List<ResourceVo> resources = apsCoreMapper.queryResourceByGroupIdGantt(workStationList, workCenter);
|
Set<Long> workstationIds = resources.stream().map(r -> r.getId()).collect(Collectors.toSet());
|
JSONObject obj = new JSONObject();
|
obj.put("resources", resources);
|
if (sceneId != null && sceneId > 0) {
|
obj.put("sceneTasks", apsCoreMapper.querySceneTaskByTimeRange(sceneId, start, end, workstationIds));
|
}
|
obj.put("operationTasks", apsCoreMapper.queryOperationTaskByTimeRangeGantt(start, end, workstationIds, stateList));
|
return obj;
|
}
|
|
/**
|
* 根据工作站零件数量计算机台时间
|
*
|
* @param workstationId
|
* @param partId
|
* @param qty
|
* @return
|
*/
|
@Override
|
public OperationTaskDTO calOperationTaskTime(Long workstationId, Long partId, BigDecimal qty) {
|
OperationTaskDTO operationTask = new OperationTaskDTO();
|
//根据工作站查询资源
|
Resource resource = resourceMapper.selectOne(Wrappers.<Resource>lambdaQuery()
|
.eq(Resource::getWorkstationId, workstationId));
|
if (resource != null) {
|
//根据资源id和零件id 查询资源产能
|
List<ResourceDuration> resourceDurationList = resourceDurationMapper.selectList(Wrappers.<ResourceDuration>lambdaQuery()
|
.orderByDesc(ResourceDuration::getId)
|
.eq(ResourceDuration::getPartId, partId)
|
.eq(ResourceDuration::getResourceId, resource.getId()));
|
if (CollectionUtil.isNotEmpty(resourceDurationList)) {
|
ResourceDuration resourceDuration = resourceDurationList.get(0);
|
//工单时间 = （计划数量 / 机台速率） + 前置时间 + 后置时间 单位是分钟
|
BigDecimal machnieTime = qty.divide(resourceDuration.getProductionRate(), 0, BigDecimal.ROUND_UP)
|
.add(resourceDuration.getPostProcessing())
|
.add(resourceDuration.getSetupTime());
|
//查询未完成的工单的最大的计划完成时间 如果没有就获取当前时间
|
LocalDateTime localDateTime = apsCoreMapper.getOperatioTaskMaxPlanEndTime(workstationId);
|
if (localDateTime == null) {
|
localDateTime = LocalDateTime.now();
|
}
|
operationTask.setTaskTheoreticalTime(machnieTime);
|
operationTask.setPlannedStartDate(localDateTime.plusMinutes(1));
|
operationTask.setPlannedFinishDate(operationTask.getPlannedStartDate().plusMinutes(machnieTime.longValue()));
|
}
|
}
|
return operationTask;
|
}
|
|
|
/**
|
* 根据零件数量 自动选择机台
|
*
|
* @param partId
|
* @param qty
|
* @return
|
*/
|
@Override
|
public OperationTaskDTO autoSetTime(String workCenter, Long partId, BigDecimal qty) {
|
OperationTaskDTO returnOp = new OperationTaskDTO();
|
//查询当前工作中心下面配置了 资源能力的 工作站
|
List<Long> workstationIds = apsCoreMapper.getWorkstationIdByWorkcenter(workCenter, partId);
|
if (CollectionUtil.isNotEmpty(workstationIds)) {
|
// 在这些工作站 中查找 未完成的工单 并且根据 计划完成时间 正序排序
|
List<OperationTask> operationTaskList = operationTaskMapper.selectList(Wrappers.<OperationTask>lambdaQuery()
|
.orderByAsc(OperationTask::getPlannedFinishDate)
|
.isNotNull(OperationTask::getPlannedFinishDate)
|
.in(OperationTask::getState, Arrays.asList("07unsubmit", "01pending", "02inProgress", "03interrupted"))
|
.in(OperationTask::getWorkstationId, workstationIds));
|
//设置默认时间为当前
|
LocalDateTime planStartDate = LocalDateTime.now();
|
//如果工单存 就先看看有没有不存在工单的机台 如果都有工单机台就选取第一个 工单的机台 时间根据最早时间计算 如果不存在工单就 工作站 选取第一个 时间获取当前
|
if (CollectionUtil.isNotEmpty(operationTaskList)) {
|
//将工单根据工作站进行分组
|
Map<Long, List<OperationTask>> mapWorkstationIdOps = operationTaskList.stream().collect(Collectors.groupingBy(OperationTask::getWorkstationId));
|
//过滤出在产工作台
|
List<Long> optaskStationIdList = new ArrayList<>(mapWorkstationIdOps.keySet());
|
//过滤出空闲工作台
|
List<Long> noOptaskStationIdList = workstationIds.stream().filter(item -> optaskStationIdList.stream().allMatch(each -> !item.equals(each))).collect(Collectors.toList());
|
//如果 空闲工作台 是空的
|
if (CollectionUtil.isEmpty(noOptaskStationIdList)) {
|
OperationTask firstFirstFinished = operationTaskList.get(0);
|
returnOp.setWorkstationId(firstFirstFinished.getWorkstationId());
|
//如果最早的结束时间在当前时间之后 开始时间就是当前时间 + 1min
|
if (firstFirstFinished.getPlannedFinishDate().isAfter(LocalDateTime.now())) {
|
planStartDate = firstFirstFinished.getPlannedFinishDate().plusMinutes(1);
|
}
|
} else {
|
returnOp.setWorkstationId(noOptaskStationIdList.get(0));
|
}
|
} else {
|
returnOp.setWorkstationId(workstationIds.get(0));
|
}
|
returnOp.setPlannedStartDate(planStartDate);
|
//查询资源
|
Resource resource = resourceMapper.selectOne(Wrappers.<Resource>lambdaQuery()
|
.eq(Resource::getWorkstationId, returnOp.getWorkstationId()));
|
//查询能力
|
ResourceDuration resourceDuration = resourceDurationMapper.selectOne(Wrappers.<ResourceDuration>lambdaQuery()
|
.orderByDesc(ResourceDuration::getId)
|
.eq(ResourceDuration::getPartId, partId)
|
.eq(ResourceDuration::getResourceId, resource.getId())
|
.last("limit 1"));
|
//计算工单需要完成时间
|
BigDecimal machnieTime = qty.divide(resourceDuration.getProductionRate(), 0, BigDecimal.ROUND_UP)
|
.add(resourceDuration.getPostProcessing())
|
.add(resourceDuration.getSetupTime());
|
//结束时间 + 完成时间
|
returnOp.setPlannedFinishDate(returnOp.getPlannedStartDate().plusMinutes(machnieTime.longValue()));
|
returnOp.setTaskTheoreticalTime(machnieTime);
|
Workstation workstation = workstationMapper.selectById(returnOp.getWorkstationId());
|
returnOp.setWorkstationNo(workstation.getWorkstationNo());
|
returnOp.setWorkstationName(workstation.getName());
|
}
|
return returnOp;
|
}
|
|
@Override
|
public Boolean updateTaskById(GanttTaskVo taskVo) {
|
SceneTask task = sceneTaskMapper.selectById(Long.valueOf(taskVo.getId()));
|
task.setStartTime(taskVo.getStartDate());
|
task.setEndTime(taskVo.getEndDate());
|
task.setResourceId(Long.valueOf(taskVo.getParent()));
|
sceneTaskMapper.updateById(task);
|
return Boolean.TRUE;
|
}
|
|
@Override
|
public Boolean removeSceneTask(Long id) {
|
sceneTaskMapper.deleteById(id);
|
return Boolean.TRUE;
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
@Override
|
public synchronized R<Boolean> applyToReality(Long sceneId) {
|
List<SceneTask> taskList = sceneTaskMapper.selectList(Wrappers.<SceneTask>lambdaQuery().eq(SceneTask::getSceneId, sceneId).eq(SceneTask::getApplied, false));
|
if (CollectionUtil.isEmpty(taskList)) {
|
return R.failed("该场景下没有未应用的内容");
|
}
|
for (SceneTask sceneTask : taskList) {
|
OperationTask optask = new OperationTask();
|
String number = opTaskSequence.nextNo();
|
optask.setOptaskNo(number);
|
optask.setRoutingId(sceneTask.getRoutingId());
|
optask.setRoutingOperationId(sceneTask.getRoutingOperationId());
|
optask.setState(OperationTaskStateStringValues.PENDING);
|
optask.setPlannedQuantity(sceneTask.getQuantity());
|
optask.setPlannedStartDate(sceneTask.getStartTime());
|
optask.setPlannedFinishDate(sceneTask.getEndTime());
|
optask.setPartId(sceneTask.getPartId());
|
|
Resource resource = resourceMapper.selectById(sceneTask.getResourceId());
|
optask.setWorkstationId(resource.getWorkstationId());
|
optask.setResourceId(resource.getId());
|
|
operationTaskMapper.insert(optask);
|
|
createMaterial(optask);
|
createSupply(optask, sceneTask);
|
|
sceneTask.setApplied(true);
|
sceneTaskMapper.updateById(sceneTask);
|
}
|
|
return R.ok();
|
}
|
|
|
/**
|
* 工单供应表 暂定1:1
|
* todo 拆分或者合并订单
|
*
|
* @param optask
|
* @param sceneTask
|
*/
|
private void createSupply(OperationTask optask, SceneTask sceneTask) {
|
OperationTaskSupply supply = new OperationTaskSupply();
|
supply.setMoId(sceneTask.getOrderId());
|
supply.setOperationTaskId(optask.getId());
|
supply.setQuantitySupply(sceneTask.getQuantity());
|
operationTaskSupplyMapper.insert(supply);
|
}
|
|
private void createMaterial(OperationTask optask) {
|
LambdaQueryWrapper wrapper = Wrappers.<MoStructureComponent>lambdaQuery().eq(MoStructureComponent::getRoutingOperationId, optask.getRoutingOperationId());
|
List<MoStructureComponent> list = moStructureComponentMapper.selectList(wrapper);
|
if (CollectionUtil.isNotEmpty(list)) {
|
for (MoStructureComponent s : list) {
|
OperationTaskMaterial material = new OperationTaskMaterial();
|
material.setOperationTaskId(optask.getId());
|
material.setPartId(s.getPartId());
|
material.setQpa(s.getQpa());
|
material.setQuantityRequired(s.getQpa().multiply(optask.getPlannedQuantity()));
|
operationTaskMaterialMapper.insert(material);
|
}
|
}
|
}
|
|
|
}
|
