wms / wms_guangxijianyi · Files

package com.huaheng.api.erp.service;

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.JSONArray;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.huaheng.api.erp.domain.BoxInfo;
import com.huaheng.api.erp.domain.ChipInfos;
import com.huaheng.api.erp.domain.ShipmentRecord;

import com.huaheng.api.wcs.service.WcsService;

import com.huaheng.common.constant.HttpConstant;

import com.huaheng.common.constant.QuantityConstant;
import com.huaheng.common.exception.service.ServiceException;

import com.huaheng.common.utils.DateUtils;

import com.huaheng.common.utils.http.OkHttpUtils;

import com.huaheng.framework.web.domain.AjaxResult;

import com.huaheng.framework.web.service.ConfigService;

import com.huaheng.pc.config.address.service.AddressService;

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.location.domain.Location;
import com.huaheng.pc.config.location.service.LocationService;

import com.huaheng.pc.config.material.domain.Material;
import com.huaheng.pc.config.material.service.MaterialService;
import com.huaheng.pc.config.proPackaging.domain.ProPackaging;
import com.huaheng.pc.config.proPackaging.service.IProPackagingService;
import com.huaheng.pc.inventory.InventoryHistoryDetail.domain.InventoryHistoryDetail;
import com.huaheng.pc.inventory.InventoryHistoryDetail.service.IInventoryHistoryDetailService;

import com.huaheng.pc.inventory.cycleCountDetail.domain.CycleCountDetail;
import com.huaheng.pc.inventory.cycleCountDetail.domain.CycleCountDetailChild;
import com.huaheng.pc.inventory.cycleCountDetail.service.CycleCountDetailChildService;
import com.huaheng.pc.inventory.cycleCountDetail.service.CycleCountDetailService;

import com.huaheng.pc.inventory.inventoryCacheDetail.domain.InventoryCacheDetail;
import com.huaheng.pc.inventory.inventoryCacheDetail.service.InventoryCacheDetailService;
import com.huaheng.pc.inventory.inventoryDetail.domain.InventoryDetail;
import com.huaheng.pc.inventory.inventoryDetail.service.InventoryDetailService;

import com.huaheng.pc.inventory.inventoryHeader.domain.InventoryHeader;
import com.huaheng.pc.inventory.inventoryHeader.service.InventoryHeaderService;

import com.huaheng.pc.inventory.inventoryHistoryHeader.domain.InventoryHistoryHeader;
import com.huaheng.pc.inventory.inventoryHistoryHeader.service.IInventoryHistoryHeaderService;
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.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.task.agvTask.domain.AgvTask;
import com.huaheng.pc.task.agvTask.service.AgvTaskService;

import com.huaheng.pc.task.taskDetail.domain.TaskDetail;
import com.huaheng.pc.task.taskDetail.service.TaskDetailService;

import com.huaheng.pc.task.taskHeader.domain.TaskHeader;

import com.huaheng.pc.task.taskHeader.service.ReceiptTaskService;

import com.huaheng.pc.task.taskHeader.service.TaskHeaderService;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;

import java.text.MessageFormat;
import java.util.*;

import java.util.stream.Collectors;

/**
 * @author 游杰
 */

@Service
public class CodingServiceImpl implements CodingService {

    @Resource
    private IInventoryHistoryDetailService inventoryHistoryDetailService;
    @Resource
    private IInventoryHistoryHeaderService inventoryHistoryHeaderService;
    @Resource

    private CycleCountDetailChildService cycleCountDetailChildService;

    @Resource
    private ShipmentDetailService shipmentDetailService;
    @Resource

    private ContainerService containerService;
    @Resource
    private ContainerTypeService containerTypeService;
    @Resource
    private ReceiptContainerHeaderService receiptContainerHeaderService;
    @Resource
    private ReceiptHeaderService receiptHeaderService;
    @Resource

    private PDAServiceImpl pdaService;
    @Resource

    private MaterialService materialService;
    @Resource

    private ShipmentHeaderService shipmentHeaderService;
    @Resource

    private AddressService addressService;
    @Resource

    private IProPackagingService proPackagingService;
    @Resource
    private ReceiptDetailService receiptDetailService;
    @Resource
    private ReceiptContainerDetailService receiptContainerDetailService;
    @Resource
    private ReceiptTaskService receiptTaskService;
    @Resource
    private AgvTaskService agvTaskService;

