package com.chinaztt.mes.aps.core;
|
|
import cn.hutool.core.collection.CollectionUtil;
|
import com.alibaba.fastjson.JSON;
|
import com.chinaztt.mes.aps.core.domain.*;
|
import com.chinaztt.mes.aps.core.helper.ResourceHelper;
|
import com.chinaztt.mes.aps.dto.OrderDTO;
|
import com.chinaztt.mes.aps.entity.SceneTask;
|
import com.chinaztt.mes.aps.service.*;
|
import com.chinaztt.mes.plan.entity.ManufacturingOrder;
|
import com.chinaztt.mes.plan.service.ManufacturingOrderService;
|
import com.chinaztt.mes.technology.dto.RefDTO;
|
import com.chinaztt.mes.technology.dto.RoutingDTO;
|
import com.chinaztt.mes.technology.dto.RoutingOperationDTO;
|
import com.chinaztt.mes.technology.service.RoutingService;
|
import com.chinaztt.ztt.common.core.util.R;
|
import lombok.AllArgsConstructor;
|
import lombok.extern.slf4j.Slf4j;
|
import org.optaplanner.core.api.score.Score;
|
import org.optaplanner.core.api.score.ScoreManager;
|
import org.optaplanner.core.api.solver.SolverFactory;
|
import org.optaplanner.core.api.solver.SolverJob;
|
import org.optaplanner.core.api.solver.SolverManager;
|
import org.optaplanner.core.impl.score.director.ScoreDirector;
|
import org.optaplanner.core.impl.score.director.ScoreDirectorFactory;
|
import org.springframework.stereotype.Component;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.time.Duration;
|
import java.time.LocalDateTime;
|
import java.util.*;
|
import java.util.concurrent.ExecutionException;
|
import java.util.stream.Collectors;
|
|
/**
|
* 排产核心类
|
*
|
* @Author: zhangxy
|
* @Date: 2020-09-23 11:00
|
*/
|
@AllArgsConstructor
|
@Component
|
@Slf4j
|
public class ApsMain {
|
|
private ResourceHelper resourceHelper;
|
private RoutingService routingService;
|
private ApsCoreService apsCoreService;
|
private ManufacturingOrderService manufacturingOrderService;
|
private SolverManager<ApsSolution, UUID> solverManager;
|
private SolverFactory solverFactory;
|
|
private ScoreManager scoreManager;
|
|
public static void main(String[] arg) {
|
|
LocalDateTime a = LocalDateTime.now();
|
|
LocalDateTime b = a.plusDays(1);
|
|
Duration d = Duration.between(b, a);
|
System.out.println(d.toMinutes());
|
|
|
}
|
|
|
/**
|
* 运行排产，传入待排产订单集合
|
* ！！！计算的时间单位都是分钟！！！
|
*
|
* @param dtoList
|
* @return
|
*/
|
public R<Boolean> run(OrderDTO[] dtoList, Long sceneId) {
|
List<Order> orders = buildOrderList(dtoList);
|
if (CollectionUtil.isEmpty(orders)) {
|
return R.failed("请选择待排产订单");
|
}
|
UUID problemId = UUID.randomUUID();
|
SolverJob<ApsSolution, UUID> solverJob = solverManager.solve(problemId, generateProblem(orders, sceneId));
|
ApsSolution solution;
|
try {
|
solution = solverJob.getFinalBestSolution();
|
saveSceneTask(solution.getTaskList(), sceneId);
|
System.out.println(JSON.toJSONString(solution));
|
} catch (InterruptedException | ExecutionException e) {
|
throw new IllegalStateException("Solving failed.", e);
|
}
|
|
return R.ok();
|
}
|
|
|
private List<Order> buildOrderList(OrderDTO[] dtoList) {
|
if (dtoList == null || dtoList.length == 0) {
|
return null;
|
}
|
List<Order> orders = new ArrayList<>();
|
for (OrderDTO dto : dtoList) {
|
ManufacturingOrder mo = manufacturingOrderService.getById(dto.getId());
|
Order order = new Order();
|
order.setPriority(dto.getPriority());
|
order.setId(mo.getId());
|
order.setPartId(mo.getPartId());
|
order.setQuantity(mo.getQtyRequired());
|
order.setRouting(routingService.getRoutingById(mo.getTechnologyRoutingId()));
|
orders.add(order);
|
}
|
|
return orders;
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
protected void saveSceneTask(List<Task> taskList, Long sceneId) {
|
if (CollectionUtil.isNotEmpty(taskList)) {
|
for (Task task : taskList) {
|
SceneTask sceneTask = new SceneTask();
|
sceneTask.setSceneId(sceneId);
|
sceneTask.setStartTime(task.getPlanStartTime());
|
sceneTask.setEndTime(task.getPlanEndTime());
|
sceneTask.setResourceId(task.getResourceBo().getId());
|
sceneTask.setOrderId(task.getOrderId());
|
sceneTask.setRoutingOperationId(task.getRoutingOperationId());
|
sceneTask.setRoutingId(task.getRoutingId());
|
sceneTask.setQuantity(task.getQuantity());
|
sceneTask.setPartId(task.getPartId());
|
apsCoreService.saveSceneTask(sceneTask);
|
}
|
}
|
}
|
|
|
/**
|
* 构造问题，传给求解引擎
|
* @param orders
|
* @param sceneId
|
* @return
|
*/
|
private ApsSolution generateProblem(List<Order> orders, Long sceneId) {
|
List<Task> tasks = new ArrayList<>();
|
//按照零件分组
|
Map<Long, List<Order>> partOrderMap = orders.stream().collect(Collectors.groupingBy(Order::getPartId));
|
partOrderMap.forEach((k, v) -> {
|
List<Order> mergedOrders = merge(v);
|
for (Order order : mergedOrders) {
|
buildTaskVariable(tasks, order);
|
}
|
});
|
|
ApsSolution problem = new ApsSolution();
|
problem.setResourceBoList(resourceHelper.buildResourceVariable(sceneId));
|
problem.setTaskList(tasks);
|
return problem;
|
}
|
|
|
private void buildTaskVariable(List tasks, Order order) {
|
int i = 1;
|
RoutingOperationDTO first = first(order.getRouting());
|
Task task = new Task();
|
task.setQuantity(order.getQuantity());
|
task.setOrderPriority(order.getPriority());
|
task.setOperationPriority(i++);
|
task.setOpNo(first.getOperationNo());
|
task.setOrderId(order.getId());
|
task.setRoutingId(order.getRouting().getId());
|
task.setRoutingOperationId(first.getId());
|
task.setName(first.getOperationName());
|
task.setCapabilityIds(getOpCapIds(first.getOperationId()));
|
task.setPartId(order.getPartId());
|
task.setSuccessorOfRouting(repeatOperation(task, order, first.getId(), tasks, i));
|
tasks.add(task);
|
}
|
|
|
private Task repeatOperation(Task pre, Order order, Long fromId, List<Task> list, int i) {
|
RoutingOperationDTO dto = next(order.getRouting(), fromId);
|
if (dto != null) {
|
Task task = new Task();
|
task.setQuantity(order.getQuantity());
|
task.setOrderPriority(order.getPriority());
|
task.setOperationPriority(i++);
|
task.setPartId(order.getPartId());
|
task.setOpNo(dto.getOperationNo());
|
task.setOrderId(order.getId());
|
task.setRoutingId(order.getRouting().getId());
|
task.setRoutingOperationId(dto.getId());
|
task.setName(dto.getOperationName());
|
task.setCapabilityIds(getOpCapIds(dto.getOperationId()));
|
task.setPredecessorOfRouting(pre);
|
task.setSuccessorOfRouting(repeatOperation(task, order, dto.getId(), list, i));
|
list.add(task);
|
return task;
|
}
|
return null;
|
}
|
|
|
private Set<Long> getOpCapIds(Long opId) {
|
OperationBo operation = apsCoreService.queryOperation(opId);
|
return operation.getCapabilityIds();
|
}
|
|
|
/**
|
* 合并订单
|
*
|
* @param orders
|
* @return
|
*/
|
private List<Order> merge(List<Order> orders) {
|
//todo 同一零件是否合并生产
|
return orders;
|
}
|
|
|
/**
|
* 工艺的首道工序
|
*
|
* @param routing
|
* @return
|
*/
|
public RoutingOperationDTO first(RoutingDTO routing) {
|
return next(routing, null);
|
}
|
|
/**
|
* 下道工序，fromId传null时找的是首道
|
*
|
* @param routing
|
* @param fromId
|
* @return
|
*/
|
public RoutingOperationDTO next(RoutingDTO routing, Long fromId) {
|
List<RefDTO> refs = routing.getRefs();
|
if (fromId == null) {
|
List<Long> roIds = routing.getOperations().stream().map(ro -> ro.getId()).collect(Collectors.toList());
|
List<Long> toIds = refs.stream().map(r -> r.getToId()).collect(Collectors.toList());
|
roIds.removeAll(toIds);
|
return routingService.getDtoByPk(roIds.get(0));
|
} else if (CollectionUtil.isNotEmpty(refs)) {
|
Optional<RefDTO> opt = refs.stream().filter(r -> r.getFromId().equals(fromId)).findFirst();
|
if (opt.isPresent()) {
|
return routingService.getDtoByPk(opt.get().getToId());
|
}
|
}
|
return null;
|
}
|
|
|
}
|
