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

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.google.common.collect.Lists;
import java.lang.invoke.SerializedLambda;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import com.qianwen.smartman.common.cache.RegionCache;
import com.qianwen.smartman.common.constant.CommonConstant;
import com.qianwen.smartman.common.constant.ExcelConstant;
import com.qianwen.smartman.common.utils.MessageUtils;
import com.qianwen.core.log.exception.ServiceException;
import com.qianwen.core.mp.base.BaseServiceImpl;
import com.qianwen.core.oss.model.BladeFile;
import com.qianwen.core.tool.utils.DateUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.modules.coproduction.convert.OrderConvert;
import com.qianwen.smartman.modules.coproduction.dto.PlanAndOrderDTO;
import com.qianwen.smartman.modules.coproduction.entity.Order;
import com.qianwen.smartman.modules.coproduction.entity.OrderProcess;
import com.qianwen.smartman.modules.coproduction.entity.OrderReportRecord;
import com.qianwen.smartman.modules.coproduction.entity.Plan;
import com.qianwen.smartman.modules.coproduction.enums.CoProductionEnum;
import com.qianwen.smartman.modules.coproduction.enums.OrderStatusEnum;
import com.qianwen.smartman.modules.coproduction.enums.PlanStatusEnum;
import com.qianwen.smartman.modules.coproduction.mapper.OrderMapper;
import com.qianwen.smartman.modules.coproduction.service.IOrderProcessService;
import com.qianwen.smartman.modules.coproduction.service.IOrderReportRecordService;
import com.qianwen.smartman.modules.coproduction.service.IOrderService;
import com.qianwen.smartman.modules.coproduction.service.IOrderWorkstationService;
import com.qianwen.smartman.modules.coproduction.service.IPlanService;
import com.qianwen.smartman.modules.coproduction.vo.OrderAndProcessInfoVO;
import com.qianwen.smartman.modules.coproduction.vo.OrderAssignVO;
import com.qianwen.smartman.modules.coproduction.vo.OrderProcessDetailVO;
import com.qianwen.smartman.modules.coproduction.vo.OrderQueryVO;
import com.qianwen.smartman.modules.coproduction.vo.OrderVO;
import com.qianwen.smartman.modules.cps.entity.Workstation;
import com.qianwen.smartman.modules.cps.service.IWorkstationService;
import com.qianwen.smartman.modules.mdc.utils.ExcelStrategyUtil;
import com.qianwen.smartman.modules.resource.builder.oss.OssBuilder;
import com.qianwen.smartman.modules.system.constant.FieldConstant;
import com.qianwen.smartman.modules.system.service.ICodeGeneratorService;
import com.qianwen.smartman.modules.tpm.enums.MetaTypeEnum;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

@Service
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/coproduction/service/impl/OrderServiceImpl.class */
public class OrderServiceImpl extends BaseServiceImpl<OrderMapper, Order> implements IOrderService {
    @Autowired
    @Lazy
    private IPlanService planService;
    @Autowired
    private ICodeGeneratorService codeGeneratorService;
    @Autowired
    @Lazy
    private IOrderProcessService orderProcessService;
    @Autowired
    private IOrderWorkstationService orderWorkstationService;
    @Autowired
    private IWorkstationService workstationService;
    @Autowired
    @Lazy
    private IOrderReportRecordService reportRecordService;
    @Autowired
    private OssBuilder ossBuilder;


    @Override // org.springblade.modules.coproduction.service.IOrderService
    public List<OrderVO> list(OrderQueryVO orderQueryVO) {
        return this.baseMapper.list(orderQueryVO);
    }

