package com.qianwen.smartman.modules.fms.service.impl;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.google.common.collect.Lists;
import com.qianwen.core.log.exception.ServiceException;
import com.qianwen.core.mp.base.BaseServiceImpl;
import com.qianwen.core.mp.support.Condition;
import com.qianwen.core.mp.support.Query;
import com.qianwen.core.tool.utils.DateUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.common.constant.DateConstant;
import com.qianwen.smartman.common.constant.FmsConstant;
import com.qianwen.smartman.common.utils.Lambda;
import com.qianwen.smartman.common.utils.ListUtils;
import com.qianwen.smartman.common.utils.MessageUtils;
import com.qianwen.smartman.modules.cps.convert.CraftRoutingConvert;
import com.qianwen.smartman.modules.cps.dto.CraftVersionDTO;
import com.qianwen.smartman.modules.cps.entity.CommonGroup;
import com.qianwen.smartman.modules.cps.entity.CraftVersionLine;
import com.qianwen.smartman.modules.cps.entity.ProductionCraftProcess;
import com.qianwen.smartman.modules.cps.entity.ProductionCraftProcessRelatedTool;
import com.qianwen.smartman.modules.cps.entity.Tray;
import com.qianwen.smartman.modules.cps.entity.TrayFixture;
import com.qianwen.smartman.modules.cps.enums.ProductionCraftStatusEnum;
import com.qianwen.smartman.modules.cps.service.ICommonGroupService;
import com.qianwen.smartman.modules.cps.service.ICraftRoutingService;
import com.qianwen.smartman.modules.cps.service.ICraftVersionLineService;
import com.qianwen.smartman.modules.cps.service.IProductionCraftProcessRelatedFixtureService;
import com.qianwen.smartman.modules.cps.service.IProductionCraftProcessRelatedToolService;
import com.qianwen.smartman.modules.cps.service.IProductionCraftProcessService;
import com.qianwen.smartman.modules.cps.service.ITrayFixtureService;
import com.qianwen.smartman.modules.cps.service.ITrayService;
import com.qianwen.smartman.modules.cps.vo.CraftRoutingDetailVO;
import com.qianwen.smartman.modules.cps.vo.CraftRoutingVO;
import com.qianwen.smartman.modules.cps.vo.IdsVO;
import com.qianwen.smartman.modules.fms.convert.FmsOrderConvert;
import com.qianwen.smartman.modules.fms.convert.FmsOrderProcessConvert;
import com.qianwen.smartman.modules.fms.convert.FmsOrderProcessFixtureConvert;
import com.qianwen.smartman.modules.fms.convert.FmsOrderProcessToolConvert;
import com.qianwen.smartman.modules.fms.entity.FmsInstructionRecord;
import com.qianwen.smartman.modules.fms.entity.FmsOrder;
import com.qianwen.smartman.modules.fms.entity.FmsOrderProcess;
import com.qianwen.smartman.modules.fms.entity.FmsOrderProcessFixture;
import com.qianwen.smartman.modules.fms.entity.FmsOrderProcessTool;
import com.qianwen.smartman.modules.fms.enums.FmsOrderEnum;
import com.qianwen.smartman.modules.fms.enums.OrderStatusEnum;
import com.qianwen.smartman.modules.fms.mapper.FmsOrderMapper;
import com.qianwen.smartman.modules.fms.service.IFmsInstructionRecordService;
import com.qianwen.smartman.modules.fms.service.IFmsOrderProcessFixtureService;
import com.qianwen.smartman.modules.fms.service.IFmsOrderProcessService;
import com.qianwen.smartman.modules.fms.service.IFmsOrderProcessToolService;
import com.qianwen.smartman.modules.fms.service.IFmsOrderService;
import com.qianwen.smartman.modules.fms.vo.FmsOrderDetailVO;
import com.qianwen.smartman.modules.fms.vo.FmsOrderProductionStatVO;
import com.qianwen.smartman.modules.fms.vo.FmsOrderQueryVO;
import com.qianwen.smartman.modules.fms.vo.FmsOrderStatusStatVO;
import com.qianwen.smartman.modules.fms.vo.FmsOrderVO;
import com.qianwen.smartman.modules.system.entity.Dict;
import com.qianwen.smartman.modules.system.service.ICodeGeneratorService;
import com.qianwen.smartman.modules.system.service.IDictService;
import com.qianwen.smartman.modules.system.service.IParamService;
import com.qianwen.smartman.modules.tpm.enums.MetaTypeEnum;

import cn.hutool.core.bean.BeanUtil;

@Service
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/fms/service/impl/FmsOrderServiceImpl.class */
public class FmsOrderServiceImpl extends BaseServiceImpl<FmsOrderMapper, FmsOrder> implements IFmsOrderService {
    private static final Logger log = LoggerFactory.getLogger(FmsOrderServiceImpl.class);
    private final IDictService dictService;
    private final ICraftRoutingService craftRoutingService;
    private final IFmsOrderProcessService fmsOrderProcessService;
    private final IProductionCraftProcessService productionCraftProcessService;
    private final IProductionCraftProcessRelatedFixtureService productionCraftProcessRelatedFixtureService;
    private final IProductionCraftProcessRelatedToolService productionCraftProcessRelatedToolService;
    private final IFmsOrderProcessFixtureService fmsOrderProcessFixtureService;
    private final IFmsOrderProcessToolService fmsOrderProcessToolService;
    private final ICodeGeneratorService codeGeneratorService;
    private final ITrayFixtureService trayFixtureService;
    private final ITrayService trayService;
    private final ICraftVersionLineService craftVersionLineService;
    private final ICommonGroupService commonGroupService;
    private final String[] emptyRange = {"", ""};
    private final IFmsInstructionRecordService fmsInstructionRecordService;
    private final IParamService paramService;