    @Resource
    private LocationService locationService;

    @Resource
    private WcsService wcsService;

    @Resource

    private ShipmentContainerHeaderService shipmentContainerHeaderService;

    @Resource

    private IBosAssistantDetailService bosAssistantDetailService;

    @Resource
    private InventoryDetailService inventoryDetailService;
    @Resource

    private IProPackagingService proPackingService;
    @Resource

    private CycleCountDetailService cycleCountDetailService;
    @Resource

    private InventoryCacheDetailService inventoryCacheDetailService;

    @Resource
    private TaskHeaderService taskHeaderService;

    @Resource

    private TaskDetailService taskDetailService;
    @Resource

    private InventoryHeaderService inventoryHeaderService;

    @Resource
    private ConfigService configService;

    @Override
    @Transactional(rollbackFor = Exception.class)

    public AjaxResult innerReceipt(String containerCode, String position, String proSchedule, String orderCode, String orderName, List<BoxInfo> boxInfoList,
        int stack, int qc, int orderFinish, BigDecimal weight, int type, String k3Code, String inType, String operatorName, String quantityorName,
        Integer toalCases) {

        String warehouseCode = "CS0001";
        boolean result = false;

        orderFinish = 1;

        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 containerStatus = container.getStatus();
        if (containerStatus.equals(QuantityConstant.STATUS_CONTAINER_LOCK)) {
            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);
        }

        ReceiptHeader receiptHeader = null;

        if (type == 0) { // 生产入库

            String receiptCode = receiptHeaderService.createCode(QuantityConstant.RECEIPT_TYPE_PRODUCTON);
            LambdaQueryWrapper<ReceiptHeader> receiptHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();

            receiptHeaderLambdaQueryWrapper.eq(ReceiptHeader::getOrderCode, orderCode).le(ReceiptHeader::getLastStatus, QuantityConstant.RECEIPT_HEADER_POSTING)
                .eq(ReceiptHeader::getReceiptType, QuantityConstant.RECEIPT_TYPE_PRODUCTON);

            receiptHeader = receiptHeaderService.getOne(receiptHeaderLambdaQueryWrapper);
            if (receiptHeader == null) {
                receiptHeader = new ReceiptHeader();
                receiptHeader.setCode(receiptCode);
                receiptHeader.setOrderCode(orderCode);
                receiptHeader.setReceiptType(QuantityConstant.RECEIPT_TYPE_PRODUCTON);

                receiptHeader.setInType(inType);

                receiptHeader.setWarehouseCode(warehouseCode);
                receiptHeader.setCompanyCode(QuantityConstant.DEFAULT_COMPANY);
                receiptHeader.setReferType(QuantityConstant.BILL_TYPE_RECEIPT_SINGLE);
                receiptHeader.setTotalLines(0);
                receiptHeader.setTotalQty(BigDecimal.ZERO);
                receiptHeader.setFirstStatus(200);
                receiptHeader.setLastStatus(200);

                receiptHeader.setToalCases(toalCases);

                receiptHeader.setOrderFinish(false);
                receiptHeader.setCreatedBy(QuantityConstant.PLATFORM_CODING);
                receiptHeader.setLastUpdatedBy(QuantityConstant.PLATFORM_CODING);
                result = receiptHeaderService.save(receiptHeader);
                if (!result) {
                    throw new ServiceException("保存入库单失败");
                }
            }

        } else if (type == 1) { // 退货入库

            LambdaQueryWrapper<ReceiptHeader> receiptHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();

            receiptHeaderLambdaQueryWrapper.eq(ReceiptHeader::getReferCode, k3Code).le(ReceiptHeader::getLastStatus, QuantityConstant.RECEIPT_HEADER_POSTING)
                .eq(ReceiptHeader::getReceiptType, QuantityConstant.RECEIPT_BILL_TYPE_SR);

            receiptHeader = receiptHeaderService.getOne(receiptHeaderLambdaQueryWrapper);

            if (receiptHeader == null) {

                throw new ServiceException("没有找到销售退货单");

            }

        } else if (type == 2) {

            String receiptCode = receiptHeaderService.createCode(QuantityConstant.RECEIPT_BILL_TYPE_OR);

            LambdaQueryWrapper<ReceiptHeader> receiptHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();

            receiptHeaderLambdaQueryWrapper.eq(ReceiptHeader::getOrderCode, orderCode).le(ReceiptHeader::getLastStatus, QuantityConstant.RECEIPT_HEADER_POSTING)
                .eq(ReceiptHeader::getReceiptType, QuantityConstant.RECEIPT_BILL_TYPE_OR);

            receiptHeader = receiptHeaderService.getOne(receiptHeaderLambdaQueryWrapper);
            if (receiptHeader == null) {
                receiptHeader = new ReceiptHeader();
                receiptHeader.setCode(receiptCode);
                receiptHeader.setOrderCode(orderCode);

                receiptHeader.setReceiptType(QuantityConstant.RECEIPT_BILL_TYPE_OR);
                String defDeptCode = configService.getKey(QuantityConstant.QT_DEF_DEPT);
                receiptHeader.setUserDef1(defDeptCode);

                receiptHeader.setInType(inType);
                receiptHeader.setWarehouseCode(warehouseCode);
                receiptHeader.setCompanyCode(QuantityConstant.DEFAULT_COMPANY);

                // 其他入库单 类型

                receiptHeader.setReferType(QuantityConstant.BILL_TYPE_RECEIPT_OTHER);

                receiptHeader.setTotalLines(0);
                receiptHeader.setTotalQty(BigDecimal.ZERO);
                receiptHeader.setFirstStatus(200);
                receiptHeader.setLastStatus(200);
                receiptHeader.setToalCases(toalCases);
                receiptHeader.setOrderFinish(false);
                receiptHeader.setCreatedBy(QuantityConstant.PLATFORM_CODING);
                receiptHeader.setLastUpdatedBy(QuantityConstant.PLATFORM_CODING);
                result = receiptHeaderService.save(receiptHeader);
                if (!result) {
                    throw new ServiceException("保存入库单失败");
                }
            }

        } else {

            throw new ServiceException("type类型不匹配");

        }

