wms / hhwms · Files

package com.huaheng.pc.shipment.shipmentContainerHeader.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

import com.huaheng.common.constant.QuantityConstant;

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

import com.huaheng.common.utils.StringUtils;

import com.huaheng.common.utils.Wrappers;

import com.huaheng.common.utils.security.ShiroUtils;
import com.huaheng.framework.web.domain.AjaxResult;

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

import com.huaheng.pc.config.container.domain.Container;
import com.huaheng.pc.config.container.service.ContainerService;

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.shipmentPreference.service.ShipmentPreferenceService;

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

import com.huaheng.pc.monitor.job.task.RyTaskKS;

import com.huaheng.pc.receipt.receiptContainerHeader.service.ReceiptContainerHeaderService;

import com.huaheng.pc.shipment.lockingWorkOrder.service.LockingWorkOrderService;

import com.huaheng.pc.shipment.shipmentContainerDetail.domain.ShipmentContainerDetail;
import com.huaheng.pc.shipment.shipmentContainerDetail.service.ShipmentContainerDetailService;
import com.huaheng.pc.shipment.shipmentContainerHeader.domain.ShipmentCombinationModel;

import com.huaheng.pc.shipment.shipmentContainerHeader.domain.ShipmentContainerHeader;
import com.huaheng.pc.shipment.shipmentContainerHeader.mapper.ShipmentContainerHeaderMapper;

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.shipment.shippingCombination.service.ShippingCombinationService;

import com.huaheng.pc.shipment.wave.domain.Wave;
import com.huaheng.pc.shipment.wave.service.WaveService;

import com.huaheng.pc.system.dict.service.IDictDataService;

import com.huaheng.pc.system.role.domain.Role;
import com.huaheng.pc.system.role.service.IRoleService;

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

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

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

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

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

import java.math.BigDecimal;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;

@Service

public class ShipmentContainerHeaderServiceImpl extends ServiceImpl<ShipmentContainerHeaderMapper, ShipmentContainerHeader> implements ShipmentContainerHeaderService {

    private static final Logger logger = LoggerFactory.getLogger(ShipmentContainerHeaderServiceImpl.class);

    @Autowired
    private ShipmentDetailService shipmentDetailService;
    @Autowired
    private InventoryDetailService inventoryDetailService;
    @Autowired
    private LocationService locationService;
    @Autowired
    private ShipmentHeaderService shipmentHeaderService;
    @Resource
    private ShipmentContainerHeaderMapper shipmentContainerHeaderMapper;
    @Autowired
    private ShipmentContainerDetailService shipmentContainerDetailService;
    @Autowired
    private MaterialService materialService;

    @Autowired
    private ShippingCombinationService shippingCombinationService;

    @Autowired
    private TaskHeaderService taskHeaderService;

    @Autowired
    private TaskDetailService taskDetailService;

    @Autowired
    private WaveService waveService;

    @Autowired
    private ShipmentPreferenceService shipmentPreferenceService;

    @Autowired
    private ContainerService containerService;

    @Resource
    private ShipmentTaskService shipmentTaskService;

    @Autowired
    private ReceiptContainerHeaderService receiptContainerHeaderService;

    @Autowired
    private LockingWorkOrderService lockingWorkOrderService;

    @Autowired
    private IRoleService roleService;

    @Autowired
    private IDictDataService dictDataService;

    @Override
    public Map<String, Integer> getShipmentContainerMaxAndMinStatusByShipmentID(int shipmentId) {
        return shipmentContainerHeaderMapper.getShipmentContainerMaxAndMinStatusByShipmentID(shipmentId);
    }


    /**

     * 1.检查基本属性
     * 2.更改库存明细
     * 3.更新单据明细的已出库数量
     * 4.自动判定出库任务状态，根据库存数量减去预定库存相等就是整盘出--预计任务状态
     * 5.增加出库组盘头
     * 6.增加出库组盘明细
     * 7.更新单据状态

     * <p>

     * 出库组盘单条保存

     *

     * @param shipmentCombinationModel
     * @return
     */

