| 对比新文件 |
| | |
|---|
| | | package cn.iocoder.yudao.module.mes.service.pro.task.schedule; |
|---|
| | | |
|---|
| | | import cn.iocoder.yudao.framework.common.exception.ServiceException; |
|---|
| | | import cn.iocoder.yudao.module.crm.api.customer.CrmCustomerApi; |
|---|
| | | import cn.iocoder.yudao.module.mes.controller.admin.pro.task.vo.*; |
|---|
| | | import cn.iocoder.yudao.module.mes.dal.dataobject.dv.machinery.MesDvMachineryDO; |
|---|
| | | import cn.iocoder.yudao.module.mes.dal.dataobject.md.item.MesMdItemDO; |
|---|
| | | import cn.iocoder.yudao.module.mes.dal.dataobject.md.workstation.MesMdWorkstationDO; |
|---|
| | | import cn.iocoder.yudao.module.mes.dal.dataobject.pro.process.MesProProcessDO; |
|---|
| | | import cn.iocoder.yudao.module.mes.dal.dataobject.pro.route.MesProRouteDO; |
|---|
| | | import cn.iocoder.yudao.module.mes.dal.dataobject.pro.task.MesProTaskDO; |
|---|
| | | import cn.iocoder.yudao.module.mes.dal.dataobject.pro.workorder.*; |
|---|
| | | import cn.iocoder.yudao.module.mes.dal.mysql.dv.machinery.MesDvMachineryMapper; |
|---|
| | | import cn.iocoder.yudao.module.mes.dal.mysql.pro.task.MesProTaskMapper; |
|---|
| | | import cn.iocoder.yudao.module.mes.dal.mysql.pro.workorder.MesProWorkOrderMapper; |
|---|
| | | import cn.iocoder.yudao.module.mes.service.cal.holiday.MesCalHolidayService; |
|---|
| | | import cn.iocoder.yudao.module.mes.service.md.item.MesMdItemService; |
|---|
| | | import cn.iocoder.yudao.module.mes.service.md.workstation.MesMdWorkstationService; |
|---|
| | | import cn.iocoder.yudao.module.mes.service.pro.process.MesProProcessService; |
|---|
| | | import cn.iocoder.yudao.module.mes.service.pro.route.MesProRouteService; |
|---|
| | | import cn.iocoder.yudao.module.mes.service.pro.task.MesProTaskService; |
|---|
| | | import cn.iocoder.yudao.module.mes.service.pro.workorder.MesProWorkOrderProcessService; |
|---|
| | | import org.junit.jupiter.api.Test; |
|---|
| | | import org.springframework.aop.framework.ProxyFactory; |
|---|
| | | import org.springframework.jdbc.core.JdbcTemplate; |
|---|
| | | import org.springframework.jdbc.datasource.*; |
|---|
| | | import org.springframework.test.util.ReflectionTestUtils; |
|---|
| | | import org.springframework.transaction.annotation.AnnotationTransactionAttributeSource; |
|---|
| | | import org.springframework.transaction.interceptor.TransactionInterceptor; |
|---|
| | | import org.springframework.dao.DataAccessException; |
|---|
| | | |
|---|
| | | import java.lang.reflect.*; |
|---|
| | | import java.math.BigDecimal; |
|---|
| | | import java.time.*; |
|---|
| | | import java.util.*; |
|---|
| | | import java.util.concurrent.*; |
|---|
| | | import java.util.concurrent.atomic.AtomicInteger; |
|---|
| | | import static org.junit.jupiter.api.Assertions.*; |
|---|
| | | |
|---|
| | | class MesProBatchScheduleServiceTest { |
|---|
| | | @Test void yieldAdjustedPreviewExecutesThroughRealQuantityGuard() { |
|---|
| | | var f = new Fixture(); |
|---|
| | | f.processes.forEach(process -> process.setYieldRate(new BigDecimal("0.98"))); |
|---|
| | | var request = f.confirmable(); |
|---|
| | | assertEquals(2, f.proxy.execute(request).size()); |
|---|
| | | assertEquals(new BigDecimal("103.00"), f.readTasks().getFirst().getQuantity()); |
|---|
| | | assertEquals(new BigDecimal("100.00"), f.readTasks().getLast().getQuantity()); |
|---|
| | | assertEquals(new BigDecimal("100.00"), f.scheduledQuantity()); |
|---|
| | | assertFalse(f.service.preview(f.request()).isCanExecute()); |
|---|
| | | } |
|---|
| | | @Test void previewDoesNotWriteAndProcessesAreSequential() { |
|---|
| | | var f = new Fixture(); |
|---|
| | | var result = f.service.preview(f.request()); |
|---|
| | | assertTrue(result.isCanExecute()); |
|---|
| | | assertEquals(2, result.getTasks().size()); |
|---|
| | | assertFalse(result.getTasks().get(1).getStartTime().isBefore(result.getTasks().getFirst().getEndTime())); |
|---|
| | | assertEquals(0, f.taskCount()); |
|---|
| | | assertEquals(0, f.creates.get()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Test void partialOrderOnlyFillsEachProcessRemainingQuantity() { |
|---|
| | | var f = new Fixture(); |
|---|
| | | f.jdbc.update("INSERT INTO schedule_task VALUES(99,1,1,1,40,4,?,?)", LocalDateTime.now().minusDays(1), LocalDateTime.now().minusHours(1)); |
|---|
| | | var preview = f.service.preview(f.request()); |
|---|
| | | assertTrue(preview.isCanExecute()); |
|---|
| | | assertEquals(new BigDecimal("60.00"), preview.getTasks().getFirst().getQuantity()); |
|---|
| | | assertEquals(new BigDecimal("100"), preview.getTasks().getLast().getQuantity()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Test void completedSchedulingBlocksDuplicateAndCanceledDoesNotConsumeQuantity() { |
|---|
| | | var f = new Fixture(); |
|---|
| | | var request = f.confirmable(); |
|---|
| | | f.proxy.execute(request); |
|---|
| | | assertThrows(ServiceException.class, () -> f.proxy.execute(request)); |
|---|
| | | assertEquals(2, f.taskCount()); |
|---|
| | | assertEquals(new BigDecimal("100.00"), f.scheduledQuantity()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Test void anyInvalidOrderBlocksWholeBatch() { |
|---|
| | | var f = new Fixture(); |
|---|
| | | f.orders.add(new MesProWorkOrderDO().setId(2L).setCode("WO-2").setStatus(0).setType(1).setQuantity(BigDecimal.TEN)); |
|---|
| | | f.jdbc.update("INSERT INTO schedule_order VALUES(2,0)"); |
|---|
| | | var request = f.request(); request.setWorkOrderIds(List.of(1L, 2L)); |
|---|
| | | var preview = f.service.preview(request); |
|---|
| | | assertFalse(preview.isCanExecute()); |
|---|
| | | assertNotNull(preview.getOrders().getLast().getError()); |
|---|
| | | request.setPreviewTime(preview.getPreviewTime()); request.setPreviewHash(preview.getPreviewHash()); |
|---|
| | | assertThrows(ServiceException.class, () -> f.proxy.execute(request)); |
|---|
| | | assertEquals(0, f.taskCount()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Test void missingCapacityAndDisabledOrderDoNotSilentlyCreateDraftTasks() { |
|---|
| | | var f = new Fixture(); |
|---|
| | | f.machines.getFirst().setProductionEfficiency(BigDecimal.ZERO); |
|---|
| | | assertFalse(f.service.preview(f.request()).isCanExecute()); |
|---|
| | | assertEquals(0, f.taskCount()); |
|---|
| | | f.machines.getFirst().setProductionEfficiency(BigDecimal.valueOf(100)); |
|---|
| | | f.orders.getFirst().setStatus(2); |
|---|
| | | assertFalse(f.service.preview(f.request()).isCanExecute()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Test void changedPreviewAndExpiredPreviewCannotCommit() { |
|---|
| | | var f = new Fixture(); var request = f.confirmable(); |
|---|
| | | f.machines.getFirst().setProductionEfficiency(BigDecimal.valueOf(200)); |
|---|
| | | assertThrows(ServiceException.class, () -> f.proxy.execute(request)); |
|---|
| | | assertEquals(0, f.taskCount()); |
|---|
| | | final var expired = f.confirmable(); expired.setPreviewTime(LocalDateTime.now(ZoneId.of("Asia/Shanghai")).minusMinutes(16)); |
|---|
| | | assertThrows(ServiceException.class, () -> f.proxy.execute(expired)); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Test void duplicateIdsAndInvalidClockAreRejected() { |
|---|
| | | var f = new Fixture(); var request = f.request(); request.setWorkOrderIds(List.of(1L, 1L)); |
|---|
| | | assertThrows(ServiceException.class, () -> f.service.preview(request)); |
|---|
| | | request.setWorkOrderIds(List.of(1L)); request.setStartTime(LocalDateTime.now().minusDays(1)); |
|---|
| | | assertThrows(ServiceException.class, () -> f.service.preview(request)); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Test void failureDuringSecondTaskRollsBackTasksAndOrderCounter() { |
|---|
| | | var f = new Fixture(); var request = f.confirmable(); f.failAt = 2; |
|---|
| | | assertThrows(IllegalStateException.class, () -> f.proxy.execute(request)); |
|---|
| | | assertEquals(0, f.taskCount()); |
|---|
| | | assertEquals(BigDecimal.ZERO.setScale(2), f.scheduledQuantity()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Test void concurrentSubmissionsCannotCreateDuplicateTasks() throws Exception { |
|---|
| | | var f = new Fixture(); var request = f.confirmable(); |
|---|
| | | var start = new CountDownLatch(1); |
|---|
| | | try (var pool = Executors.newFixedThreadPool(2)) { |
|---|
| | | Callable<Boolean> action = () -> { |
|---|
| | | start.await(); |
|---|
| | | try { f.proxy.execute(request); return true; } |
|---|
| | | catch (ServiceException | DataAccessException expected) { return false; } |
|---|
| | | }; |
|---|
| | | var first = pool.submit(action); var second = pool.submit(action); start.countDown(); |
|---|
| | | int successes = (first.get(20, TimeUnit.SECONDS) ? 1 : 0) + (second.get(20, TimeUnit.SECONDS) ? 1 : 0); |
|---|
| | | assertEquals(1, successes); assertEquals(2, f.taskCount()); |
|---|
| | | } |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Test void latenessRequiresExplicitAcknowledgment() { |
|---|
| | | var f = new Fixture(); f.orders.getFirst().setRequestDate(LocalDateTime.now().minusDays(1)); |
|---|
| | | var request = f.confirmable(); request.setAllowLate(false); |
|---|
| | | assertThrows(ServiceException.class, () -> f.proxy.execute(request)); |
|---|
| | | assertEquals(0, f.taskCount()); |
|---|
| | | request.setAllowLate(true); assertEquals(2, f.proxy.execute(request).size()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Test void preparationAndWaitingAreReserved() { |
|---|
| | | var f = new Fixture(); |
|---|
| | | f.processes.getFirst().setPrepareTime(30).setWaitTime(60); |
|---|
| | | var preview = f.service.preview(f.request()); |
|---|
| | | assertTrue(preview.isCanExecute()); |
|---|
| | | assertEquals(2, preview.getTasks().getFirst().getDuration()); |
|---|
| | | assertFalse(preview.getTasks().getLast().getStartTime().isBefore(preview.getTasks().getFirst().getEndTime().plusHours(1))); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Test void canceledTasksDoNotConsumeQuantity() { |
|---|
| | | var f = new Fixture(); |
|---|
| | | f.jdbc.update("INSERT INTO schedule_task VALUES(99,1,1,1,100,5,?,?)", LocalDateTime.now().minusDays(1), LocalDateTime.now().minusHours(1)); |
|---|
| | | var preview = f.service.preview(f.request()); |
|---|
| | | assertTrue(preview.isCanExecute()); assertEquals(new BigDecimal("100"), preview.getTasks().getFirst().getQuantity()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Test void selectedChildIsScheduledBeforeParent() { |
|---|
| | | var f = new Fixture(); |
|---|
| | | f.orders.add(new MesProWorkOrderDO().setId(2L).setCode("CHILD").setParentId(1L).setStatus(1).setType(1) |
|---|
| | | .setRouteId(100L).setProductId(1000L).setQuantity(BigDecimal.TEN)); |
|---|
| | | var request = f.request(); request.setWorkOrderIds(List.of(1L, 2L)); |
|---|
| | | var preview = f.service.preview(request); |
|---|
| | | assertTrue(preview.isCanExecute()); |
|---|
| | | assertEquals(2L, preview.getTasks().getFirst().getWorkOrderId()); |
|---|
| | | assertFalse(preview.getTasks().get(2).getStartTime().isBefore(preview.getTasks().get(1).getEndTime())); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Test void unselectedUnfinishedChildAndMultipleOutputsAreBlocked() { |
|---|
| | | var f = new Fixture(); |
|---|
| | | f.orders.add(new MesProWorkOrderDO().setId(2L).setCode("CHILD").setParentId(1L).setStatus(1).setType(1)); |
|---|
| | | assertFalse(f.service.preview(f.request()).isCanExecute()); |
|---|
| | | f.orders.removeLast(); f.processes.getFirst().setOutputItemId("1,2"); |
|---|
| | | assertFalse(f.service.preview(f.request()).isCanExecute()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | @Test void customerPermissionsAreCheckedBeforeShowingOrderData() { |
|---|
| | | var f = new Fixture(); f.orders.getFirst().setClientId(99L); |
|---|
| | | f.set("customerApi", stub(CrmCustomerApi.class, (p,m,a) -> List.of(10L))); |
|---|
| | | var preview = f.service.preview(f.request()); |
|---|
| | | assertFalse(preview.isCanExecute()); assertNull(preview.getOrders().getFirst().getWorkOrderCode()); |
|---|
| | | } |
|---|
| | | |
|---|
| | | private static <T> T stub(Class<T> type, InvocationHandler handler) { |
|---|
| | | return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, (proxy, method, args) -> { |
|---|
| | | if (method.getDeclaringClass() == Object.class) { |
|---|
| | | return switch (method.getName()) { |
|---|
| | | case "toString" -> type.getSimpleName() + "Stub"; |
|---|
| | | case "hashCode" -> System.identityHashCode(proxy); |
|---|
| | | case "equals" -> proxy == args[0]; |
|---|
| | | default -> throw new AssertionError(method.getName()); |
|---|
| | | }; |
|---|
| | | } |
|---|
| | | return handler.invoke(proxy, method, args); |
|---|
| | | })); |
|---|
| | | } |
|---|
| | | |
|---|
| | | static class Fixture { |
|---|
| | | final JdbcTemplate jdbc; |
|---|
| | | final MesProBatchScheduleService service = new MesProBatchScheduleService(); |
|---|
| | | final MesProBatchScheduleService proxy; |
|---|
| | | final AtomicInteger creates = new AtomicInteger(); |
|---|
| | | int failAt; |
|---|
| | | final List<MesProWorkOrderDO> orders = new ArrayList<>(List.of(new MesProWorkOrderDO().setId(1L).setCode("WO-1") |
|---|
| | | .setName("娴嬭瘯鐢熶骇宸ュ崟").setStatus(1).setType(1).setRouteId(100L).setProductId(1000L).setQuantity(new BigDecimal("100")))); |
|---|
| | | final List<MesProWorkOrderProcessDO> processes = new ArrayList<>(List.of( |
|---|
| | | new MesProWorkOrderProcessDO().setProcessId(1L).setSort(1), new MesProWorkOrderProcessDO().setProcessId(2L).setSort(2))); |
|---|
| | | final List<MesDvMachineryDO> machines = new ArrayList<>(List.of( |
|---|
| | | new MesDvMachineryDO().setId(10L).setName("璁惧A").setStatus(1).setProductionEfficiency(BigDecimal.valueOf(100)), |
|---|
| | | new MesDvMachineryDO().setId(20L).setName("璁惧B").setStatus(1).setProductionEfficiency(BigDecimal.valueOf(100)))); |
|---|
| | | |
|---|
| | | Fixture() { |
|---|
| | | var source = new DriverManagerDataSource("jdbc:h2:mem:schedule_"+UUID.randomUUID()+";DB_CLOSE_DELAY=-1;LOCK_TIMEOUT=10000", "sa", ""); |
|---|
| | | jdbc = new JdbcTemplate(source); |
|---|
| | | jdbc.execute("CREATE TABLE schedule_mutex(id BIGINT PRIMARY KEY)"); jdbc.update("INSERT INTO schedule_mutex VALUES(1)"); |
|---|
| | | jdbc.execute("CREATE TABLE schedule_order(id BIGINT PRIMARY KEY, scheduled DECIMAL(14,2))"); jdbc.update("INSERT INTO schedule_order VALUES(1,0)"); |
|---|
| | | jdbc.execute("CREATE TABLE schedule_task(id BIGINT PRIMARY KEY, wo BIGINT, process BIGINT, station BIGINT, qty DECIMAL(14,2), status INT, starts TIMESTAMP, ends TIMESTAMP)"); |
|---|
| | | var guard = new MesProScheduleGuardService() { |
|---|
| | | @Override public void lock() { jdbc.queryForList("SELECT id FROM schedule_mutex ORDER BY id FOR UPDATE"); } |
|---|
| | | @Override public Map<Long, Set<Long>> machineIdsByStation() { return Map.of(1L, Set.of(10L), 2L, Set.of(20L)); } |
|---|
| | | }; |
|---|
| | | set("guard", guard); |
|---|
| | | set("workOrderMapper", stub(MesProWorkOrderMapper.class, (p, m, a) -> switch (m.getName()) { |
|---|
| | | case "selectByIds" -> orders.stream().filter(order -> ((Collection<?>)a[0]).contains(order.getId())).toList(); |
|---|
| | | case "lockScheduleOrders" -> { jdbc.queryForList("SELECT id FROM schedule_order ORDER BY id FOR UPDATE"); yield orders; } |
|---|
| | | case "selectList" -> orders.stream().filter(order -> Objects.equals(order.getParentId(), a[1])).toList(); |
|---|
| | | case "updateById" -> { var o = (MesProWorkOrderDO)a[0]; yield jdbc.update("UPDATE schedule_order SET scheduled=? WHERE id=?", o.getQuantityScheduled(), o.getId()); } |
|---|
| | | default -> throw new AssertionError(m.getName()); |
|---|
| | | })); |
|---|
| | | set("taskMapper", stub(MesProTaskMapper.class, (p, m, a) -> switch (m.getName()) { |
|---|
| | | case "selectSchedulingTasks" -> readTasks().stream().filter(t -> t.getStatus()!=4 && t.getStatus()!=5).toList(); |
|---|
| | | case "selectListByWorkOrderIds" -> readTasks().stream().filter(t -> ((Collection<?>)a[0]).contains(t.getWorkOrderId())).toList(); |
|---|
| | | default -> throw new AssertionError(m.getName()); |
|---|
| | | })); |
|---|
| | | set("workstationService", stub(MesMdWorkstationService.class, (p,m,a) -> List.of( |
|---|
| | | new MesMdWorkstationDO().setId(1L).setName("宸ヤ綔绔橝").setProcessId(1L).setStatus(0), |
|---|
| | | new MesMdWorkstationDO().setId(2L).setName("宸ヤ綔绔橞").setProcessId(2L).setStatus(0)))); |
|---|
| | | set("machineryMapper", stub(MesDvMachineryMapper.class, (p,m,a) -> machines)); |
|---|
| | | set("customerApi", stub(CrmCustomerApi.class, (p,m,a) -> null)); |
|---|
| | | set("holidayService", stub(MesCalHolidayService.class, (p,m,a) -> List.of())); |
|---|
| | | set("workOrderProcessService", stub(MesProWorkOrderProcessService.class, (p,m,a) -> processes)); |
|---|
| | | var quantities = new MesProScheduleQuantityService(); |
|---|
| | | ReflectionTestUtils.setField(quantities, "workOrderProcessService", stub(MesProWorkOrderProcessService.class, (p,m,a) -> processes)); |
|---|
| | | ReflectionTestUtils.setField(guard, "quantityService", quantities); |
|---|
| | | ReflectionTestUtils.setField(guard, "taskMapper", stub(MesProTaskMapper.class, (p,m,a) -> switch (m.getName()) { |
|---|
| | | case "selectListByWorkOrderId" -> readTasks().stream().filter(t -> Objects.equals(t.getWorkOrderId(), a[0])).toList(); |
|---|
| | | case "selectSchedulingTasks" -> readTasks().stream().filter(t -> t.getStatus()!=4 && t.getStatus()!=5).toList(); |
|---|
| | | default -> throw new AssertionError(m.getName()); |
|---|
| | | })); |
|---|
| | | set("routeService", stub(MesProRouteService.class, (p,m,a) -> new MesProRouteDO().setId(100L).setName("娴嬭瘯璺嚎").setStatus(0))); |
|---|
| | | set("processService", stub(MesProProcessService.class, (p,m,a) -> m.getName().equals("getProcess") |
|---|
| | | ? new MesProProcessDO().setId((Long)a[0]).setName("宸ュ簭"+a[0]).setStatus(0) : null)); |
|---|
| | | set("itemService", stub(MesMdItemService.class, (p,m,a) -> new MesMdItemDO().setId(1000L).setName("娴嬭瘯浜у搧").setStatus(0))); |
|---|
| | | set("taskService", stub(MesProTaskService.class, (p,m,a) -> { |
|---|
| | | assertEquals("createTask", m.getName()); |
|---|
| | | int number = creates.incrementAndGet(); |
|---|
| | | if (number == failAt) throw new IllegalStateException("妯℃嫙鍙傛暟蹇収鍐欏叆澶辫触"); |
|---|
| | | var task = (MesProTaskSaveReqVO)a[0]; |
|---|
| | | guard.validate(orders.stream().filter(order -> Objects.equals(order.getId(), task.getWorkOrderId())).findFirst().orElseThrow(), |
|---|
| | | new MesProTaskDO().setWorkOrderId(task.getWorkOrderId()).setRouteId(task.getRouteId()).setProcessId(task.getProcessId()) |
|---|
| | | .setWorkstationId(task.getWorkstationId()).setQuantity(task.getQuantity()).setStartTime(task.getStartTime()).setEndTime(task.getEndTime()), null); |
|---|
| | | jdbc.update("INSERT INTO schedule_task VALUES(?,?,?,?,?,?,?,?)", number, task.getWorkOrderId(), task.getProcessId(), |
|---|
| | | task.getWorkstationId(), task.getQuantity(), 0, task.getStartTime(), task.getEndTime()); |
|---|
| | | return (long)number; |
|---|
| | | })); |
|---|
| | | var factory = new ProxyFactory(service); factory.setProxyTargetClass(true); |
|---|
| | | factory.addAdvice(new TransactionInterceptor(new DataSourceTransactionManager(source), new AnnotationTransactionAttributeSource())); |
|---|
| | | proxy = (MesProBatchScheduleService)factory.getProxy(); |
|---|
| | | } |
|---|
| | | void set(String field, Object value) { ReflectionTestUtils.setField(service, field, value); } |
|---|
| | | int taskCount() { return jdbc.queryForObject("SELECT COUNT(*) FROM schedule_task", Integer.class); } |
|---|
| | | BigDecimal scheduledQuantity() { return jdbc.queryForObject("SELECT scheduled FROM schedule_order WHERE id=1", BigDecimal.class); } |
|---|
| | | List<MesProTaskDO> readTasks() { return jdbc.query("SELECT * FROM schedule_task ORDER BY id", (row,n) -> new MesProTaskDO() |
|---|
| | | .setId(row.getLong("id")).setWorkOrderId(row.getLong("wo")).setProcessId(row.getLong("process")) |
|---|
| | | .setWorkstationId(row.getLong("station")).setQuantity(row.getBigDecimal("qty")).setStatus(row.getInt("status")) |
|---|
| | | .setStartTime(row.getTimestamp("starts").toLocalDateTime()).setEndTime(row.getTimestamp("ends").toLocalDateTime())); } |
|---|
| | | MesProBatchScheduleReqVO request() { var r = new MesProBatchScheduleReqVO(); r.setWorkOrderIds(List.of(1L)); |
|---|
| | | r.setStartTime(LocalDate.now(ZoneId.of("Asia/Shanghai")).plusDays(1).atTime(9,0)); return r; } |
|---|
| | | MesProBatchScheduleReqVO confirmable() { var r = request(); var p = service.preview(r); assertTrue(p.isCanExecute(), p.getOrders().toString()); |
|---|
| | | r.setPreviewHash(p.getPreviewHash()); r.setPreviewTime(p.getPreviewTime()); r.setAllowLate(true); return r; } |
|---|
| | | } |
|---|
| | | } |
|---|