        BigDecimal totalQty = BigDecimal.ZERO;

        String materialCode1 = null, batch1 = null, level1 = null, color1 = null, proPackage1 = null, productSize = null;
        Integer boxQty = 0;// 每箱数量
        Integer box = 0;// 箱数

        BoxInfo boxInfo1 = boxInfoList.get(0);

        for (BoxInfo boxInfo : boxInfoList) {

            materialCode1 = boxInfo.getMaterialCode();

            proPackage1 = boxInfo.getProPackaging();

            level1 = boxInfo.getLevel();
            color1 = boxInfo.getColor();

            productSize = boxInfo.getSize();

            BigDecimal qty = boxInfo.getQty();
            batch1 = boxInfo.getBatch();
            totalQty = totalQty.add(qty);

            if (!boxInfo1.getMaterialCode().equals(materialCode1)) {

                throw new ServiceException("赋码系统给的物料编码不一致:" + boxInfo1.getMaterialCode() + "," + materialCode1);
            }

            if (!boxInfo1.getProPackaging().equals(proPackage1)) {

                throw new ServiceException("赋码系统给的产品包装不一致:" + boxInfo1.getProPackaging() + "," + proPackage1);
            }

            if (!boxInfo1.getLevel().equals(level1)) {

                throw new ServiceException("赋码系统给的等级不一致:" + boxInfo1.getLevel() + "," + level1);
            }

            if (!boxInfo1.getColor().equals(color1)) {

                throw new ServiceException("赋码系统给的色号不一致:" + boxInfo1.getColor() + "," + color1);
            }

            if (!boxInfo1.getBatch().equals(batch1)) {

                throw new ServiceException("赋码系统给的批次不一致:" + boxInfo1.getBatch() + "," + batch1);
            }

        }

        Material material = materialService.getMaterialByCode(materialCode1);

        getBosAssistantNumber(color1, "colour");
        getBosAssistantNumber(level1, "level");

        LambdaQueryWrapper<ReceiptDetail> receiptDetailLambdaQueryWrapper1 = Wrappers.lambdaQuery();
        receiptDetailLambdaQueryWrapper1.eq(ReceiptDetail::getReceiptId, receiptHeader.getId());
        List<ReceiptDetail> details = receiptDetailService.list(receiptDetailLambdaQueryWrapper1);