    public FmsOrderServiceImpl(final IDictService dictService, final ICraftRoutingService craftRoutingService, final IFmsOrderProcessService fmsOrderProcessService, final IProductionCraftProcessService productionCraftProcessService, final IProductionCraftProcessRelatedFixtureService productionCraftProcessRelatedFixtureService, final IProductionCraftProcessRelatedToolService productionCraftProcessRelatedToolService, final IFmsOrderProcessFixtureService fmsOrderProcessFixtureService, final IFmsOrderProcessToolService fmsOrderProcessToolService, final ICodeGeneratorService codeGeneratorService, final ITrayFixtureService trayFixtureService, final ITrayService trayService, final ICraftVersionLineService craftVersionLineService, final ICommonGroupService commonGroupService, final IFmsInstructionRecordService fmsInstructionRecordService, final IParamService paramService) {
        this.dictService = dictService;
        this.craftRoutingService = craftRoutingService;
        this.fmsOrderProcessService = fmsOrderProcessService;
        this.productionCraftProcessService = productionCraftProcessService;
        this.productionCraftProcessRelatedFixtureService = productionCraftProcessRelatedFixtureService;
        this.productionCraftProcessRelatedToolService = productionCraftProcessRelatedToolService;
        this.fmsOrderProcessFixtureService = fmsOrderProcessFixtureService;
        this.fmsOrderProcessToolService = fmsOrderProcessToolService;
        this.codeGeneratorService = codeGeneratorService;
        this.trayFixtureService = trayFixtureService;
        this.trayService = trayService;
        this.craftVersionLineService = craftVersionLineService;
        this.commonGroupService = commonGroupService;
        this.fmsInstructionRecordService = fmsInstructionRecordService;
        this.paramService = paramService;
    }

    @Override // org.springblade.modules.fms.service.IFmsOrderService
    public IPage<FmsOrderVO> getPageOrder(FmsOrderQueryVO fmsOrderQueryVO, Query query) {
        String[] startTimeRange = (String[]) Optional.ofNullable(fmsOrderQueryVO.getPlanStartTime()).map(item -> {
            return Func.split(item, ",");
        }).orElse(this.emptyRange);
        String[] endTimeRange = (String[]) Optional.ofNullable(fmsOrderQueryVO.getPlanEndTime()).map(item2 -> {
            return Func.split(item2, ",");
        }).orElse(this.emptyRange);
        Date startTimeDateBegin = null;
        Date startTimeDateFinish = null;
        Date endTimeDateBegin = null;
        Date endTimeDateFinish = null;
        if (Func.isNotEmpty(startTimeRange[0])) {
            startTimeDateBegin = DateUtil.parse(startTimeRange[0], DateConstant.PATTERN_DATE_TIME);
            startTimeDateFinish = DateUtil.parse(startTimeRange[1], DateConstant.PATTERN_DATE_TIME);
        }
        if (Func.isNotEmpty(endTimeRange[0])) {
            endTimeDateBegin = DateUtil.parse(endTimeRange[0], DateConstant.PATTERN_DATE_TIME);
            endTimeDateFinish = DateUtil.parse(endTimeRange[1], DateConstant.PATTERN_DATE_TIME);
        }
        LambdaQueryWrapper<FmsOrder> fmsOrderLambdaQueryWrapper =Wrappers.<FmsOrder>lambdaQuery()
        		.eq(Func.isNotEmpty(fmsOrderQueryVO.getOrderType()), FmsOrder::getOrderType, fmsOrderQueryVO.getOrderType())
        		.between(Func.isNotEmpty(fmsOrderQueryVO.getPlanStartTime()), FmsOrder::getPlanStartTime, startTimeDateBegin, startTimeDateFinish)
        		.between(Func.isNotEmpty(fmsOrderQueryVO.getPlanEndTime()), FmsOrder::getPlanEndTime, endTimeDateBegin, endTimeDateFinish)
        		.likeRight(Func.isNotEmpty(fmsOrderQueryVO.getCode()), FmsOrder::getCode, fmsOrderQueryVO.getCode())
        		.in(Func.isNotEmpty(fmsOrderQueryVO.getOrderStatus()), FmsOrder::getOrderStatus, Lists.newArrayList((Object[])Func.split(fmsOrderQueryVO.getOrderStatus(), ",")));
        /*
        LambdaQueryWrapper<FmsOrder> fmsOrderLambdaQueryWrapper = Wrappers.lambdaQuery().eq(Func.isNotEmpty(fmsOrderQueryVO.getOrderType()), (v0) -> {
            return v0.getOrderType();
        }, fmsOrderQueryVO.getOrderType()).between(Func.isNotEmpty(fmsOrderQueryVO.getPlanStartTime()), (v0) -> {
            return v0.getPlanStartTime();
        }, startTimeDateBegin, startTimeDateFinish).between(Func.isNotEmpty(fmsOrderQueryVO.getPlanEndTime()), (v0) -> {
            return v0.getPlanEndTime();
        }, endTimeDateBegin, endTimeDateFinish).likeRight(Func.isNotEmpty(fmsOrderQueryVO.getCode()), (v0) -> {
            return v0.getCode();
        }, fmsOrderQueryVO.getCode()).in(Func.isNotEmpty(fmsOrderQueryVO.getOrderStatus()), (v0) -> {
            return v0.getOrderStatus();
        }, Lists.newArrayList(Func.split(fmsOrderQueryVO.getOrderStatus(), ",")));*/
        IPage<FmsOrder> fmsOrderIPage = page(Condition.getPage(query), fmsOrderLambdaQueryWrapper);
        List<FmsOrderVO> fmsOrderVOList = wrapper(fmsOrderIPage.getRecords());
        Page<FmsOrderVO> page = new Page<>(fmsOrderIPage.getCurrent(), fmsOrderIPage.getSize(), fmsOrderIPage.getTotal());
        page.setRecords(fmsOrderVOList);
        return page;
    }

    public List<FmsOrderVO> wrapper(List<FmsOrder> orders) {
        List<FmsOrderVO> fmsOrderVOList = FmsOrderConvert.INSTANCE.convert(orders);
        Map<String, Dict> fmsOrderTypeMap = this.dictService.getList(FmsOrderEnum.FMS_ORDER_TYPE.getCode()).stream().collect(Collectors.toMap((v0) -> {
            return v0.getDictKey();
        }, v -> {
            return v;
        }));
        Map<String, Dict> fmsOrderStatusMap = this.dictService.getList(FmsOrderEnum.FMS_ORDER_STATUS.getCode()).stream().collect(Collectors.toMap((v0) -> {
            return v0.getDictKey();
        }, v2 -> {
            return v2;
        }));
        fmsOrderVOList.forEach(fmsOrderVO -> {
            fmsOrderVO.setOrderStatusLabel((String) Optional.ofNullable(fmsOrderStatusMap.get(fmsOrderVO.getOrderStatus())).map((v0) -> {
                return v0.getDictValue();
            }).orElse(""));
            fmsOrderVO.setOrderTypeLabel((String) Optional.ofNullable(fmsOrderTypeMap.get(fmsOrderVO.getOrderType())).map((v0) -> {
                return v0.getDictValue();
            }).orElse(""));
        });
        return fmsOrderVOList;
    }