    @Override // org.springblade.modules.coproduction.service.IOrderService
    @Transactional(rollbackFor = {Exception.class})
    public Boolean remove(List<Long> ids, Long planId) {

    	long count = count(Wrappers.<Order>lambdaQuery().in(Order::getId, ids).ne(Order::getOrderStatus, OrderStatusEnum.NOT_STARTED.getCode()));
        if (count > 0L)
          throw new ServiceException(MessageUtils.message("production.order.can.not.delete", new Object[0])); 
        List<Order> orderList = listByIds(ids);
        removeBatchByIds(ids);
        int allAssignNum = orderList.stream().mapToInt(Order::getAssignNum).sum();
        Plan plan = (Plan)this.planService.getById(planId);
        plan.setUnassignedNum(Integer.valueOf(allAssignNum + plan.getUnassignedNum().intValue()));
        if (plan.getPlanNum().equals(plan.getUnassignedNum())) {
          plan.setPlanStatus(PlanStatusEnum.WAIT_PUBLISH.getCode()); 
        }
        return Boolean.valueOf(this.planService.updateById(plan));
    	/*
        long count = count((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().in((v0) -> {
            return v0.getId();
        }, ids)).ne((v0) -> {
            return v0.getOrderStatus();
        }, OrderStatusEnum.NOT_STARTED.getCode()));
        if (count > 0) {
            throw new ServiceException(MessageUtils.message("production.order.can.not.delete", new Object[0]));
        }
        List<Order> orderList = listByIds(ids);
        removeBatchByIds(ids);
        int allAssignNum = orderList.stream().mapToInt((v0) -> {
            return v0.getAssignNum();
        }).sum();
        Plan plan = (Plan) this.planService.getById(planId);
        plan.setUnassignedNum(Integer.valueOf(allAssignNum + plan.getUnassignedNum().intValue()));
        if (plan.getPlanNum().equals(plan.getUnassignedNum())) {
            plan.setPlanStatus(PlanStatusEnum.WAIT_PUBLISH.getCode());
        }
        return Boolean.valueOf(this.planService.updateById(plan));
        */
    }

    @Override // org.springblade.modules.coproduction.service.IOrderService
    @Transactional(rollbackFor = {Exception.class})
    public OrderVO assign(OrderAssignVO orderAssignVO) {
        Plan plan = (Plan) this.planService.getById(orderAssignVO.getPlanId());
        assignCheck(plan, orderAssignVO);
        Order order = generateOrder(orderAssignVO);
        List<OrderProcess> orderProcessList = this.orderProcessService.generateOrderProcess(orderAssignVO, order);
        this.orderWorkstationService.generateOrderWorkstation(orderProcessList);
        updatePlan(plan, orderAssignVO.getAssignNum());
        return OrderConvert.INSTANCE.convert(order);
    }

    private void updatePlan(Plan plan, Integer assignNum) {
        if (PlanStatusEnum.WAIT_PUBLISH.getCode().equals(plan.getPlanStatus())) {
            plan.setPlanStatus(PlanStatusEnum.WAIT_MACHINE.getCode());
        }
        plan.setUnassignedNum(Integer.valueOf(plan.getUnassignedNum().intValue() - assignNum.intValue()));
        this.planService.updateById(plan);
    }