        BigDecimal sum = new BigDecimal(0);
        ReceiptDetail detail = null;
        for (ReceiptDetail det : details) {
            sum = sum.add(det.getTaskQty());
            if (det.getMaterialCode().equals(materialCode1)) {
                detail = det;
            }
        }

        if (type == 1 && sum.add(totalQty).compareTo(receiptHeader.getTotalQty()) == 1) {

            throw new ServiceException("单据数量超出了:");
        }

        if (detail == null && details.size() != 0) {

            throw new ServiceException("不可出现一种新的物料:");
        }

        ReceiptDetail receiptDetail = new ReceiptDetail();
        receiptDetail.setWarehouseCode(warehouseCode);

        receiptDetail.setCompanyCode(QuantityConstant.DEFAULT_COMPANY);

        receiptDetail.setMaterialCode(materialCode1);
        receiptDetail.setMaterialUnit("1001");

        receiptDetail.setMaterialSpec(material.getSpec());

        if (details.size() > 1) {

            receiptDetail.setFHTZDetail(detail.getFHTZDetail());
        }

        LambdaQueryWrapper<Material> queryWrapper = Wrappers.lambdaQuery();

        queryWrapper.eq(Material::getCode, materialCode1).eq(Material::getWarehouseCode, QuantityConstant.DEFAULT_WAREHOUSE);

        Material material1 = materialService.getOne(queryWrapper);

        if (material1 == null) {

            return AjaxResult.error("没有找到物料信息:" + materialCode1);
        }

        receiptDetail.setMaterialName(material1.getName());
        receiptDetail.setColor(color1);
        receiptDetail.setLevel(level1);

        receiptDetail.setProPackaging(proPackage1);

        receiptDetail.setProductSchedule(proSchedule);
        receiptDetail.setProductSize(productSize);
        receiptDetail.setQty(totalQty);

        receiptDetail.setStatus(QuantityConstant.RECEIPT_HEADER_BUILD);

        LambdaQueryWrapper<ProPackaging> queryWrapper2 = Wrappers.lambdaQuery();

        queryWrapper2.eq(ProPackaging::getNumber, proPackage1);

        ProPackaging proPackaging = proPackagingService.getOne(queryWrapper2);

        if (proPackaging == null) {

            return AjaxResult.error("没有该产品包装");
        }

        // 每箱数量

        int pieceBox = proPackaging.getPieceBox();

        String toPort = null;

        String toLocationCode = null;

        // 先获取起始库位，获取不到就放到缓存区

        if (qc == 0) {
            AjaxResult ajaxResult = wcsService.getFromPort();
            if (ajaxResult.hasErr()) {
                throw new ServiceException("获取站台点失败");

            }

            JSONArray array = (JSONArray)ajaxResult.getData();

            for (int i = 0; i < array.size(); i++) {

                toPort = (String)array.get(i);

                String port = null;
                if (toPort.equals(QuantityConstant.PORT_P1005)) {
                    port = QuantityConstant.PORT_P1004;
                }

                if (toPort.equals(QuantityConstant.PORT_P1001)) {
                    port = QuantityConstant.PORT_P1000;
                }

                LambdaQueryWrapper<AgvTask> agvTaskLambdaQueryWrapper = Wrappers.lambdaQuery();

                agvTaskLambdaQueryWrapper.eq(AgvTask::getToPort, port).ne(AgvTask::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);

                List<AgvTask> list = agvTaskService.list(agvTaskLambdaQueryWrapper);

                toLocationCode = toPort;
                if (list.size() > 0) {
                    toLocationCode = getCacheLocation();
                } else {
                    break;
                }

            }

            if (array.size() == 0) {
                toLocationCode = getCacheLocation();
            }

            if (StringUtils.isEmpty(toLocationCode)) {
                throw new ServiceException("没有找到入库缓存区空闲库位");
            }

        }

        // 箱数

        box = totalQty.divide(BigDecimal.valueOf(pieceBox), RoundingMode.DOWN).intValue();
        receiptDetail.setBox(box);

        if (receiptHeader.getReceiptType().equals(QuantityConstant.RECEIPT_BILL_TYPE_SR)) {

            receiptDetail.setTaskQty(totalQty);
        }

//        if (details.size()>1&&sum.add(totalQty).compareTo(detail.getQty())==1)
//        {
//            throw new ServiceException("已收数量不能大于单据总数量");
//        }

        receiptDetail.setBatch(batch1);
        receiptDetail.setProjectNo(orderCode);