    public FmsOrderVO wrapper(FmsOrder order) {
        List<FmsOrderVO> fmsOrderVOS = wrapper(Collections.singletonList(order));
        return fmsOrderVOS.get(0);
    }

    @Override // org.springblade.modules.fms.service.IFmsOrderService
    public List<CraftRoutingDetailVO> listCraft() {
        List<CraftRoutingDetailVO> craftRoutingDetailVOS = new ArrayList<>();
        List<CraftRoutingVO> craftRoutingVOS = CraftRoutingConvert.INSTANCE.convert(this.craftRoutingService.list());
        craftRoutingVOS.forEach(craftRoutingVO -> {
            CraftRoutingDetailVO craftRoutingDetailVO = this.craftRoutingService.detailCraft(craftRoutingVO.getId());
            craftRoutingDetailVOS.addAll(filterCraft(craftRoutingDetailVO));
        });
        return craftRoutingDetailVOS;
    }

    @Override // org.springblade.modules.fms.service.IFmsOrderService
    public List<CraftRoutingDetailVO> listProductionCraft(String productionId) {
        List<CraftRoutingDetailVO> craftRoutingDetailVOS = new ArrayList<>();
        CraftRoutingDetailVO craftRoutingDetailVO = this.craftRoutingService.getCraftByProduction(Long.valueOf(productionId));
        if (Func.isEmpty(craftRoutingDetailVO)) {
            return craftRoutingDetailVOS;
        }
        List<CraftRoutingDetailVO> craftRoutingDetailVOS2 = filterCraft(craftRoutingDetailVO);
        return craftRoutingDetailVOS2;
    }

    public List<CraftRoutingDetailVO> filterCraft(CraftRoutingDetailVO craftRoutingDetailVO) {
        List<CraftRoutingDetailVO> craftRoutingDetailVOS = new ArrayList<>();
        List<CraftVersionDTO> versionList = craftRoutingDetailVO.getDtos();
        List<CraftVersionDTO> versionDTOS = versionList.stream().filter(versionDTO -> {
        	List<CraftVersionLine> versionLines = this.craftVersionLineService.list(Lambda.eq(CraftVersionLine::getVersionId, versionDTO.getId()));
            List<Long> groupIds = versionLines.stream().map(CraftVersionLine::getGroupId).collect(Collectors.toList());
        	/*
            List<CraftVersionLine> versionLines = this.craftVersionLineService.list(Lambda.eq((v0) -> {
                return v0.getVersionId();
            }, versionDTO.getId()));
            List<Long> groupIds = (List) versionLines.stream().map((v0) -> {
                return v0.getGroupId();
            }).collect(Collectors.toList());
            */
            /*
            if (Func.isNotEmpty(groupIds)) {
                return this.commonGroupService.list((Wrapper) Wrappers.query().lambda().in((v0) -> {
                    return v0.getId();
                }, groupIds)).stream().anyMatch(commonGroup -> {
                    return Objects.equals(commonGroup.getGroupTag(), FmsOrderEnum.FMS_BELTLINE.getCode());
                });
            }
            return false;*/
            return Func.isNotEmpty(groupIds) ? this.commonGroupService.list(Wrappers.<CommonGroup>query().lambda().in(CommonGroup::getId, groupIds)).stream().anyMatch(commonGroup -> {
                return Objects.equals(commonGroup.getGroupTag(), FmsOrderEnum.FMS_BELTLINE.getCode());
            }) : false;
        }).collect(Collectors.toList());
        craftRoutingDetailVO.setDtos(versionDTOS.stream().filter(versionDTO2 -> {
            return versionDTO2.getEditionStatus().equals(ProductionCraftStatusEnum.FINALIZED.getStatus());
        }).collect(Collectors.toList()));
        craftRoutingDetailVOS.add(craftRoutingDetailVO);
        return craftRoutingDetailVOS;
    }

    @Override // org.springblade.modules.fms.service.IFmsOrderService
    @Transactional
    public FmsOrderDetailVO save(FmsOrderVO fmsOrderVO) {
        FmsOrder fmsOrder = FmsOrderConvert.INSTANCE.convert(fmsOrderVO);
        if (Func.isBlank(fmsOrderVO.getCode())) {
            String code = this.codeGeneratorService.getGeneratorCode(fmsOrder, MetaTypeEnum.FMS_ORDER.getCode());
            log.info("工单编码规则生成的code:{}", code + "," + code.length());
            fmsOrder.setCode(code);
        }
        if (Func.isEmpty(fmsOrderVO.getId())) {
            fmsOrder.setOrderStatus(Integer.valueOf(OrderStatusEnum.WAIT_PUBLISH.getValue()));
            ((FmsOrderMapper) this.baseMapper).insert(fmsOrder);
            FmsOrderVO orderVO = wrapper(fmsOrder);
            FmsOrderDetailVO fmsOrderDetailVO = FmsOrderConvert.INSTANCE.convertToDetail(fmsOrder);
            fmsOrderDetailVO.setOrderStatusLabel(orderVO.getOrderStatusLabel());
            fmsOrderDetailVO.setOrderTypeLabel(orderVO.getOrderTypeLabel());
            return saveProcess(fmsOrder, fmsOrderDetailVO, fmsOrderVO);
        }
        FmsOrder fmsOrderOld = (FmsOrder) ((FmsOrderMapper) this.baseMapper).selectOne(Lambda.eq((v0) -> {
            return v0.getId();
        }, fmsOrder.getId()));
        ((FmsOrderMapper) this.baseMapper).updateById(fmsOrder);
        List<FmsOrderProcess> fmsOrderProcessList = this.fmsOrderProcessService.list(Wrappers.<FmsOrderProcess>query().lambda().eq(FmsOrderProcess::getOrderId, fmsOrderVO.getId()));
        /*
        List<FmsOrderProcess> fmsOrderProcessList = this.fmsOrderProcessService.list((Wrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getOrderId();
        }, fmsOrderVO.getId()));*/
        FmsOrderVO orderVO2 = wrapper(fmsOrder);
        FmsOrderDetailVO fmsOrderDetailVO2 = FmsOrderConvert.INSTANCE.convertToDetail(fmsOrder);
        fmsOrderDetailVO2.setOrderStatusLabel(orderVO2.getOrderStatusLabel());
        fmsOrderDetailVO2.setOrderTypeLabel(orderVO2.getOrderTypeLabel());
        if (fmsOrder.getCraftVersionId().equals(fmsOrderOld.getCraftVersionId())) {
            fmsOrderDetailVO2.setProcessList(fmsOrderProcessList);
            return fmsOrderDetailVO2;
        }
        this.fmsOrderProcessService.remove(Lambda.eq((v0) -> {
            return v0.getOrderId();
        }, fmsOrderVO.getId()));
        this.fmsOrderProcessFixtureService.remove(Lambda.in((v0) -> {
            return v0.getOrderProcessId();
        }, fmsOrderProcessList.stream().map((v0) -> {
            return v0.getId();
        }).collect(Collectors.toList())));
        this.fmsOrderProcessToolService.remove(Lambda.in((v0) -> {
            return v0.getOrderProcessId();
        },  fmsOrderProcessList.stream().map((v0) -> {
            return v0.getId();
        }).collect(Collectors.toList())));
        return saveProcess(fmsOrder, fmsOrderDetailVO2, fmsOrderVO);
    }