    @Override // org.springblade.modules.coproduction.service.IOrderService
    @Transactional(rollbackFor = {Exception.class})
    public void reportOrder(Integer orderQualifyNum, Integer orderScrappedNum, Order order, Boolean isDel) {
        Integer oldQualifyNum = order.getQualifyNum();
        Integer oldScrappedNum = order.getScrappedNum();
        Long orderId = order.getId();
        Integer newQualifyNum = Integer.valueOf(orderQualifyNum.intValue() + oldQualifyNum.intValue());
        Integer newScrappedNum = Integer.valueOf(orderScrappedNum.intValue() + oldScrappedNum.intValue());
        Integer assignNum = order.getAssignNum();
        Integer reportNum = Integer.valueOf(newQualifyNum.intValue() + newScrappedNum.intValue());
        if (assignNum.intValue() < reportNum.intValue()) {
            throw new ServiceException(MessageUtils.message("production.report.fail.order.report.num.not.exceed.assign.num", new Object[0]));
        }
        order.setQualifyNum(newQualifyNum);
        order.setScrappedNum(newScrappedNum);
        
        LambdaUpdateWrapper<Order> orderLambdaUpdateWrapper = Wrappers.<Order>lambdaUpdate().eq(Order::getId, order.getId());
       
        boolean isOrderCompleted = false;
        if (assignNum.equals(reportNum)) {
            isOrderCompleted = true;
        }
        if (isOrderCompleted) {
            orderLambdaUpdateWrapper.set((v0) -> {
                return v0.getOrderStatus();
            }, CoProductionEnum.OrderStatus.COMPLETED.getCode());
            Date endTime = null;
            OrderReportRecord latestRecord = this.reportRecordService.getLatestRecord(null, orderId, null);
            if (latestRecord != null) {
                endTime = latestRecord.getWorkshopTime();
            }
            if (endTime == null) {
                endTime = DateUtil.now();
            }
            order.setEndTime(endTime);
        }
        if (assignNum.intValue() > reportNum.intValue() && CoProductionEnum.OrderStatus.COMPLETED.getCode().equals(order.getOrderStatus())) {
            orderLambdaUpdateWrapper.set((v0) -> {
                return v0.getOrderStatus();
            }, CoProductionEnum.OrderStatus.PROCESSING.getCode());
            orderLambdaUpdateWrapper.set((v0) -> {
                return v0.getEndTime();
            }, (Object) null);
        }
        if (isDel.booleanValue()) {
            updateOrderStartTime(order, orderLambdaUpdateWrapper);
        }
        update(order, orderLambdaUpdateWrapper);
    }

    private void updateOrderStartTime(Order currentOrder, LambdaUpdateWrapper<Order> orderLambdaUpdateWrapper) {
        Date startTime = null;
        OrderReportRecord earliestRecord = this.reportRecordService.getEarliestRecord(null, currentOrder.getId(), null, null);
        if (earliestRecord != null) {
            startTime = earliestRecord.getStartTime();
        }
        if (startTime == null) {
            orderLambdaUpdateWrapper.set((v0) -> {
                return v0.getStartTime();
            }, (Object) null);
            orderLambdaUpdateWrapper.set((v0) -> {
                return v0.getOrderStatus();
            }, CoProductionEnum.OrderStatus.TOBE_START.getCode());
        }
        if (!currentOrder.getStartTime().equals(startTime)) {
            orderLambdaUpdateWrapper.set((v0) -> {
                return v0.getStartTime();
            }, startTime);
        }
    }

    @Override // org.springblade.modules.coproduction.service.IOrderService
    public void updateOrderByStart(Order order, Date startTime) {
        if (OrderStatusEnum.NOT_STARTED.getCode().equals(order.getOrderStatus())) {
            order.setOrderStatus(OrderStatusEnum.IN_EXECUTION.getCode());
            if (Func.isEmpty(order.getStartTime())) {
                order.setStartTime(startTime);
            }
            updateById(order);
        }
    }

    @Override // org.springblade.modules.coproduction.service.IOrderService
    public PlanAndOrderDTO getPlanAndOrderByOrderId(Long orderId) {
        Order order = (Order) getById(orderId);
        if (order == null) {
            throw new ServiceException(MessageUtils.message("cps.coproduction.order.is.not.exist", new Object[0]));
        }
        Plan plan = (Plan) this.planService.getById(order.getPlanId());
        if (plan == null) {
            throw new ServiceException(MessageUtils.message("cps.coproduction.plan.is.not.exist", new Object[0]));
        }
        PlanAndOrderDTO planAndOrderDTO = new PlanAndOrderDTO();
        planAndOrderDTO.setPlan(plan);
        planAndOrderDTO.setOrder(order);
        return planAndOrderDTO;
    }