    @Transactional(rollbackFor = Exception.class)

    @Override

    public ShipmentContainerHeader combination(ShipmentCombinationModel shipmentCombinationModel) {

        //1.检查基本属性

        //校验

        if (shipmentCombinationModel.getShipQty().compareTo(new BigDecimal("0")) <= 0) {

            throw new ServiceException("出库数量必须大于0");

        }
        ShipmentDetail shipmentDetail = shipmentDetailService.getById(shipmentCombinationModel.getShipmentDetailId());

        if (shipmentDetail == null) {

            throw new ServiceException("出库明细未找到");

        }
        InventoryDetail inventoryDetail = inventoryDetailService.getById((shipmentCombinationModel.getInventoryDetailId()));

        if (inventoryDetail == null) {

            throw new ServiceException("库存未找到");

        }

        String containerCode = inventoryDetail.getContainerCode();
        int unCompleteCombineNumber = receiptContainerHeaderService.getUnCompleteCombineNumber(containerCode);

        if (unCompleteCombineNumber > 0) {

            throw new ServiceException("托盘：" + containerCode + " 已经用于入库组盘");
        }

        Container container = containerService.getContainerByCode(containerCode);

        if (container != null) {
            if (container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_LOCK)) {

                //throw new ServiceException("托盘已经锁定，不能再组盘");

            }
        }

        //校验数量是否超出

        if ((shipmentDetail.getQty().subtract(shipmentDetail.getTaskQty())).compareTo(shipmentCombinationModel.getShipQty()) < 0) {

            throw new ServiceException("录入数量超出明细待出数量");

        }
        //校验库存可用数量

        if (inventoryDetail.getQty().subtract(inventoryDetail.getTaskQty()).compareTo(shipmentCombinationModel.getShipQty()) < 0) {

            throw new ServiceException("录入数量超出可出数量");

        }

        if (!shipmentDetail.getMaterialCode().equals(inventoryDetail.getMaterialCode())) {

            throw new ServiceException("配盘物料不一致");

        }
        //库位

        LambdaQueryWrapper<Location> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(Location::getWarehouseCode, inventoryDetail.getWarehouseCode())
                .eq(Location::getCode, inventoryDetail.getLocationCode());

        Location location = locationService.getOne(lambdaQueryWrapper);

        if (location == null) {
            throw new ServiceException("库位 " + inventoryDetail.getLocationCode() + " 不存在");
        }

        LambdaQueryWrapper<TaskHeader> taskWrapper = Wrappers.lambdaQuery();
        taskWrapper.eq(TaskHeader::getWarehouseCode, inventoryDetail.getWarehouseCode())
                .lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED)
                .in(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_VIEW, QuantityConstant.TASK_TYPE_TRANSFER)
                .apply("(fromLocation='" + inventoryDetail.getLocationCode() + "' or toLocation='" + inventoryDetail.getLocationCode() + "')");
        List<TaskHeader> taskHeaders = taskHeaderService.list(taskWrapper);
        if (taskHeaders.size() > 0) {
            throw new ServiceException("库位 " + inventoryDetail.getLocationCode() + " 已经有移库或出库查看任务，不能组盘");
        }

        if (container.getZoneCode().equals("LK")) {
            LambdaQueryWrapper<TaskHeader> taskWrapper1 = Wrappers.lambdaQuery();
            taskWrapper1.eq(TaskHeader::getWarehouseCode, inventoryDetail.getWarehouseCode())
                    .eq(TaskHeader::getContainerCode, containerCode)
                    .ge(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_RELEASE)
                    .lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);
            List<TaskHeader> taskHeaders1 = taskHeaderService.list(taskWrapper1);
            if (taskHeaders1.size() > 0) {
                throw new ServiceException("容器 " + containerCode + " 任务已经下发，不能组盘");
            }
        }

        //3.更新单据明细的已出库数量

        shipmentDetail.setTaskQty(shipmentDetail.getTaskQty().add(shipmentCombinationModel.getShipQty()));
        int i = shipmentDetail.getQty().compareTo(shipmentDetail.getTaskQty());

        if (i > 0) {

            shipmentDetail.setStatus(QuantityConstant.SHIPMENT_HEADER_WAVE);

        } else if (i == 0) {

            shipmentDetail.setStatus(QuantityConstant.SHIPMENT_HEADER_GROUPDISK);

        } else if (i < 0) {

            throw new ServiceException("出库数量不能大于单据数量！");
        }

        //自动判定出库任务状态，根据库存数量减去预定库存相等就是整盘出--预计任务状态