    @Transactional
    public FmsOrderDetailVO saveProcess(FmsOrder fmsOrder, FmsOrderDetailVO fmsOrderDetailVO, FmsOrderVO fmsOrderVO) {
        List<ProductionCraftProcess> productionCraftProcesses = this.productionCraftProcessService.listProcessByVersion(fmsOrderVO.getCraftVersionId());
        List<FmsOrderProcess> fmsOrderProcesses = new ArrayList<>();
        productionCraftProcesses.forEach(productionCraftProcess -> {
            FmsOrderProcess fmsOrderProcess = FmsOrderProcessConvert.INSTANCE.processToConvert(productionCraftProcess);
            fmsOrderProcess.setOrderId(fmsOrder.getId());
            this.fmsOrderProcessService.save(fmsOrderProcess);
            fmsOrderProcesses.add(fmsOrderProcess);
            List<FmsOrderProcessFixture> fmsOrderProcessFixtureList = FmsOrderProcessFixtureConvert.INSTANCE.fixtureToConvert(this.productionCraftProcessRelatedFixtureService.getProductionCraftProcessRelatedFixtureListByProcessId(productionCraftProcess.getId()));
            fmsOrderProcessFixtureList.forEach(fmsOrderProcessFixture -> {
                fmsOrderProcessFixture.setOrderId(fmsOrder.getId());
                fmsOrderProcessFixture.setOrderProcessId(fmsOrderProcess.getId());
                TrayFixture trayFixture = this.trayFixtureService.getOne(Wrappers.<TrayFixture>query().lambda().eq(TrayFixture::getFixId, fmsOrderProcessFixture.getFixtureId()));
                Tray tray = this.trayService.getOne( Wrappers.<Tray>query().lambda().eq(Tray::getId, trayFixture.getTrayId()));
                fmsOrderProcessFixture.setTrayId(tray.getId());
                fmsOrderProcessFixture.setTrayCode(tray.getCode());
            });
            this.fmsOrderProcessFixtureService.saveBatch(fmsOrderProcessFixtureList);
            List<FmsOrderProcessTool> fmsOrderProcessToolList = Lists.newArrayList();
            List<ProductionCraftProcessRelatedTool> productionCraftProcessRelatedToolList = this.productionCraftProcessRelatedToolService.list(Wrappers.<ProductionCraftProcessRelatedTool>lambdaQuery().eq(ProductionCraftProcessRelatedTool::getVersionProcessId, productionCraftProcess.getId()));
            productionCraftProcessRelatedToolList.forEach(x -> {
                FmsOrderProcessTool fmsOrderProcessTool = FmsOrderProcessToolConvert.INSTANCE.toolToConvert(x);
                fmsOrderProcessTool.setOrderProcessId(fmsOrderProcess.getId());
                fmsOrderProcessToolList.add(fmsOrderProcessTool);
            });
            this.fmsOrderProcessToolService.saveBatch(fmsOrderProcessToolList);
        });
        fmsOrderDetailVO.setProcessList(fmsOrderProcesses);
        return fmsOrderDetailVO;
    }

    @Override // org.springblade.modules.fms.service.IFmsOrderService
    @Transactional
    public void saveWorkstation(FmsOrderDetailVO fmsOrderDetailVO) {
        List<FmsOrderProcess> processList = fmsOrderDetailVO.getProcessList();
        processList.forEach(fmsOrderProcess -> {
        	this.fmsOrderProcessService.update(Wrappers.<FmsOrderProcess>update().lambda()
        			.eq(FmsOrderProcess::getId, fmsOrderProcess.getId())
        			.set(FmsOrderProcess::getWorkStationId, fmsOrderProcess.getWorkStationId())
        			.set(FmsOrderProcess::getWorkStationName, fmsOrderProcess.getWorkStationName()));
        			/*
            this.fmsOrderProcessService.update((Wrapper) ((LambdaUpdateWrapper) ((LambdaUpdateWrapper) Wrappers.update().lambda().eq((v0) -> {
                return v0.getId();
            }, fmsOrderProcess.getId())).set((v0) -> {
                return v0.getWorkStationId();
            }, fmsOrderProcess.getWorkStationId())).set((v0) -> {
                return v0.getWorkStationName();
            }, fmsOrderProcess.getWorkStationName()));*/
        });
    }

    @Override // org.springblade.modules.fms.service.IFmsOrderService
    public FmsOrderStatusStatVO orderStatistics() {
    	List<Map<String, Object>> statusList = listMaps(new QueryWrapper<FmsOrder>()
    	        .select(new String[] { Lambda.getName(FmsOrder::getOrderStatus), "count(1) as \"count\"" }).lambda()
    	        .groupBy(FmsOrder::getOrderStatus));
    	/*
        List<Map<String, Object>> statusList = listMaps((Wrapper) new QueryWrapper().select(new String[]{Lambda.getName((v0) -> {
            return v0.getOrderStatus();
        }), "count(1) as \"count\""}).lambda().groupBy((v0) -> {
            return v0.getOrderStatus();
        }));*/
    	
    	long count = count(Lambda.eq(FmsOrder::getOrderStatus, Integer.valueOf(OrderStatusEnum.FINISHED.getValue())).isNotNull(FmsOrder::getOrderStatus)
    	        .between(FmsOrder::getEndTime, LocalDate.now(), LocalDateTime.now()));
    	
    	/*
        long count = count((Wrapper) ((ExtraLambdaQueryWrapper) Lambda.eq((v0) -> {
            return v0.getOrderStatus();
        }, Integer.valueOf(OrderStatusEnum.FINISHED.getValue())).isNotNull((v0) -> {
            return v0.getOrderStatus();
        })).between((v0) -> {
            return v0.getEndTime();
        }, LocalDate.now(), LocalDateTime.now()));*/
        FmsOrderStatusStatVO fmsOrderStatusStat = new FmsOrderStatusStatVO();
        fmsOrderStatusStat.setWaitPublish(getOrderStatData(statusList, OrderStatusEnum.WAIT_PUBLISH));
        fmsOrderStatusStat.setWaitMachine(getOrderStatData(statusList, OrderStatusEnum.WAIT_MACHINE));
        fmsOrderStatusStat.setMachineIng(getOrderStatData(statusList, OrderStatusEnum.MACH_ING));
        fmsOrderStatusStat.setPauseIng(getOrderStatData(statusList, OrderStatusEnum.PAUSE_ING));
        fmsOrderStatusStat.setPause(getOrderStatData(statusList, OrderStatusEnum.PAUSE));
        fmsOrderStatusStat.setTodayFinished(count);
        return fmsOrderStatusStat;
    }