    @Override // org.springblade.modules.coproduction.service.IOrderService
    public List<OrderVO> planOrderList(OrderQueryVO orderQueryVO) {
        QueryWrapper<Order> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("plan_id", orderQueryVO.getPlanId());
        if (Func.isNotEmpty(orderQueryVO.getSortName()) && Func.isNotEmpty(orderQueryVO.getOrder())) {
            queryWrapper.orderBy(Boolean.TRUE.booleanValue(), orderQueryVO.getOrder().equals(FieldConstant.ASC), StrUtil.toUnderlineCase(orderQueryVO.getSortName()));
        } else {
            queryWrapper.orderBy(Boolean.TRUE.booleanValue(), Boolean.TRUE.booleanValue(), "order_code");
        }
        List<Order> orderList = list(queryWrapper);
        List<OrderVO> orderVOList = OrderConvert.INSTANCE.convert(orderList);
        List<OrderProcess> orderProcessList = this.orderProcessService.list(Wrappers.<OrderProcess>lambdaQuery()
                .in(OrderProcess::getOrderId, orderVOList.stream().map(OrderVO::getId).collect(Collectors.toList()))
                .orderByAsc(OrderProcess::getSort));
        /*
        List<OrderProcess> orderProcessList = this.orderProcessService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().in((v0) -> {
            return v0.getOrderId();
        }, (Collection) orderVOList.stream().map((v0) -> {
            return v0.getId();
        }).collect(Collectors.toList()))).orderByAsc((v0) -> {
            return v0.getSort();
        }));*/
        
        Map<Long, List<OrderProcess>> orderProcessMap = orderProcessList.stream().collect(Collectors.groupingBy(OrderProcess::getOrderId));
        /*
        Map<Long, List<OrderProcess>> orderProcessMap = (Map) orderProcessList.stream().collect(Collectors.groupingBy((v0) -> {
            return v0.getOrderId();
        }));*/
        orderVOList.forEach(orderVO -> {
            List<OrderProcess> orderProcesses = orderProcessMap.get(orderVO.getId());
            if (Func.isNotEmpty(orderProcesses)) {
                String reportSituation = (String) orderProcesses.stream().map(orderProcess -> {
                    return String.valueOf(orderProcess.getQualifyNum().intValue() + orderProcess.getScrappedNum().intValue());
                }).collect(Collectors.joining("/"));
                orderVO.setReportSituation(reportSituation);
            }
        });
        return orderVOList;
    }

    @Override // org.springblade.modules.coproduction.service.IOrderService
    public OrderAndProcessInfoVO getOrderAndProcessList(Long orderId) {
        OrderAndProcessInfoVO result = new OrderAndProcessInfoVO();
        Order order = (Order) getById(orderId);
        if (Func.isNotEmpty(order)) {
            result.setAssignNum(order.getAssignNum());
            result.setOrderCode(order.getOrderCode());
            
            result.setOrderProcessList(this.orderProcessService.list(Wrappers.<OrderProcess>lambdaQuery().eq(OrderProcess::getOrderId, orderId)));
            /*
            result.setOrderProcessList(this.orderProcessService.list((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
                return v0.getOrderId();
            }, orderId)));*/
        }
        return result;
    }

    @Override // org.springblade.modules.coproduction.service.IOrderService
    @Transactional(rollbackFor = {Exception.class})
    public Order reportOrderData(Order order) {
        List<OrderProcess> mainProcess = (List) order.getOrderProcessList().stream().filter(s -> {
            return Func.isEmpty(s.getMainSequenceId());
        }).collect(Collectors.toList());
        Integer scrappedNumSum = (Integer) mainProcess.stream().map((v0) -> {
            return v0.getScrappedNum();
        }).reduce(0, (v0, v1) -> {
            return Integer.sum(v0, v1);
        });
        Integer assignNum = order.getAssignNum();
        Integer reportNum = Integer.valueOf(order.getQualifyNum().intValue() + scrappedNumSum.intValue());
        if (assignNum.intValue() < reportNum.intValue()) {
            throw new ServiceException(MessageUtils.message("production.report.fail.order.report.num.not.exceed.assign.num", new Object[0]));
        }
        order.setQualifyNum(order.getQualifyNum());
        order.setScrappedNum(scrappedNumSum);
        boolean isOrderCompleted = false;
        if (assignNum.equals(reportNum)) {
            isOrderCompleted = true;
        }
        if (isOrderCompleted) {
            order.setOrderStatus(CoProductionEnum.OrderStatus.COMPLETED.getCode());
            Date endTime = null;
            OrderReportRecord latestRecord = this.reportRecordService.getLatestRecord(null, order.getId(), null);
            if (latestRecord != null) {
                endTime = latestRecord.getWorkshopTime();
            }
            if (endTime == null) {
                endTime = DateUtil.now();
            }
            order.setEndTime(endTime);
        }
        if (!isOrderCompleted) {
            order.setOrderStatus(CoProductionEnum.OrderStatus.PROCESSING.getCode());
            order.setEndTime(null);
        }
        return order;
    }