        receiptDetail.setReceiptCode(receiptHeader.getCode());

        receiptDetail.setQcCheck(qc + "");// 是否质检

        receiptDetail.setCreatedBy(QuantityConstant.PLATFORM_CODING);
        receiptDetail.setLastUpdatedBy(QuantityConstant.PLATFORM_CODING);

        receiptDetail.setReceiptId(receiptHeader.getId());

        LambdaQueryWrapper<ReceiptDetail> receiptDetailQueryWrapper = new LambdaQueryWrapper<>();

        receiptDetailQueryWrapper.eq(ReceiptDetail::getReceiptId, receiptHeader.getId()).eq(ReceiptDetail::getMaterialCode, materialCode1)
            .eq(ReceiptDetail::getBatch, batch1).eq(ReceiptDetail::getColor, color1).eq(ReceiptDetail::getLevel, level1);

        ReceiptDetail receiptDetail1 = receiptDetailService.getOne(receiptDetailQueryWrapper);

        if (receiptDetail1 != null) {

            receiptDetail = receiptDetail1;
            BigDecimal qty = receiptDetail.getQty();

            BigDecimal taskQty = receiptDetail.getTaskQty();

            qty = qty.add(totalQty);

            taskQty = taskQty.add(totalQty);

            if (receiptHeader.getReceiptType().equals(QuantityConstant.RECEIPT_BILL_TYPE_SR)) {

                receiptDetail.setTaskQty(taskQty);

            } else {

                receiptDetail.setQty(qty);
            }

            result = receiptDetailService.updateById(receiptDetail);
        } else {
            result = receiptDetailService.save(receiptDetail);
        }

        if (!result) {

            throw new ServiceException("保存入库单详情失败");
        }

        receiptHeader.setTotalLines(receiptHeader.getTotalLines() + 1);

        receiptHeader.setTotalQty(receiptHeader.getTotalQty().add(totalQty));

        // 判断是否完成的标志

        boolean result1 = orderFinish == 1;

        receiptHeader.setOrderFinish(result1);// 设值

        if (receiptHeader.getReceiptType().equals(QuantityConstant.RECEIPT_BILL_TYPE_SR)) {

            LambdaQueryWrapper<ReceiptDetail> receiptDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            receiptDetailLambdaQueryWrapper.eq(ReceiptDetail::getReceiptId, receiptHeader.getId());
            List<ReceiptDetail> receiptDetailList = receiptDetailService.list(receiptDetailLambdaQueryWrapper);
            int complete = 1;

            for (ReceiptDetail receiptDetail2 : receiptDetailList) {
                if (receiptDetail2.getQty().compareTo(receiptDetail2.getTaskQty()) > 0) {

                    complete = 0;
                }
            }

            if (complete == 1) {

                if (receiptHeader.getLastStatus().intValue() < QuantityConstant.RECEIPT_HEADER_POSTING) {

                    receiptHeader.setFirstStatus(QuantityConstant.RECEIPT_HEADER_POSTING);
                    receiptHeader.setLastStatus(QuantityConstant.RECEIPT_HEADER_POSTING);
                }

            }
        }

        result = receiptHeaderService.updateById(receiptHeader);

        if (!result) {

            throw new ServiceException("更新入库单失败");
        }

        receiptDetailService.updateReceiptHeader(receiptHeader);

        ReceiptContainerHeader receiptContainerHeader1 = new ReceiptContainerHeader();
        receiptContainerHeader1.setWarehouseCode(warehouseCode);

        receiptContainerHeader1.setCompanyCode(QuantityConstant.DEFAULT_COMPANY);

        receiptContainerHeader1.setContainerCode(containerCode);
        receiptContainerHeader1.setPosition(position);

        receiptContainerHeader1.setPort(toLocationCode);

        receiptContainerHeader1.setOperatorName(operatorName);
        receiptContainerHeader1.setQualityorName(quantityorName);

        receiptContainerHeader1.setBatch(batch1);
        receiptContainerHeader1.setLevel(level1);
        receiptContainerHeader1.setColor(color1);

        receiptContainerHeader1.setProductSize(productSize);

        receiptContainerHeader1.setProPackaging(proPackage1);

        receiptContainerHeader1.setProductSchedule(proSchedule);

//        receiptContainerHeader1.setStockId(stockId);//生产车间