    private long getOrderStatData(List<Map<String, Object>> statusList, OrderStatusEnum orderStatusEnum) {
        return Long.parseLong(String.valueOf(statusList.stream().filter(item -> {
            return String.valueOf(item.get(FmsOrder.ORDER_STATUS)).equals(String.valueOf(orderStatusEnum.getValue()));
        }).findFirst().map(item2 -> {
            return item2.get("count");
        }).orElse(0L)));
    }

    @Override // org.springblade.modules.fms.service.IFmsOrderService
    public List<FmsOrderProductionStatVO> productionStatistics(final String orderId) {
        List<Map<String, Object>> data = ((FmsOrderMapper) this.baseMapper).productionStatistics(orderId);
        return data.stream().map(item -> {
            return (FmsOrderProductionStatVO) BeanUtil.mapToBean(item, FmsOrderProductionStatVO.class, true);
        }).collect(Collectors.toList());
    }

    @Override // org.springblade.modules.fms.service.IFmsOrderService
    @Transactional(rollbackFor = {Exception.class})
    public FmsOrderVO pause(final String orderId) {
        FmsOrder fmsOrder = (FmsOrder) getById(orderId);
        if (OrderStatusEnum.MACH_ING.getValue() == fmsOrder.getOrderStatus().intValue()) {
            int online = fmsOrder.getOnlineNumber() == null ? 0 : fmsOrder.getOnlineNumber().intValue();
            int offline = fmsOrder.getOfflineNumber() == null ? 0 : fmsOrder.getOfflineNumber().intValue();
            fmsOrder.setOrderStatus(Integer.valueOf(online == offline ? OrderStatusEnum.PAUSE.getValue() : OrderStatusEnum.PAUSE_ING.getValue()));
            updateById(fmsOrder);
            return wrapper(fmsOrder);
        }
        throw new ServiceException(MessageUtils.message("fms.order.not.need.pause", new Object[0]));
    }

    @Override // org.springblade.modules.fms.service.IFmsOrderService
    @Transactional(rollbackFor = {Exception.class})
    public List<FmsOrderVO> pauseBatch(List<String> orderIds) {
        List<FmsOrderVO> list = new ArrayList<>();
        orderIds.forEach(id -> {
            FmsOrderVO pause = pause(id);
            list.add(pause);
        });
        return list;
    }

    @Override // org.springblade.modules.fms.service.IFmsOrderService
    @Transactional
    public FmsOrderVO start(final String orderId) {
        FmsOrderVO wrapper;
        synchronized (this) {
            FmsOrder fmsOrder = (FmsOrder) getById(orderId);
            int status = fmsOrder.getOrderStatus() == null ? OrderStatusEnum.WAIT_PUBLISH.getValue() : fmsOrder.getOrderStatus().intValue();
            if (status == OrderStatusEnum.WAIT_PUBLISH.getValue()) {
                throw new ServiceException(MessageUtils.message("fms.order.not.publish", new Object[0]));
            }
            if (status == OrderStatusEnum.MACH_ING.getValue()) {
                throw new ServiceException(MessageUtils.message("fms.order.has.in.mach", new Object[0]));
            }
            if (status == OrderStatusEnum.FINISHED.getValue()) {
                throw new ServiceException(MessageUtils.message("fms.order.has.finish", new Object[0]));
            }
            List<FmsOrderProcessFixture> fixtures = this.fmsOrderProcessFixtureService.getListByOrderId(fmsOrder.getId());
            List<String> trayCodeList = fixtures.stream().map((v0) -> {
                return v0.getTrayCode();
            }).collect(Collectors.toList());
            List<FmsOrder> usingOrderList = getUsingOrderByTray(trayCodeList);
            String orderCodes = (String) usingOrderList.stream().map((v0) -> {
                return v0.getCode();
            }).collect(Collectors.joining());
            if (Func.isEmpty(usingOrderList)) {
                fmsOrder.setOrderStatus(Integer.valueOf(OrderStatusEnum.MACH_ING.getValue()));
            } else if (0 == fmsOrder.getPriority().intValue()) {
                boolean hasUsing = usingOrderList.stream().anyMatch(item -> {
                    return !item.getOnlineNumber().equals(item.getOfflineNumber());
                });
                if (hasUsing) {
                    throw new ServiceException(String.format(MessageUtils.message("fms.order.start.tray.using", new Object[0]), orderCodes));
                }
                usingOrderList.forEach(order -> {
                    order.setOrderStatus(Integer.valueOf(OrderStatusEnum.PAUSE.getValue()));
                });
                fmsOrder.setOrderStatus(Integer.valueOf(OrderStatusEnum.MACH_ING.getValue()));
                updateBatchById(usingOrderList);
            } else {
                throw new ServiceException(String.format(MessageUtils.message("fms.order.start.tray.using", new Object[0]), orderCodes));
            }
            updateById(fmsOrder);
            wrapper = wrapper(fmsOrder);
        }
        return wrapper;
    }