    @Override // org.springblade.modules.coproduction.service.IOrderService
    @Transactional(rollbackFor = {Exception.class})
    public Order delReportOrderData(Order order, List<Long> removeRecordIds) {
        List<OrderProcess> mainProcess = (List) order.getOrderProcessList().stream().filter(s -> {
            return Func.isEmpty(s.getMainSequenceId());
        }).collect(Collectors.toList());
        Integer scrappedNumSum = (Integer) mainProcess.stream().map((v0) -> {
            return v0.getScrappedNum();
        }).reduce(0, (v0, v1) -> {
            return Integer.sum(v0, v1);
        });
        Integer delNum = Integer.valueOf(order.getDelOrderNum() == null ? 0 : order.getDelOrderNum().intValue());
        Integer assignNum = order.getAssignNum();
        Integer reportNum = Integer.valueOf(order.getQualifyNum().intValue() + scrappedNumSum.intValue() + delNum.intValue());
        if (assignNum.intValue() < reportNum.intValue()) {
            throw new ServiceException(MessageUtils.message("production.report.fail.order.report.num.not.exceed.assign.num", new Object[0]));
        }
        order.setQualifyNum(Integer.valueOf(order.getQualifyNum().intValue() + delNum.intValue()));
        order.setScrappedNum(scrappedNumSum);
        boolean isOrderCompleted = false;
        if (assignNum.equals(reportNum)) {
            isOrderCompleted = true;
        }
        delOrderStartTime(order, removeRecordIds);
        if (!isOrderCompleted && order.getStartTime() != null) {
            order.setOrderStatus(CoProductionEnum.OrderStatus.PROCESSING.getCode());
            order.setEndTime(null);
        }
        if (order.getStartTime() == null) {
            order.setEndTime(null);
        }
        return order;
    }

    private void delOrderStartTime(Order currentOrder, List<Long> removeRecordIds) {
        Date startTime = null;
        OrderReportRecord earliestRecord = this.reportRecordService.getEarliestRecord(null, currentOrder.getId(), null, removeRecordIds);
        if (earliestRecord != null) {
            startTime = earliestRecord.getStartTime();
        }
        if (startTime == null) {
            currentOrder.setStartTime(null);
            currentOrder.setOrderStatus(CoProductionEnum.OrderStatus.TOBE_START.getCode());
        }
        Date currentOrderStartTime = currentOrder.getStartTime();
        if (startTime != null && currentOrderStartTime != null && !currentOrderStartTime.equals(startTime)) {
            currentOrder.setStartTime(startTime);
        }
    }

    @Override // org.springblade.modules.coproduction.service.IOrderService
    public BladeFile export(Long orderId) {
    	try {
	        List<List<String>> orderHead = buildOrderHead();
	        List<List<String>> processHead = buildProcessHead();
	        List<List<Object>> orderData = new ArrayList<>();
	        List<List<Object>> processData = new ArrayList<>();
	        if (Func.isNotEmpty(orderId)) {
	            OrderVO orderVO = list(new OrderQueryVO().setOrderId(orderId)).get(0);
	            List<OrderProcessDetailVO> orderProcessDetailVOList = this.orderProcessService.listDetailByOrderId(orderId);
	            orderData = buildOrderData(Lists.newArrayList(new OrderVO[]{orderVO}));
	            processData = buildProcessData(orderProcessDetailVOList);
	        }
	        String fileName = String.format("%s-%s.xlsx", ExcelConstant.ORDER, DateUtil.time());
	        MultipartFile multipartFile = ExcelStrategyUtil.customerTwoHeadExport(fileName, ExcelConstant.ORDER, orderHead, processHead, orderData, processData);
	        return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
    	} catch (Exception ex) {
    	      throw new RuntimeException(ex);
    	    } 
    }