//        BigDecimal inventoryQty = inventoryDetail.getQty().subtract(inventoryDetail.getTaskQty());
//        if (inventoryQty.compareTo(new BigDecimal(0)) <= 0) {
//            shipmentCombinationModel.setTaskType(QuantityConstant.TASK_TYPE_WHOLESHIPMENT);
//        } else {
//            shipmentCombinationModel.setTaskType(QuantityConstant.TASK_TYPE_SORTINGSHIPMENT);
//        }
//        Container container1 = containerService.getContainerByCode(inventoryDetail.getContainerCode());
//        String containerType = container1.getContainerType();
//        if ("S".equals(containerType)) {
//            shipmentCombinationModel.setTaskType(QuantityConstant.TASK_TYPE_SORTINGSHIPMENT);
//        }

        //5.增加出库组盘头
        ShipmentContainerHeader shipmentContainerHeader = ShipmentContainerHeaderAdd(location, shipmentDetail);
        //6.增加出库组盘明细

        ShipmentContainerDetail shipmentContainerDetail = ShipmentContainerDetailAdd(shipmentDetail, shipmentContainerHeader, shipmentCombinationModel);

        if (!shipmentDetailService.saveOrUpdate(shipmentDetail)) {
            throw new ServiceException("新增组盘明细失败,sql错误");
        }

        //7.更新单据状态

        AjaxResult ajaxResult = shipmentHeaderService.updateShipmentStatus(shipmentDetail.getShipmentId());
        if (ajaxResult != null && ajaxResult.hasErr()) {
            throw new ServiceException("组盘：" + ajaxResult.getMsg());
        }