    @Override // org.springblade.modules.fms.service.IFmsOrderService
    @Transactional(rollbackFor = {Exception.class})
    public List<FmsOrderVO> startOrders(List<String> orderIds) {
        List<FmsOrderVO> result = Lists.newArrayList();
        List<FmsOrder> toBeStartList = list(Wrappers.<FmsOrder>lambdaQuery().in(FmsOrder::getId, orderIds));
        /*
        List<FmsOrder> toBeStartList = list((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
            return v0.getId();
        }, orderIds));*/
        List<Integer> statusEnumList = Arrays.asList(Integer.valueOf(OrderStatusEnum.WAIT_MACHINE.getValue()), Integer.valueOf(OrderStatusEnum.PAUSE.getValue()), Integer.valueOf(OrderStatusEnum.PAUSE_ING.getValue()));
        if (Func.isEmpty(toBeStartList)) {
            return FmsOrderConvert.INSTANCE.convert(toBeStartList);
        }
        log.info("初始工单：{}", orderIds);
        toBeStartList = toBeStartList.stream().filter(s -> statusEnumList.contains(s.getOrderStatus())).collect(Collectors.toList());
        /*
        List<FmsOrder> toBeStartList2 = (List) toBeStartList.stream().filter(s -> {
            return statusEnumList.contains(s.getOrderStatus());
        }).collect(Collectors.toList());*/
        FmsOrder highestToBeOrder = null;
        List<FmsOrder> highList = toBeStartList.stream().filter(c -> {
            return FmsConstant.MAX_PRIORITY.equals(c.getPriority());
        }).collect(Collectors.toList());
        if (Func.isNotEmpty(highList)) {
            if (highList.size() > 1) {
                throw new ServiceException(MessageUtils.message("cps.fms.start.order.fail.has.no.zero.priority", new Object[0]));
            }
            highestToBeOrder = highList.get(0);
        }
        List<Integer> machStatus = Arrays.asList(Integer.valueOf(OrderStatusEnum.MACH_ING.getValue()), Integer.valueOf(OrderStatusEnum.PAUSE_ING.getValue()));
        List<String> toBeStartedOrderIds = toBeStartList.stream().map(s2 -> {
            return String.valueOf(s2.getId());
        }).collect(Collectors.toList());
        
        Map<Long, List<FmsOrderProcessFixture>> toBeStartedFixtureList = this.fmsOrderProcessFixtureService.getFmsOrderProcessFixtureList(Func.toLongList(toBeStartedOrderIds));
        List<FmsOrder> machOrders = list(Wrappers.<FmsOrder>lambdaQuery().in(FmsOrder::getOrderStatus, machStatus));
        /*
        List<FmsOrder> machOrders = list((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
            return v0.getOrderStatus();
        }, machStatus));*/
        dealToBeStart(orderIds, toBeStartList, toBeStartedFixtureList);
        if (Func.isEmpty(machOrders)) {
        	update(Wrappers.<FmsOrder>lambdaUpdate().in(Func.isNotEmpty(orderIds), FmsOrder::getId, Func.toLongList(orderIds))
        	          .set(FmsOrder::getOrderStatus, Integer.valueOf(OrderStatusEnum.MACH_ING.getValue()))
        	          .set(FmsOrder::getStartUpTime, LocalDateTime.now()));
        	
        	/*
            update((Wrapper) ((LambdaUpdateWrapper) Wrappers.lambdaUpdate().in(Func.isNotEmpty(orderIds), (v0) -> {
                return v0.getId();
            }, Func.toLongList(orderIds)).set((v0) -> {
                return v0.getOrderStatus();
            }, Integer.valueOf(OrderStatusEnum.MACH_ING.getValue()))).set((v0) -> {
                return v0.getStartUpTime();
            }, LocalDateTime.now()));*/
        	toBeStartList.forEach(x -> {
                FmsOrderVO fmsOrderVO = FmsOrderConvert.INSTANCE.convert(x);
                fmsOrderVO.setOrderStatus(OrderStatusEnum.MACH_ING.getValue() + "");
                result.add(fmsOrderVO);
            });
            return result;
        }
        log.info("过滤工单：{}", orderIds);
        FmsOrder highestExecutionOrder = null;
        List<FmsOrder> highestExecutionOrderList = machOrders.stream().filter(c2 -> {
            return FmsConstant.MAX_PRIORITY.equals(c2.getPriority());
        }).collect(Collectors.toList());
        if (Func.isNotEmpty(highestExecutionOrderList)) {
            highestExecutionOrder = highestExecutionOrderList.get(0);
        }
        if (highestToBeOrder != null) {
            if (highestExecutionOrder != null && !highestToBeOrder.getId().equals(highestExecutionOrder.getId())) {
                throw new ServiceException(MessageUtils.message("cps.fms.start.order.fail.has.zero.priority.to.do", new Object[0]));
            }
            dealInHasExecution(toBeStartedOrderIds, highestToBeOrder, toBeStartList, machOrders, toBeStartedFixtureList);
        } else {
            dealOrder(orderIds, machOrders, toBeStartList);
        }
        toBeStartList.forEach(x2 -> {
            FmsOrderVO fmsOrderVO = FmsOrderConvert.INSTANCE.convert(x2);
            fmsOrderVO.setOrderStatus(OrderStatusEnum.MACH_ING.getValue() + "");
            result.add(fmsOrderVO);
        });
        return result;
    }

    public void dealInHasExecution(List<String> orderIds, FmsOrder highestOrder, List<FmsOrder> tobeStartList, List<FmsOrder> machOrders, Map<Long, List<FmsOrderProcessFixture>> toBeStartedFixtureMap) {
        List<String> removeIds = new ArrayList<>();
        List<FmsOrderProcessFixture> processFixtureList = toBeStartedFixtureMap.get(highestOrder.getId());
        if (Func.isNotEmpty(processFixtureList)) {
            List<String> trayCodes = processFixtureList.stream().map((v0) -> {
                return v0.getTrayCode();
            }).distinct().collect(Collectors.toList());
            List<FmsOrder> usingOrderList = getUsingOrderByTray(trayCodes);
            if (Func.isNotEmpty(usingOrderList)) {
                usingOrderList.forEach(s -> {
                    if (OrderStatusEnum.MACH_ING.getValue() == s.getOrderStatus().intValue()) {
                        pause(String.valueOf(s.getId()));
                    }
                    removeIds.add(String.valueOf(s.getId()));
                });
            }
        }
        if (Func.isNotEmpty(removeIds)) {
            orderIds = orderIds.stream().filter(s2 -> {
                return !removeIds.contains(s2);
            }).collect(Collectors.toList());
        }
        dealOrder(orderIds, machOrders, tobeStartList);
    }

