wms / wms_guangxijianyi · Files

package com.huaheng.api.erp.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.google.gson.Gson;
import com.huaheng.api.erp.ExtK3CloudApi;
import com.huaheng.api.erp.ExtSaveParam;
import com.huaheng.api.erp.domain.*;
import com.huaheng.api.general.service.BasicDataApiService;
import com.huaheng.common.constant.QuantityConstant;
import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.framework.web.domain.AjaxResult;

import com.huaheng.pc.config.bosAssistantDetail.domain.BosAssistantDetail;
import com.huaheng.pc.config.bosAssistantDetail.service.IBosAssistantDetailService;
import com.huaheng.pc.config.container.domain.Container;
import com.huaheng.pc.config.container.service.ContainerService;
import com.huaheng.pc.config.containerType.domain.ContainerType;
import com.huaheng.pc.config.containerType.service.ContainerTypeService;
import com.huaheng.pc.config.customer.domain.Customer;
import com.huaheng.pc.config.customer.service.CustomerServiceImpl;
import com.huaheng.pc.config.flexValues.domain.FlexValues;
import com.huaheng.pc.config.flexValues.service.IFlexValuesService;
import com.huaheng.pc.config.material.domain.Material;
import com.huaheng.pc.config.material.service.MaterialService;
import com.huaheng.pc.config.productScheduleDetail.domain.ProductScheduleDetail;
import com.huaheng.pc.config.productScheduleDetail.service.IProductScheduleDetailService;
import com.huaheng.pc.config.productScheduleHeader.domain.ProductScheduleHeader;
import com.huaheng.pc.config.productScheduleHeader.service.IProductScheduleHeaderService;
import com.huaheng.pc.config.productSize.domain.ProductSize;
import com.huaheng.pc.config.productSize.service.IProductSizeService;
import com.huaheng.pc.config.proPackaging.domain.ProPackaging;
import com.huaheng.pc.config.proPackaging.service.IProPackagingService;
import com.huaheng.pc.config.station.domain.Station;
import com.huaheng.pc.config.station.service.StationService;
import com.huaheng.pc.config.stock.domain.Stock;
import com.huaheng.pc.config.stock.service.IStockService;
import com.huaheng.pc.config.unit.domain.Unit;
import com.huaheng.pc.config.unit.service.IUnitService;
import com.huaheng.pc.inventory.inventoryDetail.domain.InventoryDetail;
import com.huaheng.pc.inventory.inventoryDetail.service.InventoryDetailService;
import com.huaheng.pc.inventory.inventoryHeader.service.InventoryHeaderService;
import com.huaheng.pc.receipt.receiptContainerDetail.domain.ReceiptContainerDetail;
import com.huaheng.pc.receipt.receiptContainerDetail.service.ReceiptContainerDetailService;
import com.huaheng.pc.receipt.receiptContainerHeader.domain.ReceiptContainerHeader;
import com.huaheng.pc.receipt.receiptContainerHeader.service.ReceiptContainerHeaderService;
import com.huaheng.pc.receipt.receiptDetail.domain.ReceiptDetail;
import com.huaheng.pc.receipt.receiptDetail.service.ReceiptDetailService;
import com.huaheng.pc.receipt.receiptHeader.domain.ReceiptHeader;
import com.huaheng.pc.receipt.receiptHeader.service.ReceiptHeaderService;
import com.huaheng.pc.shipment.shipmentContainerDetail.domain.ShipmentContainerDetail;
import com.huaheng.pc.shipment.shipmentContainerDetail.service.ShipmentContainerDetailService;
import com.huaheng.pc.shipment.shipmentContainerHeader.domain.ShipmentContainerHeader;
import com.huaheng.pc.shipment.shipmentContainerHeader.service.ShipmentContainerHeaderService;
import com.huaheng.pc.shipment.shipmentDetail.domain.ShipmentDetail;
import com.huaheng.pc.shipment.shipmentDetail.service.ShipmentDetailService;
import com.huaheng.pc.shipment.shipmentHeader.domain.ShipmentHeader;
import com.huaheng.pc.shipment.shipmentHeader.service.ShipmentHeaderService;
import com.huaheng.pc.system.dept.domain.Dept;
import com.huaheng.pc.system.dept.service.DeptServiceImpl;
import com.huaheng.pc.system.user.domain.User;
import com.huaheng.pc.system.user.service.UserServiceImpl;
import com.huaheng.pc.task.taskHeader.service.ReceiptTaskService;
import com.huaheng.pc.task.taskHeader.service.ShipmentTaskService;
import com.huaheng.pc.task.taskHeader.service.TaskHeaderService;
import com.kingdee.bos.webapi.sdk.*;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.huaheng.pc.task.agvTask.domain.AgvTask;
import com.huaheng.pc.task.agvTask.service.AgvTaskService;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class ERPServiceImpl implements ERPService {

    @Resource
    private ContainerService containerService;
    @Resource
    private ContainerTypeService containerTypeService;
    @Resource
    private ReceiptContainerHeaderService receiptContainerHeaderService;
    @Resource
    private ReceiptContainerDetailService receiptContainerDetailService;
    @Resource
    private ReceiptHeaderService receiptHeaderService;
    @Resource
    private ReceiptDetailService receiptDetailService;
    @Resource
    private ReceiptTaskService receiptTaskService;
    @Resource
    private MaterialService materialService;
    @Resource
    private AgvTaskService agvTaskService;

    @Resource
    private ShipmentHeaderService shipmentHeaderService;
    @Resource
    private InventoryHeaderService inventoryHeaderService;
    @Resource
    private InventoryDetailService inventoryDetailService;
    @Resource
    private ShipmentContainerHeaderService shipmentContainerHeaderService;
    @Resource
    private StationService stationService;
    @Resource
    private TaskHeaderService taskHeaderService;
    @Resource
    private CustomerServiceImpl customerService;
    @Resource
    private ShipmentTaskService shipmentTaskService;
    @Resource
    private ShipmentDetailService shipmentDetailService;
    @Resource
    private ShipmentContainerDetailService shipmentContainerDetailService;
    @Resource
    private DeptServiceImpl deptService;
    @Resource
    private BasicDataApiService basicDataApiService;
    @Resource
    private IStockService stockService;
    @Resource
    private UserServiceImpl userService;
    @Resource
    private IFlexValuesService flexValuesService;
    @Resource
    private IUnitService unitService;
    @Resource
    private IProPackagingService proPackagingService;
    @Resource
    private IBosAssistantDetailService bosAssistantDetailService;
    @Resource
    private IProductSizeService productSizeService;
    @Resource
    private IProductScheduleDetailService productScheduleDetailService;
    @Resource
    private IProductScheduleHeaderService productScheduleHeaderService;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult innerReceipt(String containerCode, String position, String orderCode,
                                   String orderName, List<BoxInfo> boxInfoList,
                                   String stack, int qc) {
        String warehouseCode = "CS0001";
        boolean result = false;
        Container container = containerService.getContainerByCode(containerCode, warehouseCode);
        if(container == null) {
            return AjaxResult.error("根据托盘号:" + containerCode + "没有找到匹配的容器");
        }
        String locationCode = container.getLocationCode();
        if(StringUtils.isNotEmpty(locationCode)) {
            return AjaxResult.error("这个容器在库位上，不能用来入库, 托盘号:" + containerCode);
        }
        String containerTypeCode = container.getContainerType();
        if(containerTypeCode == null) {
            return AjaxResult.error("容器类型编码为空");
        }
        ContainerType containerType = containerTypeService.getContainerTypeByCode(containerTypeCode, warehouseCode);
        if(containerType == null) {
            return AjaxResult.error("容器类型为空");
        }
        if(boxInfoList == null || boxInfoList.size() == 0) {
            return AjaxResult.error("箱信息为空");
        }

        List<ReceiptContainerDetail> receiptContainerDetailList = new ArrayList<>();
        LambdaQueryWrapper<ReceiptContainerHeader> receiptContainerHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        receiptContainerHeaderLambdaQueryWrapper.eq(ReceiptContainerHeader::getContainerCode, containerCode)
                .lt(ReceiptContainerHeader::getStatus, QuantityConstant.RECEIPT_CONTAINER_FINISHED);
        ReceiptContainerHeader receiptContainerHeader =
                receiptContainerHeaderService.getOne(receiptContainerHeaderLambdaQueryWrapper);
        if(receiptContainerHeader != null) {
            return AjaxResult.error("容器已经有组盘信息，容器号:" + containerCode);
        }

        LambdaQueryWrapper<ReceiptHeader> receiptHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        receiptHeaderLambdaQueryWrapper.eq(ReceiptHeader::getCode, orderCode);
        ReceiptHeader receiptHeader = receiptHeaderService.getOne(receiptHeaderLambdaQueryWrapper);
        if(receiptHeader == null) {
            receiptHeader = new ReceiptHeader();
            receiptHeader.setCode(orderCode);
            receiptHeader.setReceiptType("SC");
            receiptHeader.setWarehouseCode(warehouseCode);
            receiptHeader.setCompanyCode("JY");
            receiptHeader.setFirstStatus(200);
            receiptHeader.setLastStatus(200);
            receiptHeader.setWarehouseCode(warehouseCode);
            receiptHeader.setCreatedBy("赋码系统");
            receiptHeader.setLastUpdatedBy("赋码系统");
            result = receiptHeaderService.save(receiptHeader);
            if(!result) {
                throw new ServiceException("保存入库单失败");
            }
        }

        BigDecimal totalQty = new BigDecimal(0);
        String materialCode1 = null, batch1 = null, level1=null,color1=null,materialPackage1=null;
        for(BoxInfo boxInfo : boxInfoList) {
            String boxCode = boxInfo.getBoxCode();
            String boxPosition = boxInfo.getBoxPosition();
            List<ChipInfos> chipInfoList = boxInfo.getChipInfos();
            materialCode1 = boxInfo.getMaterialCode();
            materialPackage1 = boxInfo.getMaterialPackage();
            level1 = boxInfo.getLevel();
            color1 = boxInfo.getColor();
            BigDecimal qty = boxInfo.getQty();
            batch1 = boxInfo.getBatch();
            totalQty = totalQty.add(qty);
        }
        ReceiptDetail receiptDetail = new ReceiptDetail();
        receiptDetail.setWarehouseCode(warehouseCode);
        receiptDetail.setCompanyCode("JY");
        receiptDetail.setMaterialCode(materialCode1);
        receiptDetail.setOpenQty(totalQty);
        receiptDetail.setTotalQty(totalQty);
        receiptDetail.setBatch(batch1);
        receiptDetail.setProjectNo(orderCode);
        receiptDetail.setReceiptCode(orderCode);
        receiptDetail.setQcCheck(qc+"");//是否质检
        receiptDetail.setCreatedBy("赋码系统");
        receiptDetail.setLastUpdatedBy("赋码系统");
        receiptDetail.setReceiptId(receiptHeader.getId());
        result = receiptDetailService.save(receiptDetail);
        if(!result) {
            throw new ServiceException("保存入库单详情失败");
        }

        ReceiptContainerHeader receiptContainerHeader1 = new ReceiptContainerHeader();
        receiptContainerHeader1.setWarehouseCode(warehouseCode);
        receiptContainerHeader1.setCompanyCode("JY");
        receiptContainerHeader1.setContainerCode(containerCode);
        receiptContainerHeader1.setPosition(position);
        receiptContainerHeader1.setColor(color1);//色号
        receiptContainerHeader1.setLevel(level1);//等级
        receiptContainerHeader1.setMaterialPackage(materialPackage1);//包装
        receiptContainerHeader1.setOrderCode(orderCode);//订单编号
        receiptContainerHeader1.setOrderName(orderName);//订单名称
        receiptContainerHeader1.setBatch(batch1);//批次
        receiptContainerHeader1.setMaterialCode(materialCode1);//物料编码
        receiptContainerHeader1.setContainerType(containerTypeCode);
        receiptContainerHeader1.setTaskType(QuantityConstant.TASK_TYPE_WHOLERECEIPT);
        receiptContainerHeader1.setStatus(QuantityConstant.RECEIPT_CONTAINER_BUILD);
        receiptContainerHeader1.setStack(stack);//设置垛型
        receiptContainerHeader1.setCreatedBy("赋码系统");
        receiptContainerHeader1.setLastUpdatedBy("赋码系统");
        result = receiptContainerHeaderService.save(receiptContainerHeader1);
        if(!result) {
            throw new ServiceException("保存入库组盘头失败");
        }
        for(BoxInfo boxInfo : boxInfoList) {
            String boxCode = boxInfo.getBoxCode();
            String boxPosition = boxInfo.getBoxPosition();
            List<ChipInfos> chipInfoList = boxInfo.getChipInfos();
            String materialCode = boxInfo.getMaterialCode();
            Material material = materialService.findAllByCode(materialCode, warehouseCode);
            String level = boxInfo.getLevel();
            String color = boxInfo.getColor();
            BigDecimal qty = boxInfo.getQty();
            String batch = boxInfo.getBatch();
            for(ChipInfos chipInfos : chipInfoList) {
                ReceiptContainerDetail receiptContainerDetail = new ReceiptContainerDetail();
                String chipCode = chipInfos.getChipBarcode();
                receiptContainerDetail.setWarehouseCode(warehouseCode);
                receiptContainerDetail.setContainerCode(containerCode);
                receiptContainerDetail.setContainerType(containerTypeCode);
                receiptContainerDetail.setCompanyCode("JY");
                receiptContainerDetail.setTaskType(QuantityConstant.TASK_TYPE_WHOLERECEIPT);
                receiptContainerDetail.setChipCode(chipCode);
                receiptContainerDetail.setMaterialCode(materialCode);
                receiptContainerDetail.setMaterialName(material.getName());
                receiptContainerDetail.setMaterialSpec(material.getSpec());
                receiptContainerDetail.setMaterialUnit(material.getUnit());
                receiptContainerDetail.setLevel(level);
                receiptContainerDetail.setColor(color);
               // receiptContainerDetail.setQty(new BigDecimal(1));
                receiptContainerDetail.setQty(receiptDetail.getTotalQty());
                receiptContainerDetail.setBatch(batch);
                receiptContainerDetail.setReceiptCode(orderCode);
                receiptContainerDetail.setBoxCode(boxCode);
                receiptContainerDetail.setReceiptType("SC");
                receiptContainerDetail.setInventorySts("good");
                receiptContainerDetail.setCreatedBy("赋码系统");
                receiptContainerDetail.setLastUpdatedBy("赋码系统");
                receiptContainerDetail.setBoxPosition(boxPosition);
                receiptContainerDetail.setReceiptId(receiptHeader.getId());
                receiptContainerDetail.setReceiptDetailId(receiptDetail.getId());
                receiptContainerDetail.setReceiptContainerId(receiptContainerHeader1.getId());
                receiptContainerDetailList.add(receiptContainerDetail);
            }
        }
        result = receiptContainerDetailService.saveBatch(receiptContainerDetailList);
        if(!result) {
            throw new ServiceException("保存入库组盘详情失败");
        }
        Integer id = receiptContainerHeader1.getId();
        result = receiptTaskService.createReceiptTask(id, warehouseCode);
        if(!result) {
            throw new ServiceException("生产任务失败");
        }

        if(qc==1){
        agvTaskAndReceiptQcStream(position,receiptHeader,warehouseCode);
        }else {
            //生成AGV取放货任务
            AgvTask agvTask = new AgvTask();
            agvTask.setType(QuantityConstant.AGV_TYPE_TAKE_AND_RELEASE);
            agvTask.setStatus(QuantityConstant.AGV_TASK_STATUS_BUILD);
            agvTask.setWarehouseCode(warehouseCode);
            agvTask.setPriority(10);
            agvTask.setFromPort(position);
            agvTask.setToPort("5");
            agvTask.setCreatedBy("赋码系统");
            result = agvTaskService.save(agvTask);
            if(!result) {
                throw new ServiceException("生成AGV任务失败");
            }
        }
        return AjaxResult.success("保存入库组盘信息成功");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult innerShipment(String shipmentCode, String shipmentType, String carType, String order, List<MaterialInfo> materialList,
                                    String remake, Date scheduleDate,BigDecimal totalQty) {
        String warehouseCode = "CS0001";
        boolean result = false;
        //查找入库订单
        //ReceiptHeader 的Code就是订单编号 order
        LambdaQueryWrapper<ReceiptHeader> receiptHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        receiptHeaderLambdaQueryWrapper.eq(ReceiptHeader::getCode, order);
        ReceiptHeader receiptHeader = receiptHeaderService.getOne(receiptHeaderLambdaQueryWrapper);
        if(receiptHeader == null) {
            return AjaxResult.error("根据订单号:" + order + "没有找到匹配的订单");
        }
        //总数量，校验数据完整性
        //出库单总数量应该是从入库单数量中获取比较
        LambdaQueryWrapper<InventoryDetail> inventoryHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryHeaderLambdaQueryWrapper.eq(InventoryDetail::getReceiptCode, order)
                .eq(InventoryDetail::getTaskQty,0);
        List<InventoryDetail> inventoryDetails = inventoryDetailService.list(inventoryHeaderLambdaQueryWrapper);
        if(inventoryDetails == null || inventoryDetails.size() <= 0){
            return AjaxResult.error("根据订单号："+order+"没有找到该订单库存");
        }

        //总数 对比 库存订单物料的总数
        BigDecimal sum = inventoryDetails.stream().map(t -> t.getQty()).reduce(BigDecimal.ZERO, BigDecimal::add);

        if(totalQty.compareTo(sum) != 0){
            return AjaxResult.error("erp出库总数量与立库库存总数量不一致");
        }

        //当前出库订单需要数量
        BigDecimal orderQty = materialList.stream().map(t -> t.getQty()).reduce(BigDecimal.ZERO, BigDecimal::add);
        //
        int totalLines = materialList.size();

        LambdaQueryWrapper<ShipmentHeader> shipmentHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        shipmentHeaderLambdaQueryWrapper.eq(ShipmentHeader::getCode, shipmentCode);
        ShipmentHeader shipmentHeader = shipmentHeaderService.getOne(shipmentHeaderLambdaQueryWrapper);
        if(shipmentHeader == null) {
            shipmentHeader = new ShipmentHeader();
            shipmentHeader.setCode(shipmentCode);
            shipmentHeader.setShipmentType("SP");
            shipmentHeader.setWarehouseCode(warehouseCode);
            shipmentHeader.setCompanyCode("JY");
            shipmentHeader.setFirstStatus(200);
            shipmentHeader.setLastStatus(200);
            shipmentHeader.setTotalQty(orderQty);
            shipmentHeader.setTotalLines(totalLines);
            shipmentHeader.setWarehouseCode(warehouseCode);
            shipmentHeader.setCreatedBy("赋码系统");
            shipmentHeader.setLastUpdatedBy("赋码系统");
            shipmentHeader.setCarModel(carType);
            shipmentHeader.setShipmentNote(remake);
            result = shipmentHeaderService.save(shipmentHeader);
            if(!result) {
                throw new ServiceException("保存出库单失败");
            }
        }

        LambdaQueryWrapper<Station> stationLambdaQueryWrapper = Wrappers.lambdaQuery();
        stationLambdaQueryWrapper.eq(Station::getArea, 3);
        List<Station> stationList = stationService.list(stationLambdaQueryWrapper);

        List<String> portCodeList = stationList.stream().map(t->t.getCode()).collect(Collectors.toList());
        if(portCodeList == null || portCodeList.size() == 0) {
            return AjaxResult.error("没有找到对应出口");
        }

        //迭代出库物料信息 可能有多种物料信息
        for(MaterialInfo materialInfo : materialList) {
            String materialCode = materialInfo.getMaterialCode();
            BigDecimal qty = materialInfo.getQty();
            String batch = materialInfo.getBatch();
            String stack = materialInfo.getStack();
            String color = materialInfo.getColor();
            String level = materialInfo.getLevel();
            LambdaQueryWrapper<Material> lambdaQueryWrapper = Wrappers.lambdaQuery();
            lambdaQueryWrapper.eq(StringUtils.isNotEmpty(materialCode),Material::getCode,materialCode)
                    .eq(Material::getWarehouseCode,QuantityConstant.DEFAULT_WAREHOUSE);
            Material material = materialService.getOne(lambdaQueryWrapper);

            ShipmentDetail shipmentDetail = new ShipmentDetail();
            shipmentDetail.setWarehouseCode(warehouseCode);
            shipmentDetail.setCompanyCode("JY");
            shipmentDetail.setMaterialCode(materialCode);
            shipmentDetail.setMaterialName(material.getName());
            shipmentDetail.setMaterialSpec(material.getSpec());
            shipmentDetail.setMaterialUnit(material.getUnit());
            shipmentDetail.setShipQty(qty);//发货数量
            shipmentDetail.setRequestQty(BigDecimal.ZERO);//请求数量
            shipmentDetail.setBatch(batch);
            shipmentDetail.setAllocationRule("XMH");
            shipmentDetail.setProjectNo(order);
            shipmentDetail.setInventorySts(QuantityConstant.GOOD);
            shipmentDetail.setShipmentCode(shipmentCode);
            shipmentDetail.setCreatedBy("赋码系统");
            shipmentDetail.setLastUpdatedBy("赋码系统");
            shipmentDetail.setShipmentId(shipmentHeader.getId());
            result = shipmentDetailService.save(shipmentDetail);
            if(!result) {
                throw new ServiceException("保存出库单详情失败");
            }


            //判断物料是否有库存
            LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getZoneCode, "L")
                    .eq(InventoryDetail::getMaterialCode, materialCode)
                    .eq(InventoryDetail::getTaskQty, 0)
                    .eq(InventoryDetail::getBatch,batch)
                    .eq(InventoryDetail::getColor,color)
                    .eq(InventoryDetail::getLevel,level)
                    .eq(InventoryDetail::getReceiptCode,order);//订单编号
            //获取物料集合
            List<InventoryDetail> inventoryDetailList = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);
            if(inventoryDetailList == null || inventoryDetailList.size() == 0) {
                return AjaxResult.error("没有对应库存");
            }

            List<String> containerList = inventoryDetailList.stream().
                    map(t -> t.getContainerCode()).collect(Collectors.toList());
            containerList = containerList.stream().distinct().collect(Collectors.toList());
            List<String> removeContainerList = new ArrayList<>();
            for(String containerCode : containerList) {
                Container container = containerService.getContainerByCode(containerCode, warehouseCode);
                if(!container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_SOME)) {
                    removeContainerList.add(containerCode);
                }
            }
            containerList.removeAll(removeContainerList);

            //获取到MaterialInfo在库存集合
//            inventoryDetailList.
            ERPShipmentContainer shipmentContainer = new ERPShipmentContainer();
            shipmentContainer.setShipmentDetail(shipmentDetail);
            shipmentContainer.setShipQty(shipmentDetail.getShipQty());
            shipmentContainer.setRequestQty(shipmentDetail.getRequestQty());
            shipmentContainer.setHavInventory(false);
            shipmentContainer.setMaterialInfo(materialInfo);
            shipmentContainer.setContainers(containerList);
            shipmentContainer.setOrderCode(order);
            addERPCombination(shipmentContainer);
        }

        return AjaxResult.success("保存出库组盘信息成功");
    }

    /**
     * 同步部门数据
     */
    @Override
    public void dept() {
        K3CloudApi api = new ExtK3CloudApi();
        QueryParam param = new QueryParam()
                .setFormId("BD_Department")
                .setFieldKeys("FDEPTID,FNumber,FName,FParentID")
                .setFilterString("fdocumentStatus=\'C\' and FUseOrgId.FNumber='102' and FForbidStatus=\'A\'")
                .setOrderString("FDEPTID ASC");
        List<ERPDept> datas = null;
        try {
            datas = api.executeBillQuery(param, ERPDept.class);
        } catch (Exception e) {
            e.printStackTrace();
        }

        //erp 部门集合
        List<Dept> depts = new ArrayList<>();
        for (ERPDept data : datas) {
            Dept dept = new Dept();
            dept.setDeptName(data.getName());
            dept.setId(data.getDeptId());
            dept.setCode(data.getNumber());
            dept.setParentId(data.getParentId());
            depts.add(dept);
        }

        Set<String> collect = depts.stream().map(Dept::getCode).collect(Collectors.toSet());
        do{
            Iterator<Dept> iterator = depts.iterator();
            //迭代erp 部门
            while (iterator.hasNext()){
                //获取部门
                Dept dept = iterator.next();
                //获取部门编码
                String code = dept.getCode();
                //查询是否有该部门
                Dept dept1 = deptService.selectDepts(code);
                //没有 新增 有就修改
                if(dept1 == null){
                    //判断erp部门有没有父部门id 有else查找父部门 没有就开新的分支
                    Integer parentId = dept.getParentId();
                    if(parentId==0){
                        dept.setParentId(0);
                        dept.setAncestors("0");
                        dept.setOrderNum("0");
                        boolean save = deptService.save(dept);
                        if(save){
                            collect.remove(code);
                        }
                        //减少下次循环的次数
                        iterator.remove();
                    }else{
                        //获取父部门判断是否为null
                        Dept parentDept = deptService.getById(parentId);
                        //判断 为null 进入下次循环
                        if(parentDept!=null){
                            dept.setAncestors(parentDept.getAncestors() + "," + parentDept.getId());
                            //显示排序 序号
                            int orderNum = Integer.valueOf(parentDept.getOrderNum()) + 1;
                            dept.setOrderNum(""+orderNum);
                            boolean save = deptService.save(dept);
                            if(save){
                                collect.remove(code);
                            }
                            iterator.remove();
                        }
                    }
                }else{
                    //修改 部门名称
                    dept1.setDeptName(dept.getDeptName());
                    //修改父部门
                    dept1.setParentId(dept.getParentId());
                    //查询修改后 部门是否存在
                    Dept superDept = deptService.selectDeptById(dept1.getParentId());
                    if(superDept!=null){
                        dept1.setAncestors(superDept.getAncestors() + "," + dept.getParentId());
                        dept1.setOrderNum(Integer.valueOf(superDept.getOrderNum())+1+"");
                    }else {
                        //大于0 表示该部门 父部门发生改变 父部门还没有录入跳过 进入下次循环
                        if(dept1.getParentId()>0){
                            continue;
                        }
                        dept1.setAncestors("0");
                        dept1.setOrderNum("0");
                    }
                    boolean save = deptService.saveOrUpdate(dept);
                    if(save){
                        collect.remove(code);
                    }
                    iterator.remove();
                }
            }
        }while (collect.size()>0);
    }
    /**
     * 同步用户数据
     */
    @Override
    public void user() {
        K3CloudApi api = new ExtK3CloudApi();
        QueryParam param = new QueryParam()
                .setFormId("BD_Empinfo")
                .setFieldKeys("FID,FName,FNumber,FPostDept,FCreateDate,FModifyDate")
                .setFilterString("fdocumentStatus=\'C\' and FUseOrgId.FNumber='102' and FForbidStatus=\'A\'")
                .setOrderString("FID ASC")
                .setLimit(0);
        List<ERPUser> datas = null;
        try {
            datas = api.executeBillQuery(param, ERPUser.class);
        } catch (Exception e) {
            e.printStackTrace();
        }

        //通过json获取员工对象集合 获取key相同的数据
        Gson gson = new Gson();
        String jsonStr = gson.toJson(datas);
        //erp 员工集合
        List<User> userList = Arrays.asList(gson.fromJson(jsonStr, User[].class));

        System.out.println("a");
        for (User user : userList) {
            basicDataApiService.user(user);
        }
    }
    /**
     * 同步客户数据
     */
    @Override
    public void customer() {
        K3CloudApi api = new ExtK3CloudApi();
        QueryParam param = new QueryParam()
                .setFormId("BD_Customer")
                .setFieldKeys("FCUSTID,FName,FNumber,FCOUNTRY,FPROVINCIAL,FCreateDate,FModifyDate")
                .setFilterString("fdocumentStatus=\'C\' and FUseOrgId.FNumber='102' and FForbidStatus=\'A\'")
                .setOrderString("FModifyDate DESC")
                .setLimit(0);
        List<ERPCustmer> datas = null;
        try {
            datas = api.executeBillQuery(param, ERPCustmer.class);
        } catch (Exception e) {
            e.printStackTrace();
        }

        //通过json获取客户对象集合 获取key相同的数据
        Gson gson = new Gson();
        String jsonStr = gson.toJson(datas);
        //erp 客户集合
        List<Customer> userList = Arrays.asList(gson.fromJson(jsonStr, Customer[].class));

        LambdaQueryWrapper<Customer> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(Customer::getEnable,true);
        //获取本地 客户集合
        List<Customer> list = customerService.list(queryWrapper);

        //客户id
        List<String> idList = list.stream().map(t -> t.getCode()).collect(Collectors.toList());
        //erp客户id
        List<String> erpIdList = userList.stream().map(t -> t.getCode()).collect(Collectors.toList());

        //新增客户id集合
        List<String> addList = new ArrayList<>();

        //判断id
        for (String erpId : erpIdList) {
            if(!idList.contains(erpId)){
                addList.add(erpId);
            }
        }
        //
        List<Customer> userList1 = new ArrayList<>();
        //对比 修改 保存 客户属性
        for (Customer user1 : userList) {
            user1.setWarehouseCode("CS0001");
            user1.setCompanyCode("JY");
            user1.setCreatedBy("ERP系统");
            userList1.add(user1);
        }
        if(userList1.size()>0){
            customerService.truncateTable();
        }
        customerService.saveOrUpdateBatch(userList1);
    }

    @Override
    public void material() {
        K3CloudApi api = new ExtK3CloudApi();
        QueryParam param = new QueryParam()
                .setFormId("BD_MATERIAL")
                .setFieldKeys("FMATERIALID,FCREATEORGID,FNUMBER,fUseOrgId,FName,FSpecification,F_CH_Square,F_CH_PieceWeight,FIsBatchManage,FIsEnable1,FAuxPropertyId,FCreateDate,FMODIFYDATE")
                .setOrderString("FMODIFYDATE DESC")
                .setFilterString("fdocumentStatus=\'C\' and FUseOrgId.FNumber='102' and FForbidStatus=\'A\'")
                .setStartRow(0)
                .setLimit(0);
        List<ERPMaterial> datas = null;
        try {
            datas = api.executeBillQuery(param, ERPMaterial.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
        List<ERPMaterial> newDatas= new ArrayList<>();
        ERPMaterial erpMaterial = null;
        //去重 erp物料数据
        for (ERPMaterial data : datas) {
            //material为null 或者materialId 实例化erp物料对象
            if(erpMaterial != null ){
                if(!erpMaterial.getNumber().equals(data.getNumber())){
                    newDatas.add(erpMaterial);
                }
            }
            if(erpMaterial == null || !erpMaterial.getNumber().equals(data.getNumber())){
                erpMaterial = new ERPMaterial();
                erpMaterial.setMaterialId(data.getMaterialId());
                erpMaterial.setNumber(data.getNumber());
                erpMaterial.setName(data.getName());
                erpMaterial.setSpecification(data.getSpecification());
                erpMaterial.setPieceWeight(data.getPieceWeight());
                erpMaterial.setSquare(data.getSquare());
                if(com.huaheng.common.utils.StringUtils.isNotNull(data.getIsBatchManage())){
                    erpMaterial.setIsBatchManage(data.getIsBatchManage());
                }
                erpMaterial.setCreateDate(data.getCreateDate());
                erpMaterial.setModifyDate(data.getModifyDate());
            }
            if(com.huaheng.common.utils.StringUtils.isNotNull(data.isColor())){
                erpMaterial.setColor(data.isColor());
            }
            if(com.huaheng.common.utils.StringUtils.isNotNull(data.isCustProductSize())){
                erpMaterial.setCustProductSize(data.isCustProductSize());
            }
            if(com.huaheng.common.utils.StringUtils.isNotNull(data.isLevel())){
                erpMaterial.setLevel(data.isLevel());
            }
            if(com.huaheng.common.utils.StringUtils.isNotNull(data.isProPackaging())){
                erpMaterial.setProPackaging(data.isProPackaging());
            }
            if(com.huaheng.common.utils.StringUtils.isNotNull(data.isProductSchedule())){
                erpMaterial.setProductSchedule(data.isProductSchedule());
            }
        }
        newDatas.add(erpMaterial);

        Gson gson = new Gson();
        String jsonStr = gson.toJson(newDatas);
        //erp 物料集合
        List<Material> materialList = Arrays.asList(gson.fromJson(jsonStr, Material[].class));

        //新增集合
        List<Material> addMaterialList = new ArrayList<>();
        //设置保存
        for (Material material1 : materialList) {
            material1.setCreatedBy("ERP系统");
            material1.setCompanyCode("JY");
            material1.setWarehouseCode("CS0001");
            material1.setType("product");
            material1.setDaysToExpire(0);
            material1.setTrackSerialNum(0);
            material1.setAutoGenSerialNum(0);
            material1.setMinShelfLifeDays(0);
            material1.setEnable(true);
            material1.setVersion(0);
            material1.setDeleted(false);
            material1.setIsMix(true);
            addMaterialList.add(material1);
        }
        if(datas.size()>0){
            materialService.truncateTable();
        }
        materialService.insertBatch(addMaterialList);
    }

    @Override
    public void proPackaging() {
        K3CloudApi api = new ExtK3CloudApi();
        QueryParam param = new QueryParam()
                .setFormId("CH_ProPackaging")
                .setFieldKeys("FID,FNumber,FName,FDescription,FPrice,FPieceBox,F_CH_Pallet,F_CH_Boxs")
                .setFilterString("fdocumentStatus=\'C\' and FUseOrgId.FNumber='101' and FForbidStatus=\'A\'")
                .setOrderString("FID ASC")
                .setLimit(0);
        List<ProPackaging> datas = null;
        try {
            datas = api.executeBillQuery(param, ProPackaging.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
        if(datas.size()>0){
            proPackagingService.truncateTable();
        }
        proPackagingService.insertBatch(datas);
    }

    @Override
    public void productSize() {
        //基本物料数据获取器
        K3CloudApi api = new ExtK3CloudApi();
        QueryParam param = new QueryParam()
                .setFormId("CH_CustProductSize")
                .setFieldKeys("Fnumber,FSize,fname,fdocumentStatus,fcreateDate,FUnitArea,fmodifyDate,F_CH_longSide,F_CH_shortSide,FforbidStatus,FcreateOrgId.Fnumber,FuseOrgId.Fnumber,F_CH_group,Fdescription")
                .setFilterString("fdocumentStatus=\'C\' and FForbidStatus=\'A\'  and FUseOrgId.FNumber='100'")
                .setStartRow(0)
                .setLimit(0);
        List<ProductSize> datas = null;
        try {
            datas = api.executeBillQuery(param, ProductSize.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
        if(datas.size()>0){
            productSizeService.truncateTable();
        }
        productSizeService.insertBatch(datas);
    }

    @Override
    public void stock() {
        K3CloudApi api = new ExtK3CloudApi();
        QueryParam param = new QueryParam()
                .setFormId("BD_STOCK")
                .setFieldKeys("fStockId,fName,fNumber,fisOpenLocation,FUseOrgId.FNumber")
                .setFilterString("fdocumentStatus=\'C\' and FUseOrgId.FNumber='102' and FForbidStatus=\'A\'")
                .setOrderString("fStockId ASC")
                .setLimit(0);
        List<Stock> stocks = null;
        try {
            stocks = api.executeBillQuery(param, Stock.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
        if(stocks.size()>0){
            stockService.truncateTable();
        }
        stockService.insertBatch(stocks);
    }

    @Override
    public void flexValues() {
        K3CloudApi api = new ExtK3CloudApi();
        QueryParam param = new QueryParam()
                .setFormId("bd_flexvalues")
                .setFieldKeys("fid,fName,fNumber,fflexValueNumber,fflexValueName,FUseOrgId.FNumber")
                .setFilterString("fdocumentStatus=\'C\' and FUseOrgId.FNumber='101' and FForbidStatus=\'A\'")
                .setOrderString("fid ASC")
                .setLimit(0);
        List<FlexValues> flexValues = null;
        try {
            flexValues = api.executeBillQuery(param, FlexValues.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
        if(flexValues.size()>0){
            flexValuesService.truncateTable();
        }
        flexValuesService.insertBatch(flexValues);
    }

    @Override
    public void unit() {
        K3CloudApi api = new ExtK3CloudApi();
        QueryParam param = new QueryParam()
                .setFormId("bd_unit")
                .setFieldKeys("funitid,fName,fNumber")
                .setFilterString("FDocumentStatus=\'C\' and FForbidStatus=\'A\'")
                .setOrderString("funitid ASC")
                .setLimit(0);
        List<Unit> units = null;
        try {
            units = api.executeBillQuery(param, Unit.class);
        } catch (Exception e) {
            e.printStackTrace();
        }

        if(units.size()>0){
            unitService.truncateTable();
        }
        unitService.insertBatch(units);
    }

    @Override
    public void bosAssistantDetail() {
        //基本物料数据获取器
        K3CloudApi api = new ExtK3CloudApi();
        QueryParam param = new QueryParam()
                .setFormId("BOS_ASSISTANTDATA_DETAIL")
                .setFieldKeys("Fid.Fnumber,FdataValue,FNUMBER,fdocumentStatus,FisSysPreset,Fdescription")
                .setFilterString("fdocumentStatus=\'C\' and FForbidStatus=\'A\' and FId.FNumber in (\'level\',\'colour\',\'QTCKLX\',\'QTRKLX\',\'SCLLLX\')")
                .setStartRow(0)
                .setLimit(0);
        List<BosAssistantDetail> datas = null;
        try {
            datas = api.executeBillQuery(param, BosAssistantDetail.class);
        } catch (Exception e) {
            e.printStackTrace();
        }

        Set<String> set = new HashSet<>();
        //去重
        List<BosAssistantDetail> newdates = new ArrayList<>();
        for (BosAssistantDetail data : datas) {
            String number = data.getNumber()+ data.getIdNumber();
            if(set.contains(number)){
                continue;
            }
            newdates.add(data);
            set.add(number);
        }
        //清楚
        if(newdates.size()>0){
            bosAssistantDetailService.truncateTable();
        }
        bosAssistantDetailService.insertBatch(newdates);
    }

    @Override
    public void productSchedule() {
        K3CloudApi api = new ExtK3CloudApi();
        QueryParam param = new QueryParam()
                .setFormId("CH_ProductSchedule")
                .setFieldKeys("FNumber,FName,FDocumentStatus,F_CH_Date,F_CH_Customer.FNumber,FCreateDate,FModifyDate,F_CH_IsClose,F_PKMX_DateNew,F_PKMX_CustOutDate,F_CH_Dept.FNumber")
                .setFilterString("fdocumentStatus=\'C\' and FForbidStatus=\'A\' and F_CH_IsClose=0 and FCreateOrgId.Fnumber='100'")
                .setOrderString("FCreateDate DESC")
                .setStartRow(0)
                .setLimit(0);
        List<ProductScheduleHeader> datas = null;
        try {
            datas = api.executeBillQuery(param, ProductScheduleHeader.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
        if(datas.size()>0){
            productScheduleHeaderService.truncateTable();
        }
        productScheduleHeaderService.insertBatch(datas);

        QueryParam detailParam = new QueryParam()
                .setFormId("CH_ProductSchedule")
                .setFieldKeys("fid,FNumber,FmaterialId.FNumber,F_CH_Assistant.FNumber,F_CH_Size.FNumber,F_CH_Packaging.FNumber,F_CH_NoOrderNum,F_CH_NoInNum,F_CH_StockID.FNumber,F_CH_FLot,F_CH_area,F_CH_UnitArea,F_CH_FBillNo,F_CH_AssistQty1,F_CH_UnitWeight,F_CH_Weight,F_CH_Remark2")
                .setFilterString("fdocumentStatus=\'C\' and FForbidStatus=\'A\' and F_CH_IsClose=0 and FCreateOrgId.Fnumber='100'")
                .setOrderString("FCreateDate DESC")
                .setStartRow(0)
                .setLimit(0);
        List<ProductScheduleDetail> detailDatas = null;
        try {
            detailDatas = api.executeBillQuery(detailParam, ProductScheduleDetail.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
        if(detailDatas.size()>0){
            productScheduleDetailService.truncateTable();
        }
        productScheduleDetailService.insertBatch(detailDatas);
    }



    @Override
    public AjaxResult receiptMethod(String receiptHeaderId){
        ReceiptHeader header = receiptHeaderService.getById(receiptHeaderId);
        return receiptMethod(header);
    }

    /**
     * 回传入库单数据
     * @param receiptHeader 任务头
     */
    @Transactional
    public AjaxResult receiptMethod(ReceiptHeader receiptHeader){
        if(receiptHeader==null){
            return AjaxResult.error("入库单为空");
        }
        if(receiptHeader.getFirstStatus()==800 && receiptHeader.getLastStatus()==800){
            //入库数据
            Object receiptData;
            //回传标识
            String formId = "";
            //获取回传入库信息
            receiptData = param(receiptHeader,receiptHeader.getReceiptType());
            ExtSaveParam saveParam = new ExtSaveParam<>(receiptData);

            K3CloudApi api = new ExtK3CloudApi();
            //返回结果
            SaveResult spInStock = null;
//            Gson gson = new Gson();
            try {
                if(SingleReceipt.class.isAssignableFrom(receiptData.getClass())){
                    formId = "SP_InStock";
                    spInStock = api.save(formId,saveParam, InvokeMode.Syn);
                }else if(OtherReceipt.class.isAssignableFrom(receiptData.getClass())){
                    formId = "STK_MISCELLANEOUS";
                    spInStock = api.save(formId,saveParam,InvokeMode.Syn);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

                if(spInStock.getResult().getResponseStatus().isIsSuccess()){
                    receiptHeader.setFirstStatus(QuantityConstant.RECEIPT_RECEIVE_SUCCESS);
                    receiptHeader.setLastStatus(QuantityConstant.RECEIPT_RECEIVE_SUCCESS);
                    System.out.println("aaaaaaaaaaaaaaaaaaaaaaa");
                    System.out.println("aaaaaaaaaaaaaaaaaaaaaaa");
                    System.out.println("aaaaaaaaaaaaaaaaaaaaaaa");
                    return AjaxResult.success("回传成功");
                }else{
                    ArrayList<RepoError> errors = spInStock.getResult().getResponseStatus().getErrors();
                    String errorStr = "";
                    for (RepoError error : errors) {
                        errorStr = error.getFieldName()+"=="+error.getMessage()+"==";
                    }
                    return AjaxResult.error(errorStr);
                }
        }
        return AjaxResult.error("入库单异数据问题");
    }

    @Override
    public AjaxResult shipmentMethod(String shipmentHeaderId){
        ShipmentHeader header = shipmentHeaderService.getById(shipmentHeaderId);
        return shipmentMethod(header);
    }
    /**
     * 回传出库单数据
     * @param shipmentHeader 任务头
     */
    @Transactional
    public AjaxResult shipmentMethod(ShipmentHeader shipmentHeader){
        if(shipmentHeader==null){
            return AjaxResult.error("出库单为空");
        }
        if(shipmentHeader.getFirstStatus()==500 && shipmentHeader.getLastStatus()==500){
            //入库数据
            Object receiptData;
            //回传标识
            String formId = "";
            //回传器
            SaveParam<Object> saveParam = null;
            //获取回传出库信息
            receiptData = param(shipmentHeader,shipmentHeader.getShipmentType());
            //回传model
            saveParam = new ExtSaveParam<>(receiptData);

            K3CloudApi api = new ExtK3CloudApi();
            if(SingleShipment.class.isAssignableFrom(receiptData.getClass())){
                formId = "SP_PickMtrl";
                saveParam = new ExtSaveParam<>(receiptData);
            }else if(OtherShipment.class.isAssignableFrom(receiptData.getClass())){
                formId = "STK_MisDelivery";
                saveParam = new ExtSaveParam<>(receiptData);
            }
            //返回结果
            SaveResult spInStock = null;
            try {
                spInStock = api.save(formId,saveParam,InvokeMode.Syn);
            } catch (Exception e) {
                e.printStackTrace();
            }
            if(spInStock.getResult().getResponseStatus().isIsSuccess()){
                shipmentHeader.setFirstStatus(QuantityConstant.SHIPMENT_RECEIVE_SUCCESS);
                shipmentHeader.setLastStatus(QuantityConstant.SHIPMENT_RECEIVE_SUCCESS);
                return AjaxResult.success("回传成功");
            }else{
                ArrayList<RepoError> errors = spInStock.getResult().getResponseStatus().getErrors();
                String errorStr = "";
                for (RepoError error : errors) {
                    errorStr = error.getFieldName()+"=="+error.getMessage()+"==";
                }
                return AjaxResult.error(errorStr);
            }
        }
        return AjaxResult.error("出库单数据问题");
    }

    /**
     * 判断入库单类型返回 回传入库信息
     * @param receiptHeader 入库头
     * @param billType 单据类型
     * @return 回传入库信息
     */
    private Object param(ReceiptHeader receiptHeader,String billType){
        Object returnReceipt;
        switch (billType) {
            //简单生产入库单
            case QuantityConstant.BILL_TYPE_RECEIPT_SINGLE:
                returnReceipt = buildSingleReceiptHead(receiptHeader);
                break;
            //其他生产入库单
            case QuantityConstant.BILL_TYPE_RECEIPT_OTHER:
                returnReceipt = buildOtherReceiptHead(receiptHeader);
                break;
            default:
                throw new ServiceException("不支持的任务类型");
        }
        //获取入库单数据
        LambdaQueryWrapper<ReceiptDetail> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(ReceiptDetail::getReceiptId,receiptHeader.getId());
        //入库明细集合
        List<ReceiptDetail> details = receiptDetailService.list(queryWrapper);
        //回传入库明细集
        List<ReceiptBillEntity> receiptInfos = getReceiptEntities(details);

        //设置回传入库明细集
        Class<?> receiptCls = returnReceipt.getClass();

        if(OtherReceipt.class.isAssignableFrom(receiptCls)){
            OtherReceipt otherReceipt = (OtherReceipt)returnReceipt;
            otherReceipt.setEntity(receiptInfos);
            //重新赋值给 returnReceipt
            returnReceipt = otherReceipt;
        }else if(SingleReceipt.class.isAssignableFrom(receiptCls)){
            SingleReceipt singleReceipt = (SingleReceipt)returnReceipt;
            singleReceipt.setEntity(receiptInfos);
            //重新赋值给 returnReceipt
            returnReceipt = singleReceipt;
        }
        return returnReceipt;
    }

    /**
     * 获取
     * 判断出库单类型返回 回传出库信息
     * @param shipmentHeader 出库头
     * @param billType 单据类型
     * @return 回传出库信息
     */
    private Object param(ShipmentHeader shipmentHeader,String billType){
        Object returnShipment;
        switch (billType) {
            //简单生产退料单
            case QuantityConstant.BILL_TYPE_SHIPMENT_SINGLE:
                returnShipment = buildSingleShipmentHead(shipmentHeader);
                break;
            //其他生产退料单
            case QuantityConstant.BILL_TYPE_SHIPMENT_OTHER:
                returnShipment = buildOtherShipmentHead(shipmentHeader);
                break;
            default:
                throw new ServiceException("不支持的任务类型");
        }
        //获取退料单数据
        LambdaQueryWrapper<ShipmentDetail> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(ShipmentDetail::getShipmentId,shipmentHeader.getId());
        //出库明细集合
        List<ShipmentDetail> details = shipmentDetailService.list(queryWrapper);

        //回传出库明细集
        List<ShipmentBillEntity> billEntities = getShipmentEntities(details);

        //设置回传出库明细集
        Class<?> receiptCls = returnShipment.getClass();
        if(OtherShipment.class.isAssignableFrom(receiptCls)){
            OtherShipment otherShipment = (OtherShipment)returnShipment;
            otherShipment.setEntity(billEntities);
            //重新赋值给 returnShipment
            returnShipment = otherShipment;
        }else if(SingleShipment.class.isAssignableFrom(receiptCls)){
            SingleShipment singleShipment = (SingleShipment)returnShipment;
            singleShipment.setEntity(billEntities);
            //重新赋值给 returnShipment
            returnShipment = singleShipment;
        }
        return returnShipment;
    }

    /**
     * 获取回传入库明细数据 通过入库单明细集
     * @param details 入库单明细集
     */
    public List<ReceiptBillEntity> getReceiptEntities(List<ReceiptDetail> details){
        List<ReceiptBillEntity> billEntities = new ArrayList<>();
        if(details.size()>0){
            for (ReceiptDetail detail : details) {
                ReceiptBillEntity entity = getEntity(detail);
                billEntities.add(entity);
            }
        }
        return billEntities;
    }
    /**
     * 获取回传出库明细数据 通过出库单明细集
     * @param details 出库单明细集
     */
    public List<ShipmentBillEntity> getShipmentEntities(List<ShipmentDetail> details){
        List<ShipmentBillEntity> billEntities = new ArrayList<>();
        if(details.size()>0){
            for (ShipmentDetail detail : details) {
                ShipmentBillEntity entity = getEntity(detail);
                billEntities.add(entity);
            }
        }
        return billEntities;
    }

    /**
     * 通过参数入库明细单 获取单据体
     * @param detail 入库明细单
     * @return 返回 BillEntity 单据体
     */
    public ReceiptBillEntity getEntity(ReceiptDetail detail){
        ReceiptBillEntity billEntity = new ReceiptBillEntity();
        //设值辅助属性
        LambdaQueryWrapper<Material> queryWrapper1 = Wrappers.lambdaQuery();
        queryWrapper1.eq(Material::getCode,detail.getMaterialCode());
        Material material = materialService.getOne(queryWrapper1);

        // 传入物料判断是否添加辅助属性
        AuxProperty auxProperty = new AuxProperty(material);
        //包装
        ConvertObj proPackaging= ConvertObjFactory.newInstance(detail.getProPackaging());
        //排产订单
        ConvertObj productScheduleHeader = ConvertObjFactory.newInstance(detail.getProductSchedule());
        //色号
        ConvertObj color= ConvertObjFactory.newInstance(detail.getColor());
        //等级
        ConvertObj level = ConvertObjFactory.newInstance(detail.getLevel());
        //尺寸
        ConvertObj productSize = ConvertObjFactory.newInstance(detail.getLevel());

        auxProperty.setColor(color);
        auxProperty.setLevel(level);
        auxProperty.setProPackaging(proPackaging);
        auxProperty.setProductSize(productSize);
        auxProperty.setProductSchedule(productScheduleHeader);

        //base attr
        //物料编码
        billEntity.setMaterial(ConvertObjFactory.newInstance(detail.getMaterialCode()));
        //辅助属性
        billEntity.setProperty(auxProperty);
        //单位
        billEntity.setUnit(ConvertObjFactory.newInstance(detail.getMaterialUnit()));
        //收货仓库
        String stockId = detail.getStockId();
        billEntity.setStockId(ConvertObjFactory.newInstance(stockId));
        //批号
        billEntity.setLotId(ConvertObjFactory.newInstance(detail.getBatch()));
        //货主类型
        billEntity.setOwnerType("BD_OwnerOrg");
        //货主
        billEntity.setOwnerId(ConvertObjFactory.newInstance(QuantityConstant.JY));
        //库存状态
        billEntity.setStockstatusId(ConvertObjFactory.newInstance("KCZT01_SYS"));
        //保管者类型
        billEntity.setKeeperType("BD_KeeperOrg");
        //保管者
        billEntity.setKeeperId(ConvertObjFactory.newInstance(QuantityConstant.JY));
        //库存组织
        billEntity.setOrgId(ConvertObjFactory.newInstance(QuantityConstant.JY));


        //other attr
        //默认生产车间
        //就一个可选测试
        billEntity.setWorkShopId1(ConvertObjFactory.newInstance("BM000340"));
        //箱数
        billEntity.setBox(detail.getTotalQty().intValue());
        //生产编号
        billEntity.setProductNo(detail.getBatch());
        //基本单位实收数量
        billEntity.setBaseRealQty(detail.getTotalQty());
        //实收数量
        billEntity.setRealQty(detail.getTotalQty());
        //重量
        BigDecimal pieceWeight = material.getPieceWeight();
        billEntity.setWeight(pieceWeight.multiply(detail.getTotalQty()));
        return billEntity;
    }
    /**
     * 通过参数出库明细单 获取单据体
     * @param detail 出库明细单
     * @return 返回 BillEntity 单据体
     */
    public ShipmentBillEntity getEntity(ShipmentDetail detail){
        ShipmentBillEntity billEntity = new ShipmentBillEntity();
        //设值辅助属性
        LambdaQueryWrapper<Material> queryWrapper2 = Wrappers.lambdaQuery();
        queryWrapper2.eq(Material::getCode,detail.getMaterialCode());
        Material material = materialService.getOne(queryWrapper2);
//        LambdaQueryWrapper<InventoryDetail> queryWrapper1 = Wrappers.lambdaQuery();
//        queryWrapper1.eq(InventoryDetail::getMaterialCode,detail.getMaterialCode())
//                .gt(InventoryDetail::getTaskQty,0)
//                .gt(InventoryDetail::getBatch,detail.getBatch());
//        List<InventoryDetail> list = inventoryDetailService.list(queryWrapper1);
//        InventoryDetail inventoryDetail = list.get(0);
        AuxProperty auxProperty = new AuxProperty(material);
        ConvertObj proPackaging= ConvertObjFactory.newInstance(detail.getProPackaging());
        ConvertObj productScheduleHeader = ConvertObjFactory.newInstance(detail.getProductSchedule());
        ConvertObj color= ConvertObjFactory.newInstance(detail.getColor());
        ConvertObj level = ConvertObjFactory.newInstance(detail.getLevel());
        ConvertObj productSize = ConvertObjFactory.newInstance(detail.getLevel());
        auxProperty.setColor(color);
        auxProperty.setLevel(level);
        auxProperty.setProPackaging(proPackaging);
        auxProperty.setProductSize(productSize);
        auxProperty.setProductSchedule(productScheduleHeader);

        //base attr
        //物料编码
        billEntity.setMaterial(ConvertObjFactory.newInstance(detail.getMaterialCode()));
        //辅助属性
        billEntity.setProperty(auxProperty);
        //单位
        billEntity.setUnit(ConvertObjFactory.newInstance(detail.getMaterialUnit()));
        //收货仓库
        String stockId = detail.getStockId();
        billEntity.setStockId(ConvertObjFactory.newInstance(stockId));
        //批号
        billEntity.setLotId(ConvertObjFactory.newInstance(detail.getBatch()));
        //货主类型
        billEntity.setOwnerType("BD_OwnerOrg");
        //货主
        billEntity.setOwnerId(ConvertObjFactory.newInstance(QuantityConstant.JY));
        //库存状态
        billEntity.setStockstatusId(ConvertObjFactory.newInstance("KCZT01_SYS"));
        //保管者类型
        billEntity.setKeeperType("BD_KeeperOrg");
        //保管者
        billEntity.setKeeperId(ConvertObjFactory.newInstance(QuantityConstant.JY));
        //库存组织
        billEntity.setOrgId(ConvertObjFactory.newInstance(QuantityConstant.JY));


        //other attr
        //实发数量
        billEntity.setBaseQty(detail.getShipQty());
        //批号
        billEntity.setLot(ConvertObjFactory.newInstance(detail.getBatch()));
        //生产编号影响成本
        billEntity.setIsAffectCost(false);
        //库存单位
        billEntity.setStockUnitId(ConvertObjFactory.newInstance(detail.getMaterialUnit()));
        //基本单位
        billEntity.setStockUnitId(ConvertObjFactory.newInstance(detail.getMaterialUnit()));
        //产品货主类型
        billEntity.setParentOwnerTypeId("BD_OwnerOrg");
        //产品货主
        billEntity.setStockUnitId(ConvertObjFactory.newInstance(QuantityConstant.JY));
        //生产领料类型
        billEntity.setSclllx(ConvertObjFactory.newInstance(detail.getSclllx()));
        return billEntity;
    }

    /**
     * 构建其他入库头信息
     * @param receiptHeader 入库头
     * @return object对象
     */
    public Object buildOtherReceiptHead(ReceiptHeader receiptHeader){
        OtherReceipt otherReceipt = new OtherReceipt();
        //单据类型
        otherReceipt.setBillTypeId(ConvertObjFactory.newInstance(receiptHeader.getReceiptType()));
        //库存组织
        otherReceipt.setStockOrgId(ConvertObjFactory.newInstance(QuantityConstant.JY));
        //货主
        otherReceipt.setOwnerIdHead(ConvertObjFactory.newInstance(QuantityConstant.JY));
        //供应商
        otherReceipt.setSupplierId(ConvertObjFactory.newInstance("001.0001"));
        //部门
        otherReceipt.setDeptId(ConvertObjFactory.newInstance("102.BM000279"));
        //仓管员
        otherReceipt.setStockId(ConvertObjFactory.newInstance("102.YG2021054"));
        //本位币
        otherReceipt.setStockId(ConvertObjFactory.newInstance("PRE001"));
        //其他入库类型
        otherReceipt.setQtrklx(ConvertObjFactory.newInstance("001"));
        return otherReceipt;
    }

    /**
     * 构建简单入库头信息
     * @param receiptHeader 入库头
     * @return object对象
     */
    public Object buildSingleReceiptHead(ReceiptHeader receiptHeader){

        SingleReceipt singleReceipt = new SingleReceipt();
        //单据类型
        singleReceipt.setBillType(ConvertObjFactory.newInstance(receiptHeader.getReceiptType()));
        //生产组织
        singleReceipt.setProdOrgId(ConvertObjFactory.newInstance(QuantityConstant.JY));
        //货主
        singleReceipt.setOwnerId0(ConvertObjFactory.newInstance(QuantityConstant.JY));
        //入库组织
        singleReceipt.setStockOrgId(ConvertObjFactory.newInstance(QuantityConstant.JY));
        //时间
        singleReceipt.setDate(new Date());

        String loginName = receiptHeader.getCreatedBy();
        LambdaQueryWrapper<User> queryWrapper2 = Wrappers.lambdaQuery();
        queryWrapper2.eq(User::getLoginName,loginName);
        User stock = userService.getOne(queryWrapper2);

        //获取仓管员编码
        String number = stock.getNumber();
        singleReceipt.setStockId(ConvertObjFactory.newInstance(number));
        //仓管员
        singleReceipt.setDescription("666");
        //本位币.
        singleReceipt.setBaseCurrId(ConvertObjFactory.newInstance("PRE001"));
        return singleReceipt;

    }

    public Object buildSingleShipmentHead(ShipmentHeader shipmentHeader){
        SingleShipment singleShipment = new SingleShipment();
        //单据类型
        singleShipment.setBillType(ConvertObjFactory.newInstance(shipmentHeader.getShipmentType()));
        //时间
        singleShipment.setDate(new Date());
        //入库组织
        singleShipment.setStockOrgId(ConvertObjFactory.newInstance(QuantityConstant.JY));
        //本位币.
        singleShipment.setBaseCurrId(ConvertObjFactory.newInstance("PRE001"));
        //货主类型
        singleShipment.setOwnerTypeIdHead("BD_OwnerOrg");
        //货主
        singleShipment.setOwnerId0(ConvertObjFactory.newInstance(QuantityConstant.JY));
        //生产组织
        singleShipment.setProdOrgId(ConvertObjFactory.newInstance(QuantityConstant.JY));

        String loginName = shipmentHeader.getCreatedBy();
        LambdaQueryWrapper<User> queryWrapper2 = Wrappers.lambdaQuery();
        queryWrapper2.eq(User::getLoginName,loginName);
        User stock = userService.getOne(queryWrapper2);
        String number = stock.getNumber();
        //仓管员
        singleShipment.setStockId(ConvertObjFactory.newInstance(number));


        //other
        //生产车间
        singleShipment.setWorkShopId(ConvertObjFactory.newInstance("BM000340"));
        //业务类型
        singleShipment.setBizType("NORMAL");
        return singleShipment;
    }

    public Object buildOtherShipmentHead(ShipmentHeader shipmentHeader){
        OtherShipment otherShipment = new OtherShipment();
        //base
        //单据类型
        otherShipment.setBillTypeId(ConvertObjFactory.newInstance(shipmentHeader.getShipmentType()));
        //库存组织
        otherShipment.setStockOrgId(ConvertObjFactory.newInstance(QuantityConstant.JY));
        //库存方向
        otherShipment.setStockDirect("GENERAL");
        //日期
        otherShipment.setDate(new Date());
        //部门
        otherShipment.setDeptId(ConvertObjFactory.newInstance("102.BM000279"));
        //仓管员
        otherShipment.setStockId(ConvertObjFactory.newInstance("102.YG2021054"));
        //货主类型
        otherShipment.setOwnerTypeIdHead("BD_OwnerOrg");
        //货主
        otherShipment.setOwnerIdHead(ConvertObjFactory.newInstance(QuantityConstant.JY));
        //本位币
        otherShipment.setStockId(ConvertObjFactory.newInstance("PRE001"));

        //other
        //其他入库类型
        otherShipment.setQtcklx(ConvertObjFactory.newInstance("002"));
        // 客户
        otherShipment.setCustId(ConvertObjFactory.newInstance(shipmentHeader.getCustomerCode()));
        //供应商
        otherShipment.setSupplierId(ConvertObjFactory.newInstance("001.0001"));
        //收货人信息
        otherShipment.setReceive("receive");
        return otherShipment;
    }

    /**
     * 递归进行组盘 当出库单明细 的请求数量等于出库数量时,
     * 结束递归
     * 当请求数量小于
     * @param shipmentContainer
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    protected ERPShipmentContainer addERPCombination(ERPShipmentContainer shipmentContainer){
        BigDecimal shipQty = shipmentContainer.getShipQty();
        BigDecimal requestQty = shipmentContainer.getRequestQty();
        String orderCode = shipmentContainer.getOrderCode();
        ShipmentDetail shipmentDetail = shipmentContainer.getShipmentDetail();
        List<String> containers = shipmentContainer.getContainers();//该订单项目的所有物料托盘
        String color = shipmentContainer.getMaterialInfo().getColor();
        String level = shipmentContainer.getMaterialInfo().getLevel();
        String stack = shipmentContainer.getMaterialInfo().getStack();
        String batch = shipmentContainer.getMaterialInfo().getBatch();
        String materialCode = shipmentContainer.getMaterialInfo().getMaterialCode();

        String containerCode1 = containers.get(containers.size() - 1);
        Container container = containerService.getContainerByCode(containerCode1, "CS0001");
        String containerCode = container.getCode();
        String locationCode = container.getLocationCode();

        ShipmentContainerHeader shipmentContainerHeader = new ShipmentContainerHeader();
        shipmentContainerHeader.setWarehouseCode("CS0001");
        shipmentContainerHeader.setLocationCode(locationCode);
        shipmentContainerHeader.setCompanyCode("JY");
        shipmentContainerHeader.setContainerCode(containerCode);
        shipmentContainerHeader.setColor(color);//色号
        shipmentContainerHeader.setLevel(level);//等级
        shipmentContainerHeader.setOrderCode(orderCode);//订单编号
        shipmentContainerHeader.setBatch(batch);//批次
        shipmentContainerHeader.setMaterialCode(materialCode);//物料编码
        shipmentContainerHeader.setTaskType(QuantityConstant.TASK_TYPE_SORTINGSHIPMENT);
        shipmentContainerHeader.setStatus(QuantityConstant.SHIPMENT_CONTAINER_BUILD);
        shipmentContainerHeader.setStack(stack);//设置垛型
        shipmentContainerHeader.setCreatedBy("赋码系统");
        shipmentContainerHeader.setLastUpdatedBy("赋码系统");
        boolean result = shipmentContainerHeaderService.save(shipmentContainerHeader);
        if(!result){
            throw new ServiceException("保存出库组盘头失败");
        }
        //出库阻盘头完成
        containers.remove(containerCode1);//删除该托盘号

        List<InventoryDetail> inventoryList = inventoryDetailService.getInventoryList(containerCode, "CS0001");
        for (InventoryDetail inventoryDetail : inventoryList) {
            ShipmentContainerDetail shipmentContainerDetail = new ShipmentContainerDetail();
            String chipCode = inventoryDetail.getChipCode();
            shipmentContainerDetail.setInventoryId(inventoryDetail.getId());//设置库存明细id 用于取消配盘
            shipmentContainerDetail.setWarehouseCode(QuantityConstant.DEFAULT_WAREHOUSE);
            shipmentContainerDetail.setContainerCode(containerCode);
            shipmentContainerDetail.setLocationCode(inventoryDetail.getLocationCode());
            shipmentContainerDetail.setCompanyCode("JY");
            shipmentContainerDetail.setTaskType(QuantityConstant.TASK_TYPE_WHOLERECEIPT);
            shipmentContainerDetail.setChipCode(chipCode);
            shipmentContainerDetail.setMaterialCode(inventoryDetail.getMaterialCode());
            shipmentContainerDetail.setMaterialName(inventoryDetail.getMaterialName());
            shipmentContainerDetail.setMaterialSpec(inventoryDetail.getMaterialSpec());
            shipmentContainerDetail.setMaterialUnit(inventoryDetail.getMaterialUnit());
            shipmentContainerDetail.setLevel(level);
            shipmentContainerDetail.setColor(color);
            shipmentContainerDetail.setQty(new BigDecimal(1));
            shipmentContainerDetail.setBatch(batch);
            shipmentContainerDetail.setShipmentCode(shipmentDetail.getShipmentCode());
            shipmentContainerDetail.setBoxCode(inventoryDetail.getBoxCode());
            shipmentContainerDetail.setShipmentType("SC");
            shipmentContainerDetail.setInventorySts("good");
            shipmentContainerDetail.setCreatedBy("赋码系统");
            shipmentContainerDetail.setLastUpdatedBy("赋码系统");
            shipmentContainerDetail.setBoxPosition(Integer.valueOf(inventoryDetail.getBoxPosition()));
            shipmentContainerDetail.setShipmentId(shipmentDetail.getShipmentId());
            shipmentContainerDetail.setShipmentDetailId(shipmentDetail.getId());
            shipmentContainerDetail.setShippingContainerId(shipmentContainerHeader.getId());

            inventoryDetail.setTaskQty(inventoryDetail.getTaskQty().add(BigDecimal.ONE));
            requestQty = requestQty.add(BigDecimal.ONE);//组盘加一
            result = shipmentContainerDetailService.save(shipmentContainerDetail);
            if(!result){
                throw new ServiceException("保存出库组盘明细失败");
            }
            //更新库存任务数量
            result = inventoryDetailService.updateById(inventoryDetail);
            if(!result){
                throw new ServiceException("保存出库组盘明细失败");
            }
            if(requestQty.compareTo(shipQty)==0){
                shipmentContainer.setHavInventory(true);
                break;
            }
        }
        result = shipmentTaskService.createPickingTask(shipmentContainerHeader.getId(), QuantityConstant.DEFAULT_WAREHOUSE);
        if(!result){
            throw new ServiceException("保存出库任务失败");
        }
        //出
        if(shipmentContainer.getHavInventory()){
            shipmentContainer.setRequestQty(requestQty);
            shipmentDetail.setStatus(QuantityConstant.SHIPMENT_HEADER_GROUPDISK);
            shipmentDetail.setProcessStamp(QuantityConstant.SHIPMENT_HEADER_GROUPDISK+"");
            result = shipmentDetailService.updateById(shipmentDetail);

            if(!result){
                throw new ServiceException("保存出库单明细失败");
            }
            return null;//结束
        }
        shipmentContainer.setRequestQty(requestQty);
        shipmentContainer.setContainers(containers);
        return addERPCombination(shipmentContainer);
    }


    @Transactional(rollbackFor = Exception.class)
    Boolean agvTaskAndReceiptQcStream(String position, ReceiptHeader receiptHeader,String warehouseCode){
        //生成AGV取放货任务
        AgvTask agvTask = new AgvTask();
        agvTask.setType(QuantityConstant.AGV_TYPE_TAKE_AND_RELEASE);
        agvTask.setStatus(QuantityConstant.AGV_TASK_STATUS_BUILD);
        agvTask.setWarehouseCode(warehouseCode);
        agvTask.setPriority(10);
        agvTask.setFromPort(position);
        agvTask.setToPort("质检点位");
        agvTask.setCreatedBy("赋码系统");
        Boolean result = agvTaskService.save(agvTask);
        if(!result) {
            throw new ServiceException("生成AGV任务失败");
        }
        //生成入库质检单
        receiptHeaderService.check(receiptHeader.getId());
        return Boolean.TRUE;
    }

}