    @Override // org.springblade.modules.coproduction.service.IOrderService
    public BladeFile exportList(OrderQueryVO orderQueryVO) {
        List<OrderVO> orderVOList = list(orderQueryVO);
        List<List<String>> head = buildOrderHead();
        List<List<Object>> data = buildOrderData(orderVOList);
        String fileName = String.format("%s-%s.xlsx", ExcelConstant.ORDER, DateUtil.time());
        MultipartFile multipartFile;
		try {
			multipartFile = ExcelStrategyUtil.customerExport(fileName, ExcelConstant.ORDER, head, data);
		} catch (Exception e) {
			log.error("导出列表错误",e);
			e.printStackTrace();
			throw new RuntimeException(e);
		}
        return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
    }

    private List<List<String>> buildOrderHead() {
        List<List<String>> orderHead = new ArrayList<>();
        orderHead.add(Lists.newArrayList(new String[]{"工单编号"}));
        orderHead.add(Lists.newArrayList(new String[]{"本次派发数量"}));
        orderHead.add(Lists.newArrayList(new String[]{"合格数"}));
        orderHead.add(Lists.newArrayList(new String[]{"报废数"}));
        orderHead.add(Lists.newArrayList(new String[]{"待加工数量"}));
        orderHead.add(Lists.newArrayList(new String[]{"计划开始时间"}));
        orderHead.add(Lists.newArrayList(new String[]{"计划结束时间"}));
        orderHead.add(Lists.newArrayList(new String[]{"状态"}));
        return orderHead;
    }

    private List<List<String>> buildProcessHead() {
        List<List<String>> processHead = new ArrayList<>();
        processHead.add(Lists.newArrayList(new String[]{"工序编号"}));
        processHead.add(Lists.newArrayList(new String[]{"工序名称"}));
        processHead.add(Lists.newArrayList(new String[]{"工序顺序"}));
        processHead.add(Lists.newArrayList(new String[]{"报工数量"}));
        processHead.add(Lists.newArrayList(new String[]{"合格数量"}));
        processHead.add(Lists.newArrayList(new String[]{"报废数量"}));
        processHead.add(Lists.newArrayList(new String[]{"合格率"}));
        processHead.add(Lists.newArrayList(new String[]{"开工时间"}));
        processHead.add(Lists.newArrayList(new String[]{"报工时间"}));
        processHead.add(Lists.newArrayList(new String[]{"指派工位"}));
        processHead.add(Lists.newArrayList(new String[]{"加工人员"}));
        return processHead;
    }

    private List<List<Object>> buildOrderData(List<OrderVO> orderVOList) {
        List<List<Object>> orderData = new ArrayList<>();
        orderVOList.forEach(orderVO -> {
            ArrayList arrayList = new ArrayList();
            arrayList.add(orderVO.getOrderCode());
            arrayList.add(orderVO.getAssignNum());
            arrayList.add(orderVO.getQualifyNum());
            arrayList.add(orderVO.getScrappedNum());
            arrayList.add(Integer.valueOf((orderVO.getAssignNum().intValue() - orderVO.getQualifyNum().intValue()) - orderVO.getScrappedNum().intValue()));
            arrayList.add(Func.isNotEmpty(orderVO.getPlanStartTime()) ? DateUtil.format(orderVO.getPlanStartTime(), "yyyy/MM/dd") : null);
            arrayList.add(Func.isNotEmpty(orderVO.getPlanEndTime()) ? DateUtil.format(orderVO.getPlanEndTime(), "yyyy/MM/dd") : null);
            arrayList.add(orderVO.getOrderStatusStr());
            orderData.add(arrayList);
        });
        return orderData;
    }