    public void dealOrder(List<String> orderIds, List<FmsOrder> machOrders, List<FmsOrder> tobeStartList) {
        List<String> removeOrderIds = new ArrayList<>();
        if (Func.isNotEmpty(orderIds)) {
            List<Long> machOrderIds = machOrders.stream().map((v0) -> {
                return v0.getId();
            }).collect(Collectors.toList());
            List<FmsOrderProcessFixture> fmsOrderProcessFixtures = this.fmsOrderProcessFixtureService.getFmsOrderProcessFixtures(Func.toLongList(orderIds));
            List<String> toBeStartTrays = fmsOrderProcessFixtures.stream().map((v0) -> {
                return v0.getTrayCode();
            }).distinct().collect(Collectors.toList());
            
            List<FmsOrderProcessFixture> fmsOrderProcessFixtures1 = this.fmsOrderProcessFixtureService.getFmsOrderProcessFixtures(machOrderIds);
            List<String> inExecutionTrays = fmsOrderProcessFixtures1.stream().map((v0) -> {
                return v0.getTrayCode();
            }).distinct().collect(Collectors.toList());
            
            List<String> sameTrayCodes = toBeStartTrays.stream().filter(inExecutionTrays::contains).collect(Collectors.toList());
            /*
            Stream<String> stream = toBeStartTrays.stream();
            inExecutionTrays.getClass();
            List<String> sameTrayCodes = stream.filter((v1) -> {
                return r1.contains(v1);
            }).collect(Collectors.toList());
            */
            
            
            if (Func.isNotEmpty(sameTrayCodes)) {
                List<FmsOrderProcessFixture> toBeSameTrays = fmsOrderProcessFixtures.stream().filter(c -> {
                    return sameTrayCodes.contains(c.getTrayCode());
                }).collect(Collectors.toList());
                List<FmsOrderProcessFixture> inExecutionSameTrays = fmsOrderProcessFixtures1.stream().filter(c2 -> {
                    return sameTrayCodes.contains(c2.getTrayCode());
                }).collect(Collectors.toList());
                Map<String, List<FmsOrderProcessFixture>> toBeSameTraysMap = toBeSameTrays.stream().collect(Collectors.groupingBy((v0) -> {
                    return v0.getTrayCode();
                }));
                Map<String, List<FmsOrderProcessFixture>> inExecutionSameTraysMap = inExecutionSameTrays.stream().collect(Collectors.groupingBy((v0) -> {
                    return v0.getTrayCode();
                }));
                List<Long> toBeSameTrayOrderIds = toBeSameTrays.stream().map((v0) -> {
                    return v0.getOrderId();
                }).distinct().collect(Collectors.toList());
                List<Long> inExecutionSameTrayOrderIds = inExecutionSameTrays.stream().map((v0) -> {
                    return v0.getOrderId();
                }).distinct().collect(Collectors.toList());
                List<FmsOrder> tobeStartSameTrayList = tobeStartList.stream().filter(s -> {
                    return toBeSameTrayOrderIds.contains(s.getId());
                }).collect(Collectors.toList());
                Map<Long, FmsOrder> toMap = tobeStartSameTrayList.stream().collect(Collectors.toMap((v0) -> {
                    return v0.getId();
                }, Function.identity()));
                List<FmsOrder> inExecutionSameTrayOrderList = machOrders.stream().filter(s2 -> {
                    return inExecutionSameTrayOrderIds.contains(s2.getId());
                }).collect(Collectors.toList());
                Map<Long, FmsOrder> inMap = inExecutionSameTrayOrderList.stream().collect(Collectors.toMap((v0) -> {
                    return v0.getId();
                }, Function.identity()));
                sameTrayCodes.forEach(trayCode -> {
                    List<FmsOrderProcessFixture> toStartOrderList = toBeSameTraysMap.get(trayCode);
                    List<FmsOrderProcessFixture> inExecutionOrderList = inExecutionSameTraysMap.get(trayCode);
                    List<Long> toBeIds = toStartOrderList.stream().map((v0) -> {
                        return v0.getOrderId();
                    }).distinct().collect(Collectors.toList());
                    List<Long> inExecutionIds = inExecutionOrderList.stream().map((v0) -> {
                        return v0.getOrderId();
                    }).distinct().collect(Collectors.toList());
                    for (Long toId : toBeIds) {
                        FmsOrder fmsOrder = (FmsOrder) toMap.get(toId);
                        for (Long inId : inExecutionIds) {
                            FmsOrder inOrder = (FmsOrder) inMap.get(inId);
                            if (!toId.equals(inId) && fmsOrder.getPriority().intValue() != 0 && fmsOrder.getPriority().intValue() <= inOrder.getPriority().intValue()) {
                                removeOrderIds.add(String.valueOf(toId));
                            }
                        }
                    }
                });
            }
            if (Func.isNotEmpty(removeOrderIds)) {
                List<String> removeIds = removeOrderIds.stream().distinct().collect(Collectors.toList());
                orderIds = orderIds.stream().filter(c3 -> {
                    return !removeIds.contains(c3);
                }).collect(Collectors.toList());
            }
            if (Func.isNotEmpty(orderIds)) {
            	update(Wrappers.<FmsOrder>lambdaUpdate().in(FmsOrder::getId, Func.toLongList(orderIds))
                        .set(FmsOrder::getOrderStatus, Integer.valueOf(OrderStatusEnum.MACH_ING.getValue()))
                        .set(FmsOrder::getStartUpTime, LocalDateTime.now())); 
            	/*
                update((Wrapper) ((LambdaUpdateWrapper) ((LambdaUpdateWrapper) Wrappers.lambdaUpdate().in((v0) -> {
                    return v0.getId();
                }, Func.toLongList(orderIds))).set((v0) -> {
                    return v0.getOrderStatus();
                }, Integer.valueOf(OrderStatusEnum.MACH_ING.getValue()))).set((v0) -> {
                    return v0.getStartUpTime();
                }, LocalDateTime.now()));
                */
            }
        }
    }

    public void dealToBeStart(List<String> orderIds, List<FmsOrder> list, Map<Long, List<FmsOrderProcessFixture>> toBeStartedFixtureMap) {
        if (orderIds.size() > 1) {
            Map<Integer, List<FmsOrder>> priorityMap = list.stream().collect(Collectors.groupingBy((v0) -> {
                return v0.getPriority();
            }));
            priorityMap.forEach((k, v) -> {
                v.sort((o1, o2) -> {
                    Long id = o1.getId();
                    Long id2 = o2.getId();
                    List<FmsOrderProcessFixture> processFixtureList = toBeStartedFixtureMap.get(id);
                    List<FmsOrderProcessFixture> processFixtureList1 = toBeStartedFixtureMap.get(id2);
                    if (Func.isNotEmpty(processFixtureList) && Func.isNotEmpty(processFixtureList1)) {
                        List<String> collect = processFixtureList.stream().map((v0) -> {
                            return v0.getTrayCode();
                        }).distinct().collect(Collectors.toList());
                        List<String> collect1 = processFixtureList1.stream().map((v0) -> {
                            return v0.getTrayCode();
                        }).distinct().collect(Collectors.toList());
                        //排序而已，不太重要,此处需要再仔细考虑
                       
                        List<String> collect2 = collect.stream().filter((v1) -> {
                            return collect1.contains(v1);
                        }).collect(Collectors.toList());
                        
                        if (collect2.size() > 0) {
                            orderIds.remove(String.valueOf(o1.getId()));
                            return 0;
                        }
                        return 0;
                    }
                    return 0;
                });
            });
        }
    }