        receiptContainerHeader1.setOrderCode(orderCode);// 订单编号
        receiptContainerHeader1.setOrderName(orderName);// 订单名称
        receiptContainerHeader1.setMaterialCode(materialCode1);// 物料编码

        receiptContainerHeader1.setContainerType(containerTypeCode);

        receiptContainerHeader1.setWeight(String.valueOf(weight));

        receiptContainerHeader1.setTaskType(QuantityConstant.TASK_TYPE_WHOLERECEIPT);
        receiptContainerHeader1.setStatus(QuantityConstant.RECEIPT_CONTAINER_BUILD);

        receiptContainerHeader1.setStack(stack);// 设置垛型

        receiptContainerHeader1.setCreatedBy(QuantityConstant.PLATFORM_CODING);
        receiptContainerHeader1.setLastUpdatedBy(QuantityConstant.PLATFORM_CODING);

        result = receiptContainerHeaderService.save(receiptContainerHeader1);

        if (!result) {

            throw new ServiceException("保存入库组盘头失败");
        }

        for (BoxInfo boxInfo : boxInfoList) {

            String boxCode = boxInfo.getBoxCode();

            int boxPosition = boxInfo.getBoxPosition();

            List<ChipInfos> chipInfoList = boxInfo.getChipInfos();

//            String materialCode = boxInfo.getMaterialCode();
//            Material material = materialService.getMaterialByCode(materialCode, warehouseCode);

            String level = boxInfo.getLevel();

            String proPackagingStr = boxInfo.getProPackaging();

            String productSize1 = boxInfo.getSize();

            String color = boxInfo.getColor();
            String batch = boxInfo.getBatch();

            for (ChipInfos chipInfos : chipInfoList) {

                ReceiptContainerDetail receiptContainerDetail = new ReceiptContainerDetail();

                String chipCode1 = chipInfos.getChipBarcode1();
                String chipCode2 = chipInfos.getChipBarcode2();

                receiptContainerDetail.setWarehouseCode(warehouseCode);
                receiptContainerDetail.setContainerCode(containerCode);
                receiptContainerDetail.setContainerType(containerTypeCode);

                receiptContainerDetail.setCompanyCode(QuantityConstant.DEFAULT_COMPANY);

                receiptContainerDetail.setTaskType(QuantityConstant.TASK_TYPE_WHOLERECEIPT);

                receiptContainerDetail.setChipCode1(chipCode1);
                receiptContainerDetail.setChipCode2(chipCode2);

                receiptContainerDetail.setMaterialCode(receiptDetail.getMaterialCode());
                receiptContainerDetail.setMaterialName(receiptDetail.getMaterialName());
                receiptContainerDetail.setMaterialSpec(receiptDetail.getMaterialSpec());
                receiptContainerDetail.setMaterialUnit(receiptDetail.getMaterialUnit());

                receiptContainerDetail.setProPackaging(proPackagingStr);// 包装
                receiptContainerDetail.setProductSchedule(proSchedule);// 排产订单
                receiptContainerDetail.setProductSize(productSize1);// 等级
                receiptContainerDetail.setLevel(level);// 等级
                receiptContainerDetail.setColor(color);// 色号

                receiptContainerDetail.setQty(BigDecimal.ONE);
                receiptContainerDetail.setBatch(batch);
                receiptContainerDetail.setReceiptCode(orderCode);
                receiptContainerDetail.setBoxCode(boxCode);
                receiptContainerDetail.setReceiptType("SC");

                receiptContainerDetail.setInventorySts(QuantityConstant.QUALITY_GOOD);
                receiptContainerDetail.setCreatedBy(QuantityConstant.PLATFORM_CODING);
                receiptContainerDetail.setLastUpdatedBy(QuantityConstant.PLATFORM_CODING);

                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();

        if (qc == 1) {

            receiptContainerHeader1.setExceptionCode("需要质检");
            receiptContainerHeaderService.updateById(receiptContainerHeader1);

            toLocationCode = getCacheLocation();

        } else {

            if (toLocationCode.equals(QuantityConstant.PORT_P1001) || toLocationCode.equals(QuantityConstant.PORT_P1005)) {

                AjaxResult ajaxResult = receiptTaskService.createReceiptTask(id, warehouseCode);

                if (ajaxResult.hasErr()) {