    private List<List<Object>> buildProcessData(List<OrderProcessDetailVO> orderProcessDetailVOList) {
        List<List<Object>> processData = new ArrayList<>();
        orderProcessDetailVOList.forEach(o -> {
            ArrayList arrayList = new ArrayList();
            arrayList.add(o.getProcessCode());
            arrayList.add(o.getProcessName());
            arrayList.add(o.getSort());
            int reportNum = o.getQualifyNum().intValue() + o.getScrappedNum().intValue();
            arrayList.add(Integer.valueOf(reportNum));
            arrayList.add(o.getQualifyNum());
            arrayList.add(o.getScrappedNum());
            if (reportNum == CommonConstant.ZERO.intValue()) {
                arrayList.add("-");
            } else {
                arrayList.add(BigDecimal.valueOf(o.getQualifyNum().intValue()).multiply(BigDecimal.valueOf(100L)).divide(BigDecimal.valueOf(reportNum), RoundingMode.HALF_UP).intValue() + "%");
            }
            arrayList.add(Func.isNotEmpty(o.getStartTime()) ? DateUtil.format(o.getStartTime(), "yyyy/MM/dd HH:mm") : null);
            arrayList.add(Func.isNotEmpty(o.getEndTime()) ? DateUtil.format(o.getStartTime(), "yyyy/MM/dd HH:mm") : null);
            arrayList.add(o.getWorkstationName());
            arrayList.add(o.getProducerUserName());
            processData.add(arrayList);
        });
        return processData;
    }

    private Order generateOrder(OrderAssignVO orderAssignVO) {
        String orderCode = orderAssignVO.getOrderCode();
        if (Func.isEmpty(orderCode)) {
            orderCode = this.codeGeneratorService.getGeneratorCode(orderAssignVO, MetaTypeEnum.ORDER.getCode());
        }
        checkCode(orderCode);
        Order order = new Order(orderAssignVO.getPlanId(), orderCode, orderAssignVO.getAssignNum());
        save(order);
        return order;
    }

    private void checkCode(String orderCode) {
    	long count = count(Wrappers.<Order>lambdaQuery().eq(Order::getOrderCode, orderCode));
    	/*
        long count = count((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getOrderCode();
        }, orderCode));
        */
        if (count > 0) {
            throw new ServiceException(MessageUtils.message("production.order.code.already.exists", new Object[0]));
        }
    }

    private void assignCheck(Plan plan, OrderAssignVO orderAssignVO) {
        if (Func.isEmpty(plan)) {
            throw new ServiceException(MessageUtils.message("production.plan.not.exists", new Object[0]));
        }
        List<Integer> canNotAssignPlanStatus = Lists.newArrayList(new Integer[]{PlanStatusEnum.CLOSE.getCode(), PlanStatusEnum.FINISHED.getCode(), PlanStatusEnum.PAUSE.getCode()});
        if (canNotAssignPlanStatus.contains(plan.getPlanStatus())) {
            throw new ServiceException(MessageUtils.message("production.plan.status.not.met", new Object[0]));
        }
        if (orderAssignVO.getAssignNum().intValue() > plan.getUnassignedNum().intValue()) {
            throw new ServiceException(MessageUtils.message("production.assign.num.exceed.plan.unassigned.num", new Object[0]));
        }
        Set<Long> workstationIdSet = new HashSet<>();
        orderAssignVO.getPlanProcessWorkStationAssignVOList().forEach(p -> {
            String workstationId = p.getWorkstationId();
            if (Func.isNotEmpty(workstationId)) {
                String[] split = workstationId.split(",");
                for (String s : split) {
                    workstationIdSet.add(Long.valueOf(s));
                }
            }
        });
        if (Func.isNotEmpty(workstationIdSet)) {
        	long workstationNum = this.workstationService.count(Wrappers.<Workstation>lambdaQuery().in(Workstation::getId, workstationIdSet));
        	/*
            long workstationNum = this.workstationService.count((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
                return v0.getId();
            }, workstationIdSet));
            */
            if (workstationNum < workstationIdSet.size()) {
                throw new ServiceException(MessageUtils.message("production.assign.workstation.not.exists", new Object[0]));
            }
        }
    }
}