    private List<FmsOrder> getUsingOrderByTray(final List<String> trayCodeList) {
        List<FmsOrderProcessFixture> fixtures = this.fmsOrderProcessFixtureService.list(Lambda.in((v0) -> {
            return v0.getTrayCode();
        }, trayCodeList));
        List<Long> processIds = fixtures.stream().map((v0) -> {
            return v0.getOrderProcessId();
        }).collect(Collectors.toList());
        List<FmsOrderProcess> processList = null;
        if (Func.isNotEmpty(processIds)) {
            processList = this.fmsOrderProcessService.list(Lambda.in((v0) -> {
                return v0.getId();
            }, processIds));
        }
        if (Func.isNotEmpty(processList)) {
            List<FmsOrder> orderList = list(Lambda.in((v0) -> {
                return v0.getId();
            },  processList.stream().map((v0) -> {
                return v0.getOrderId();
            }).collect(Collectors.toList())));
            List<FmsOrder> usingOrders = orderList.stream().filter(item -> {
                return item.getOrderStatus().equals(Integer.valueOf(OrderStatusEnum.MACH_ING.getValue())) || item.getOrderStatus().equals(Integer.valueOf(OrderStatusEnum.PAUSE_ING.getValue()));
            }).collect(Collectors.toList());
            return usingOrders;
        }
        return Collections.emptyList();
    }

    private List<Long> getToBeStartOrderByTray(List<String> trayCodeList, List<Long> orderIds) {
    	List<FmsOrderProcessFixture> fixtures = this.fmsOrderProcessFixtureService.list(Wrappers.<FmsOrderProcessFixture>lambdaQuery()
    			.in(FmsOrderProcessFixture::getOrderId, orderIds)
    			.in(FmsOrderProcessFixture::getTrayCode, trayCodeList));
    	/*
        List<FmsOrderProcessFixture> fixtures = this.fmsOrderProcessFixtureService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().in((v0) -> {
            return v0.getOrderId();
        }, orderIds)).in((v0) -> {
            return v0.getTrayCode();
        }, trayCodeList));*/
        if (Func.isNotEmpty(fixtures)) {
            List<Long> orderList = fixtures.stream().map((v0) -> {
                return v0.getOrderId();
            }).distinct().collect(Collectors.toList());
            if (Func.isNotEmpty(orderList)) {
                return orderList;
            }
        }
        return new ArrayList<>();
    }

    @Override // org.springblade.modules.fms.service.IFmsOrderService
    @Transactional(rollbackFor = {Exception.class})
    public FmsOrderVO publish(final String orderId) {
        FmsOrder fmsOrder = (FmsOrder) getById(orderId);
        int status = fmsOrder.getOrderStatus() == null ? OrderStatusEnum.WAIT_PUBLISH.getValue() : fmsOrder.getOrderStatus().intValue();
        if (status != OrderStatusEnum.WAIT_PUBLISH.getValue()) {
            throw new ServiceException(MessageUtils.message("fms.order.has.publish", new Object[0]));
        }
        List<FmsOrderProcess> fmsOrderProcessList = this.fmsOrderProcessService.list(Lambda.eq(FmsOrderProcess::getOrderId, orderId).orderByAsc(FmsOrderProcess::getSort));
        /*
        List<FmsOrderProcess> fmsOrderProcessList = this.fmsOrderProcessService.list((Wrapper) Lambda.eq((v0) -> {
            return v0.getOrderId();
        }, orderId).orderByAsc((v0) -> {
            return v0.getSort();
        }));*/
        boolean existEmptyWorkstation = fmsOrderProcessList.stream().anyMatch(item -> {
            return Func.isEmpty(item.getWorkStationId());
        });
        if (existEmptyWorkstation) {
            throw new ServiceException(MessageUtils.message("fms.order.workstation.isnull", new Object[0]));
        }
        FmsOrderProcess fmsOrderProcess = ((FmsOrderProcess) ListUtils.getFirst(fmsOrderProcessList)).setInputNum(fmsOrder.getAssignNum()).setDistributedNum(fmsOrder.getAssignNum());
        this.fmsOrderProcessService.updateById(fmsOrderProcess);
        fmsOrder.setOrderStatus(Integer.valueOf(OrderStatusEnum.WAIT_MACHINE.getValue()));
        updateById(fmsOrder);
        return wrapper(fmsOrder);
    }

    @Override // org.springblade.modules.fms.service.IFmsOrderService
    public Boolean stopDownOrder() {
        FmsInstructionRecord lastRecord = this.fmsInstructionRecordService.getLastRecord();
        if (lastRecord == null) {
            return Boolean.FALSE;
        }
        if (FmsConstant.GENERATED.equals(lastRecord.getState()) || FmsConstant.EXECUTING.equals(lastRecord.getState())) {
            lastRecord.setChangeModel(1);
            return Boolean.valueOf(this.fmsInstructionRecordService.updateById(lastRecord));
        }
        this.paramService.startSwitching();
        return Boolean.TRUE;
    }

    @Override // org.springblade.modules.fms.service.IFmsOrderService
    @Transactional(rollbackFor = {Exception.class})
    public Boolean removeOrder(IdsVO ids) {
        List<Long> orderIds = Func.toLongList(ids.getIds());
        List<FmsOrder> fmsOrders = listByIds(orderIds);
        boolean match = fmsOrders.stream().allMatch(fo -> {
            return fo.getOrderStatus().equals(Integer.valueOf(OrderStatusEnum.WAIT_PUBLISH.getValue())) || fo.getOrderStatus().equals(Integer.valueOf(OrderStatusEnum.WAIT_MACHINE.getValue()));
        });
        if (!match) {
            throw new ServiceException(MessageUtils.message("cps.fms.order.delete.wait.publish.machine", new Object[0]));
        }
        return Boolean.valueOf(removeBatchByIds(orderIds));
    }

    @Override // org.springblade.modules.fms.service.IFmsOrderService
    public List<String> listWorkstationByTrayCode(String trayCode) {
        return ((FmsOrderMapper) this.baseMapper).listWorkstationByTrayCode(trayCode);
    }
}