//2.更新库存分配数
        inventoryDetail.setTaskQty(inventoryDetail.getTaskQty().add(shipmentCombinationModel.getShipQty()));

        if (!inventoryDetailService.saveOrUpdate(inventoryDetail)) {
            throw new ServiceException("修改库存明细失败,sql错误");
        }

        return shipmentContainerHeader;

    }

    /**

     * 组盘头
     * 1.查看是否有状态小于等于20的组盘头，有就需新建组盘头，没有就新建
     * 2.没有符合条件的组盘头，新建组盘头
     *

     * @param location

     * @param shipmentDetail

     * @return
     */
    private ShipmentContainerHeader ShipmentContainerHeaderAdd(Location location,

                                                               ShipmentDetail shipmentDetail) {
        //1.查看是否有状态小于等于20的组盘头，有就需新建组盘头，没有就新建

        LambdaQueryWrapper<ShipmentContainerHeader> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(ShipmentContainerHeader::getLocationCode, location.getCode())
                .eq(ShipmentContainerHeader::getContainerCode, location.getContainerCode())
                .eq(ShipmentContainerHeader::getWarehouseCode, ShiroUtils.getWarehouseCode())
                .lt(ShipmentContainerHeader::getStatus, QuantityConstant.SHIPMENT_CONTAINER_FINISHED);

        ShipmentContainerHeader shipmentContainerHeader = this.getOne(lambdaQueryWrapper);

        if (shipmentContainerHeader != null) {
            if (shipmentDetail.getWarehouseCode().equals("KS0001") && !ShiroUtils.getUserName().equals(shipmentContainerHeader.getCreatedBy())) {
                throw new ServiceException(shipmentDetail.getMaterialName() + "物料匹配托盘" + location.getContainerCode() + "已被" + shipmentContainerHeader.getCreatedBy() + "组盘，暂时不能组盘");

            }

            if (shipmentDetail.getWarehouseCode().equals("CS0001") && !ShiroUtils.getUserName().equals(shipmentContainerHeader.getCreatedBy())) {
                if(location.getContainerCode().equals("X00001")){
                    throw new ServiceException(shipmentDetail.getMaterialName() + "物料匹配托盘" + location.getContainerCode() + "已被" + shipmentContainerHeader.getCreatedBy() + "组盘，暂时不能组盘");
                }
            }
            //下发后不能再配盘
            LambdaQueryWrapper<TaskHeader> taskWrapper = Wrappers.lambdaQuery();
            taskWrapper.eq(TaskHeader::getWarehouseCode,ShiroUtils.getWarehouseCode())
                    .eq(TaskHeader::getAllocationHeadId, shipmentContainerHeader.getId())
                    .gt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_BUILD);
            taskWrapper.last("limit 1");
            TaskHeader taskHeader = taskHeaderService.getOne(taskWrapper);
            if(taskHeader != null){
                throw new ServiceException("托盘" + location.getContainerCode() + "已有任务下发，暂时不能组盘");
            }

            return shipmentContainerHeader;

        } else {

            // 2.没有符合条件的组盘头，新建组盘头
            //找到容器类型

            LambdaQueryWrapper<Container> containerLam = Wrappers.lambdaQuery();
            containerLam.eq(Container::getCode, location.getContainerCode())
                    .eq(Container::getWarehouseCode, ShiroUtils.getWarehouseCode());

            Container container = containerService.getOne(containerLam);

            if (container == null) {

                throw new ServiceException("系统没有此容器编码");
            }

            LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getContainerCode, container.getCode());

            List<InventoryDetail> inventoryDetailList = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);

            int taskType = QuantityConstant.TASK_TYPE_WHOLESHIPMENT;

            if (inventoryDetailList != null && inventoryDetailList.size() > 0) {
                for (InventoryDetail inventoryDetail : inventoryDetailList) {
                    if (inventoryDetail.getQty().subtract(inventoryDetail.getTaskQty()).

                            compareTo(BigDecimal.ZERO) > 0) {
                        taskType = QuantityConstant.TASK_TYPE_SORTINGSHIPMENT;
                    }

                }

            }

            if ("S".equals(container.getContainerType())) {

                taskType = QuantityConstant.TASK_TYPE_SORTINGSHIPMENT;
            }

            ShipmentHeader shipmentHeader = shipmentHeaderService.getById(shipmentDetail.getShipmentId());

            shipmentContainerHeader = new ShipmentContainerHeader();
            shipmentContainerHeader.setContainerCode(location.getContainerCode());
            shipmentContainerHeader.setLocationCode(location.getCode());

            shipmentContainerHeader.setZoneCode(location.getZoneCode());

            shipmentContainerHeader.setWarehouseCode(ShiroUtils.getWarehouseCode());

            shipmentContainerHeader.setUWarehouseCode(shipmentHeader.getUWarehouseCode());

            shipmentContainerHeader.setCompanyCode(shipmentDetail.getCompanyCode());
            shipmentContainerHeader.setPort(shipmentDetail.getPort());
            shipmentContainerHeader.setContainerType(container.getContainerType());
            shipmentContainerHeader.setStatus(QuantityConstant.SHIPMENT_CONTAINER_BUILD);
            shipmentContainerHeader.setTaskType(taskType);
            shipmentContainerHeader.setTaskCreated(0);
            shipmentContainerHeader.setCreatedBy(ShiroUtils.getLoginName());
            Boolean flag = this.save(shipmentContainerHeader);
            if (flag == false) {
                throw new ServiceException("新建组盘头失败，sql错误");
            }
            return shipmentContainerHeader;
        }

    }

    /**

     * 组盘明细
     * 1.查看是否有同一出库明细的物料需要出库
     * 2.有时修改阻盘明细的出库数量就行
     * 3.没有就新建明细
     * 4。查看组盘头状态，如果状态在10到20，则生成任务明细或修改任务明细的数量
     *

     * @param shipmentDetail
     * @param shipmentContainerHeader
     * @param shipmentCombinationModel
     * @return
     */
    private ShipmentContainerDetail ShipmentContainerDetailAdd(ShipmentDetail shipmentDetail,
                                                               ShipmentContainerHeader shipmentContainerHeader,
                                                               ShipmentCombinationModel shipmentCombinationModel) {

        Boolean flag = true;

        //1.查看是否有同一出库明细的物料需要出库

        LambdaQueryWrapper<ShipmentContainerDetail> lambdaQueryWrapper = Wrappers.lambdaQuery();

        lambdaQueryWrapper.eq(ShipmentContainerDetail::getShippingContainerId, shipmentContainerHeader.getId())
                .eq(ShipmentContainerDetail::getLocationCode, shipmentContainerHeader.getLocationCode())
                .eq(ShipmentContainerDetail::getContainerCode, shipmentContainerHeader.getContainerCode())
                .eq(ShipmentContainerDetail::getShipmentDetailId, shipmentCombinationModel.getShipmentDetailId())
                .eq(ShipmentContainerDetail::getInventoryId, shipmentCombinationModel.getInventoryDetailId())
                .eq(ShipmentContainerDetail::getWarehouseCode, ShiroUtils.getWarehouseCode());

        ShipmentContainerDetail shipmentContainerDetail = shipmentContainerDetailService.getOne(lambdaQueryWrapper);

        ShipmentContainerDetail shipmentContainerDetaill = new ShipmentContainerDetail();

        Container container = containerService.getContainerByCode(shipmentContainerHeader.getContainerCode());

        //2.有时修改阻盘明细的出库数量就行

        if (shipmentContainerDetail != null) {

            shipmentContainerDetail.setQty(shipmentContainerDetail.getQty().add(shipmentCombinationModel.getShipQty()));

            shipmentContainerDetaill = shipmentContainerDetail;

            shipmentContainerDetaill.setZoneCode(container.getZoneCode());

            flag = shipmentContainerDetailService.saveOrUpdate(shipmentContainerDetail);
            if (flag == false) {

                throw new ServiceException("修改组盘明细失败,sql错误");
            }

        } else {

            //3.没有就新建明细

            LambdaQueryWrapper<Material> lam = Wrappers.lambdaQuery();
            lam.eq(Material::getCode, shipmentDetail.getMaterialCode())
                    .eq(Material::getWarehouseCode, ShiroUtils.getWarehouseCode());

            Material material = materialService.getOne(lam);

            if (material == null) {
                throw new ServiceException("出库单(" + shipmentDetail.getShipmentCode() + ")的物料(" + shipmentDetail.getMaterialCode() + ")不存在！");
            }

            shipmentContainerDetaill.setWarehouseCode(shipmentContainerHeader.getWarehouseCode());

            shipmentContainerDetaill.setUWarehouseCode(shipmentContainerHeader.getUWarehouseCode());

            shipmentContainerDetaill.setCompanyCode(shipmentContainerHeader.getCompanyCode());
            shipmentContainerDetaill.setContainerCode(shipmentContainerHeader.getContainerCode());
            shipmentContainerDetaill.setLocationCode(shipmentContainerHeader.getLocationCode());
            shipmentContainerDetaill.setInventoryId(shipmentCombinationModel.getInventoryDetailId());
            shipmentContainerDetaill.setInventorySts(shipmentDetail.getInventorySts());
            shipmentContainerDetaill.setShippingContainerId(shipmentContainerHeader.getId());
            shipmentContainerDetaill.setShipmentCode(shipmentDetail.getShipmentCode());
            shipmentContainerDetaill.setShipmentId(shipmentDetail.getShipmentId());
            shipmentContainerDetaill.setShipmentDetailId(shipmentDetail.getId());
            shipmentContainerDetaill.setMaterialCode(shipmentDetail.getMaterialCode());
            shipmentContainerDetaill.setMaterialName(shipmentDetail.getMaterialName());
            shipmentContainerDetaill.setMaterialSpec(shipmentDetail.getMaterialSpec());
            shipmentContainerDetaill.setMaterialUnit(shipmentDetail.getMaterialUnit());
            shipmentContainerDetaill.setQty(shipmentCombinationModel.getShipQty());
            shipmentContainerDetaill.setWaveId(shipmentDetail.getWaveId());
            shipmentContainerDetaill.setTaskCreated(0);

            shipmentContainerDetaill.setStatus(QuantityConstant.SHIPMENT_CONTAINER_BUILD);

            shipmentContainerDetaill.setBatch(shipmentDetail.getBatch());
            shipmentContainerDetaill.setLot(shipmentDetail.getLot());
            shipmentContainerDetaill.setProjectNo(shipmentDetail.getProjectNo());
            shipmentContainerDetaill.setCreatedBy(ShiroUtils.getLoginName());

            shipmentContainerDetaill.setZoneCode(container.getZoneCode());

            flag = shipmentContainerDetailService.save(shipmentContainerDetaill);

            if (flag == false) {

                throw new ServiceException("新建组盘明细失败,sql错误");
            }

        }

        //4.查看组盘头状态，如果状态在10到30，则生成任务明细或修改任务明细的数量

        //查看任务头

        int containerHeaderStatus = shipmentContainerHeader.getStatus().intValue();

        if (QuantityConstant.SHIPMENT_CONTAINER_TASK <= containerHeaderStatus &&
                containerHeaderStatus < QuantityConstant.SHIPMENT_CONTAINER_FINISHED) {
            LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            taskHeaderLambdaQueryWrapper.eq(TaskHeader::getWarehouseCode, shipmentContainerHeader.getWarehouseCode())

                    .in(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_SORTINGSHIPMENT, QuantityConstant.TASK_TYPE_WHOLESHIPMENT)

                    .eq(TaskHeader::getAllocationHeadId, shipmentContainerHeader.getId());
            TaskHeader taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);
            if (taskHeader == null) {

                throw new ServiceException("有相同的组盘头，但找不到相应的任务头");

            }

            LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getContainerCode, shipmentContainerHeader.getContainerCode())
                    .eq(InventoryDetail::getWarehouseCode, shipmentContainerHeader.getWarehouseCode());
            List<InventoryDetail> inventories = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);
            BigDecimal inventoryTotal = new BigDecimal("0");
            for (InventoryDetail item : inventories) {
                BigDecimal lastQty = item.getQty().subtract(item.getTaskQty());
                inventoryTotal = inventoryTotal.add(lastQty);
            }

            InventoryDetail inventoryDetail=inventoryDetailService.getById(shipmentCombinationModel.getInventoryDetailId());
            if(inventoryDetail==null){
                throw new ServiceException("找不到对应的库存明细");
            }
            inventoryTotal = inventoryTotal.subtract(shipmentCombinationModel.getShipQty());

            String value = dictDataService.getDictValueByLabel(QuantityConstant.RULE_SHIPMENT_TASK, taskHeader.getZoneCode(), ShiroUtils.getWarehouseCode());
            int shipmentTaskRule = Integer.parseInt(value);
//            if (inventoryTotal.compareTo(new BigDecimal(0)) <= 0 && !container.getContainerType().equals(QuantityConstant.AGV_CONTAINER_TYPE)) {
            if (inventoryTotal.compareTo(new BigDecimal(0)) <= 0){
            //整盘出库
                if(shipmentTaskRule == QuantityConstant.RULE_TASK_WHOLE_SHIPMENT) {
                    taskHeader.setTaskType(QuantityConstant.TASK_TYPE_WHOLESHIPMENT);
                    taskHeaderService.updateById(taskHeader);
                }

            }

            if (shipmentContainerDetaill == null || shipmentContainerDetaill.getId() == null) {

                //shipmentContainerDetaill为空时，说明组盘明细不是新建，so修改任务明细
                //查找任务明细
                LambdaQueryWrapper<TaskDetail> taskDetailLam = Wrappers.lambdaQuery();

                taskDetailLam.eq(TaskDetail::getWarehouseCode, shipmentContainerDetail.getWarehouseCode())
                        .eq(TaskDetail::getAllocationId, shipmentContainerDetail.getId())
                        .eq(TaskDetail::getTaskId, taskHeader.getId())

                        .in(TaskDetail::getTaskType, QuantityConstant.TASK_TYPE_SORTINGSHIPMENT, QuantityConstant.TASK_TYPE_WHOLESHIPMENT);

                TaskDetail taskDetail = taskDetailService.getOne(taskDetailLam);

                if (taskDetail == null) {

                    throw new ServiceException("找不到对应的任务明细");
                }
                taskDetail.setQty(taskDetail.getQty().add(shipmentCombinationModel.getShipQty()));

                flag = taskDetailService.saveOrUpdate(taskDetail);
                if (flag == false) {

                    throw new ServiceException("修改任务明细失败,sql错误");
                }

                shipmentContainerDetail.setStatus(QuantityConstant.SHIPMENT_CONTAINER_TASK);
                if (!shipmentContainerDetailService.updateById(shipmentContainerDetail)) {
                    throw new ServiceException("修改组盘明细状态失败");
                }

            } else {

                //shipmentContainerDetaill不为空时，说明组盘明细是新建，so新建任务明细

                LambdaQueryWrapper<TaskDetail> taskDetailLam = Wrappers.lambdaQuery();

                taskDetailLam.eq(TaskDetail::getWarehouseCode, shipmentContainerDetaill.getWarehouseCode())
                        .eq(TaskDetail::getAllocationId, shipmentContainerDetaill.getId())

                        .eq(TaskDetail::getTaskId, taskHeader.getId())
                        .in(TaskDetail::getTaskType, QuantityConstant.TASK_TYPE_SORTINGSHIPMENT, QuantityConstant.TASK_TYPE_WHOLESHIPMENT);
                TaskDetail taskDetail = taskDetailService.getOne(taskDetailLam);
                if (taskDetail != null) {
                } else {
                    taskDetail = new TaskDetail();
                }

                taskDetail.setTaskId(taskHeader.getId());
                taskDetail.setInternalTaskType(taskHeader.getInternalTaskType());
                taskDetail.setWarehouseCode(taskHeader.getWarehouseCode());
                taskDetail.setCompanyCode(taskHeader.getCompanyCode());
                taskDetail.setTaskType(taskHeader.getTaskType());
                taskDetail.setAllocationId(shipmentContainerDetaill.getId());
                taskDetail.setBillCode(shipmentContainerDetaill.getShipmentCode());
                taskDetail.setBillDetailId(shipmentContainerDetaill.getShipmentDetailId());
                taskDetail.setMaterialCode(shipmentContainerDetaill.getMaterialCode());
                taskDetail.setMaterialName(shipmentContainerDetaill.getMaterialName());
                taskDetail.setMaterialSpec(shipmentContainerDetaill.getMaterialSpec());
                taskDetail.setMaterialUnit(shipmentContainerDetaill.getMaterialUnit());
                taskDetail.setFromInventoryId(shipmentContainerDetaill.getInventoryId());

                taskDetail.setToInventoryId(shipmentContainerDetaill.getInventoryId());
                taskDetail.setInventorySts(shipmentContainerDetaill.getInventorySts());

                taskDetail.setQty(shipmentContainerDetaill.getQty());
                taskDetail.setContainerCode(taskHeader.getContainerCode());
                taskDetail.setFromLocation(taskHeader.getFromLocation());
                taskDetail.setToLocation(taskHeader.getToLocation());
                taskDetail.setLot(shipmentContainerDetaill.getLot());
                taskDetail.setWaveId(shipmentContainerDetaill.getWaveId());
                taskDetail.setBatch(shipmentContainerDetaill.getBatch());

                taskDetail.setProjectNo(shipmentContainerDetaill.getProjectNo());

                taskDetail.setReferenceCode(shipmentDetail.getReferCode());

                taskDetail.setGoodsShelfNo(taskHeader.getGoodsShelfNo());

                if (shipmentContainerHeader.getStatus().equals(QuantityConstant.SHIPMENT_CONTAINER_TASK)) {

//                    taskDetail.setStatus(QuantityConstant.TASK_STATUS_BUILD);
                    taskDetail.setStatus(QuantityConstant.TASK_STATUS_RELEASE);

                } else {

                    taskDetail.setStatus(QuantityConstant.TASK_STATUS_RELEASE);

                }
                taskDetail.setCreatedBy(ShiroUtils.getLoginName());
                taskDetail.setLastUpdatedBy(ShiroUtils.getLoginName());

                flag = taskDetailService.saveOrUpdate(taskDetail);

                if (flag == false) {

                    throw new ServiceException("新建任务明细失败,sql错误");
                }

                shipmentContainerDetaill.setStatus(QuantityConstant.SHIPMENT_CONTAINER_TASK);
                if (!shipmentContainerDetailService.updateById(shipmentContainerDetaill)) {

                    throw new ServiceException("修改组盘明细状态失败");
                }

            }
        }

        return shipmentContainerDetail;
    }

    /**
     * 取消组盘的一组明细

     *

     * @param detailIds
     * @return
     */
    @Override

    public AjaxResult cancelCombinationDetail(List<Integer> detailIds) {

        List<ShipmentContainerDetail> shipmentContainerDetails = new ArrayList<>();

        for (int detailId : detailIds) {

            ShipmentContainerDetail shipmentContainerDetail = shipmentContainerDetailService.getById(detailId);
            shipmentContainerDetails.add(shipmentContainerDetail);
        }
        return cancelCombinationDetailInner(shipmentContainerDetails);
    }

    /**
     * 取消组盘的一组明细

     *

     * @param shipmentContainerDetails
     * @return
     */
    @Override

    @Transactional(rollbackFor = Exception.class)

    public AjaxResult cancelCombinationDetailInner(List<ShipmentContainerDetail> shipmentContainerDetails) {
        for (ShipmentContainerDetail shipmentContainerDetail : shipmentContainerDetails) {

            //获取头
            ShipmentContainerHeader shipmentContainerHeader = this.getById(shipmentContainerDetail.getShippingContainerId());

            if (shipmentContainerHeader.getStatus() >= QuantityConstant.SHIPMENT_CONTAINER_TASK) {
                return AjaxResult.error("容器" + shipmentContainerHeader.getContainerCode() + "非新建状态，不允许取消明细");

            }
            //恢复占用库存
            InventoryDetail inventoryDetail = inventoryDetailService.getById(shipmentContainerDetail.getInventoryId());

            if (inventoryDetail != null) {

                InventoryDetail inventoryDetail1 = new InventoryDetail();
                inventoryDetail1.setId(inventoryDetail.getId());
                inventoryDetail1.setTaskQty(inventoryDetail.getTaskQty().subtract(shipmentContainerDetail.getQty()));
                inventoryDetailService.updateById(inventoryDetail1);

                logger.info("扣减库存::" + inventoryDetail.getId() + "容器:" + inventoryDetail.getContainerCode() + "物料code:" + inventoryDetail.getMaterialCode() + "数量：" + inventoryDetail.getTaskQty() + "组盘数量：" + shipmentContainerDetail.getQty());

            }

            //恢复单据发货数量
            ShipmentDetail shipmentDetail = shipmentDetailService.getById(shipmentContainerDetail.getShipmentDetailId());

            shipmentDetail.setTaskQty(shipmentDetail.getTaskQty().subtract(shipmentContainerDetail.getQty()));