wms / hhwms · Files

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

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

import com.huaheng.common.constant.QuantityConstant;

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

import com.huaheng.common.utils.StringUtils;

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.receipt.receiptContainerDetail.domain.ReceiptContainerDetail;

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

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.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.domain.ShippingSearch;
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.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 io.swagger.models.auth.In;

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

import org.springframework.stereotype.Service;
import javax.annotation.Resource;

import java.math.BigDecimal;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.huaheng.pc.shipment.shipmentContainerHeader.domain.ShipmentContainerHeader;
import com.huaheng.pc.shipment.shipmentContainerHeader.mapper.ShipmentContainerHeaderMapper;

import org.springframework.transaction.annotation.Transactional;

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

    @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;

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



    /**

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

     * 出库组盘单条保存
     * @param shipmentCombinationModel
     * @return
     */
    @Transactional
    @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 + " 已经用于入库组盘");
        }

        //校验数量是否超出
        if((shipmentDetail.getShipQty().subtract(shipmentDetail.getRequestQty())).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() + " 不存在");
        }

        //2.更新库存分配数

        inventoryDetail.setTaskQty(inventoryDetail.getTaskQty().add(shipmentCombinationModel.getShipQty()));
        inventoryDetailService.saveOrUpdate(inventoryDetail);

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

        shipmentDetail.setRequestQty(shipmentDetail.getRequestQty().add(shipmentCombinationModel.getShipQty()));
        int i = shipmentDetail.getShipQty().compareTo(shipmentDetail.getRequestQty());
        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("出库数量不能大于单据数量！");
        }
        shipmentDetailService.saveOrUpdate(shipmentDetail);

        //自动判定出库任务状态，根据库存数量减去预定库存相等就是整盘出--预计任务状态
        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);

        }

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

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

        //7.更新单据状态

        shipmentHeaderService.updateShipmentStatus(shipmentDetail.getShipmentId());

        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)  {

            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;
                    }

                }

            }

            shipmentContainerHeader = new ShipmentContainerHeader();
            shipmentContainerHeader.setContainerCode(location.getContainerCode());
            shipmentContainerHeader.setLocationCode(location.getCode());
            shipmentContainerHeader.setWarehouseCode(ShiroUtils.getWarehouseCode());
            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();

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

        if(shipmentContainerDetail != null)    {
            shipmentContainerDetail.setQty(shipmentContainerDetail.getQty().add(shipmentCombinationModel.getShipQty()));

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

            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("有相同的组盘头，但找不到相应的任务头");

            }

            if(shipmentContainerDetaill == 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错误");
                }

            }else {

                //shipmentContainerDetaill不为空时，说明组盘明细是新建，so新建任务明细
                TaskDetail 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.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());

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

                    taskDetail.setStatus(QuantityConstant.TASK_STATUS_BUILD);

                } else {

                    taskDetail.setStatus(QuantityConstant.TASK_STATUS_RELEASE);

                }
                taskDetail.setCreatedBy(ShiroUtils.getLoginName());
                taskDetail.setLastUpdatedBy(ShiroUtils.getLoginName());
                flag = taskDetailService.save(taskDetail);
                if(flag == false){
                    throw new ServiceException("新建任务明细失败,sql错误");
                }

            }
        }

        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
    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());
            inventoryDetail.setTaskQty(inventoryDetail.getTaskQty().subtract(shipmentContainerDetail.getQty()));
            inventoryDetailService.saveOrUpdate(inventoryDetail);
            //恢复单据发货数量
            ShipmentDetail shipmentDetail = shipmentDetailService.getById(shipmentContainerDetail.getShipmentDetailId());
            shipmentDetail.setRequestQty(shipmentDetail.getRequestQty().subtract(shipmentContainerDetail.getQty()));
            if(shipmentDetail.getRequestQty().compareTo(BigDecimal.ZERO) != 0 ){

                shipmentDetail.setStatus(QuantityConstant.SHIPMENT_HEADER_WAVE);//明细状态恢复,如果删除后还有以出数量就是波次

            }else{

                shipmentDetail.setStatus(QuantityConstant.SHIPMENT_HEADER_POOL );//明细状态

            }
            shipmentDetailService.saveOrUpdate(shipmentDetail);
            //删除这个配盘明细
            shipmentContainerDetailService.removeById(shipmentContainerDetail.getId());

            //查询头表下还有没有明细，如果没有，则删了这个头表
            ShipmentContainerDetail condition = new ShipmentContainerDetail();
            condition.setShippingContainerId(shipmentContainerDetail.getShippingContainerId());
            List<Map<String, Object>> list= shipmentContainerDetailService.selectListMapByEqual("id", condition);
            if(list==null||list.size() == 0){
                this.removeById(shipmentContainerHeader.getId());

                locationService.updateStatus(shipmentContainerHeader.getLocationCode(),
                        QuantityConstant.STATUS_LOCATION_EMPTY);

            }
            //更新单据状态
            shipmentHeaderService.updateShipmentStatus(shipmentDetail.getShipmentId());
        }
        return AjaxResult.success("");
    }

    /**
     * 取消组盘
     * @param shipmentContainerIds
     * @return
     */
    @Override
    public AjaxResult cancelCombination(List<Integer> shipmentContainerIds)  {

        AjaxResult result = checkForCancelCombination(shipmentContainerIds);
        if(result.getCode()!= RetCode.SUCCESS.getValue()){
            return result;
        }
        for(int id : shipmentContainerIds){
            LambdaQueryWrapper<ShipmentContainerDetail> lambdaQueryWrapper=Wrappers.lambdaQuery();
            lambdaQueryWrapper.eq(ShipmentContainerDetail::getShippingContainerId,id);
            List<ShipmentContainerDetail> shipmentContainerDetails = shipmentContainerDetailService.list(lambdaQueryWrapper);
            result = cancelCombinationDetailInner(shipmentContainerDetails);
            if(result.hasErr()){
                return result;
            }
        }

        return AjaxResult.success("");
    }

    /**
     *  出库自动组盘
     * @param shipmentCode
     * @return
     */
    @Override
    @Transactional
    public AjaxResult autoCombination(String shipmentCode) {

        LambdaQueryWrapper<ShipmentHeader> shipmentHeaderLam = Wrappers.lambdaQuery();
        shipmentHeaderLam.eq(ShipmentHeader::getWarehouseCode,ShiroUtils.getWarehouseCode())
                .eq(ShipmentHeader::getCode,shipmentCode);
        ShipmentHeader shipmentHeader = shipmentHeaderService.getOne(shipmentHeaderLam);
        if(shipmentHeader == null){
            throw new ServiceException("系统没有此单据");
        }

        shipmentPreferenceService.checkShipmentProcess(shipmentHeader.getId().toString(),100,shipmentCode);

        LambdaQueryWrapper<ShipmentDetail> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(ShipmentDetail::getShipmentCode, shipmentCode)
                .eq(ShipmentDetail::getWarehouseCode, ShiroUtils.getWarehouseCode());

        List<ShipmentDetail> shipmentDetailList = shipmentDetailService.list(lambdaQueryWrapper);

        if (shipmentDetailList.isEmpty()) {

            return AjaxResult.error("找不到子单链");
        }

        for(ShipmentDetail shipmentDetail: shipmentDetailList){
            if(shipmentDetail.getWaveId() != 0){
                return AjaxResult.error(shipmentCode+"单号已加入波次"+shipmentDetail.getWaveId()+",无法自动组盘");
            }
        }

        return this.autoCombination(shipmentDetailList);
    }


    //出库自动组盘

    @Override

    public AjaxResult autoCombination(List<ShipmentDetail> shipmentDetailList){
        int num = 0;

        List<Integer> list = new ArrayList<>();

        for (ShipmentDetail item : shipmentDetailList) {
            //获取需要出库数量
            BigDecimal shipmentQty = item.getShipQty().subtract(item.getRequestQty());

            String userDef1 = item.getUserDef1();
            if (StringUtils.isNotEmpty(userDef1)) {
                shipmentQty = new BigDecimal(userDef1);
            }

            //判断是否还有需要出库的物料，如果没有就跳过该物料
            if (shipmentQty.compareTo(BigDecimal.ZERO) <= 0) {
                continue;
            }

            List<InventoryDetail> inventoryList = shippingCombinationService.getInventorys(item);

            //去除已锁的库存

            ArrayList<InventoryDetail> removeInventoryList = new ArrayList<>();
            List<TaskHeader> taskHeaderList = taskHeaderService.getUnCompleteTaskList();
            List<ReceiptContainerHeader> receiptContainerHeaderList =
                    receiptContainerHeaderService.getUnCompleteCombineList();

            boolean lock = false;
            for (InventoryDetail inventoryDetail : inventoryList) {

                LambdaQueryWrapper<Container> containerLambdaQueryWrapper  = Wrappers.lambdaQuery();
                containerLambdaQueryWrapper.eq(Container::getCode, inventoryDetail.getContainerCode());
                Container container = containerService.getOne(containerLambdaQueryWrapper);
                if (QuantityConstant.STATUS_CONTAINER_LOCK.equals(container.getStatus())) {
                    removeInventoryList.add(inventoryDetail);

                    lock = true;
                }

                if(taskHeaderList != null) {
                    for(TaskHeader taskHeader : taskHeaderList) {
                        if(taskHeader.getContainerCode().equals(container.getCode())) {
                            removeInventoryList.add(inventoryDetail);
                        }
                    }
                }
                if(receiptContainerHeaderList != null) {
                    for(ReceiptContainerHeader receiptContainerHeader : receiptContainerHeaderList) {
                        if(receiptContainerHeader.getContainerCode().equals(container.getCode())) {
                            removeInventoryList.add(inventoryDetail);
                        }
                    }
                }

            }

            inventoryList.removeAll(removeInventoryList);

            if (inventoryList.size()<1 && lock){
                return AjaxResult.success("明细id为"+item.getId()+"的物料所在托盘全部处于锁定状态，请完成或取消任务后再进行组盘");
            }

            if(inventoryList.size() < 1 && item.getWaveId() != 0){

                Wave wave = waveService.getById(item.getWaveId());

                wave.setStatus(QuantityConstant.WAVE_STATUS_ERROR);
                wave.setCurrentWaveStep(QuantityConstant.WAVE_STEP_ERROR);
                wave.setLastWaveStep(QuantityConstant.WAVE_STEP_BUILD);

                waveService.updateById(wave);

                throw new ServiceException("主单为"+item.getShipmentCode()+"子单id为"+item.getId() + "的单据没有库存，波次失败");

            }

            if (inventoryList.size() < 1) {
                num = num + 1;
            } else {
                for (InventoryDetail inventory : inventoryList) {
                    //判断是否组盘完毕，完毕就退出内循环
                    if (shipmentQty.compareTo(BigDecimal.ZERO) <= 0) {
                        break;
                    }

                    BigDecimal inventoryQty = inventory.getQty().subtract(inventory.getTaskQty());
                    ShipmentCombinationModel shipmentCombination = new ShipmentCombinationModel();
                    shipmentCombination.setInventoryDetailId(inventory.getId());
                    shipmentCombination.setShipmentDetailId(item.getId());

                    shipmentCombination.setType((short) QuantityConstant.TASK_TYPE_WHOLESHIPMENT);

                    //如果库存数 >= 待出库数，组盘数就是待出库数并且结束组盘，否则组盘数就是库存数
                    if (inventoryQty.compareTo(shipmentQty) > -1) {
                        shipmentCombination.setShipQty(shipmentQty);
                    } else {
                        shipmentCombination.setShipQty(inventoryQty);
                    }

                    ShipmentContainerHeader shipmentContainerHeader=this.combination(shipmentCombination);
                    list.add(shipmentContainerHeader.getId());

                    shipmentQty = shipmentQty.subtract(shipmentCombination.getShipQty());
                }
            }
        }

        if(num == shipmentDetailList.size()){

            throw new ServiceException("单据物料的库存分配规则在此库区没有库存,无法出库");

        }

        return AjaxResult.success("成功",list);

    }

    /**
     * 检查是否可以进行取消配盘
     * @param shipmentContainerIds
     * @return
     */
    @Override
    public AjaxResult checkForCancelCombination(List<Integer> shipmentContainerIds) {
        for(int id : shipmentContainerIds){
            ShipmentContainerHeader shipmentContainerHeader = this.getById(id);

            if(shipmentContainerHeader.getStatus()>=QuantityConstant.SHIPMENT_CONTAINER_TASK){

                return AjaxResult.error("存在已生成任务的记录，请先取消任务再取消组盘");
            }
        }
        return AjaxResult.success("");
    }

    /* 生成任务 */
    @Override
    @Transactional
    public AjaxResult createTask(List<Integer> idList) {
        ShipmentTaskCreateModel shipmentTask = new ShipmentTaskCreateModel();
        for (Integer id : idList)   {
            shipmentTask.setShipmentContainerHeaderIds(id);

            AjaxResult ajaxResult = shipmentTaskService.createTaskFromShipmentContainers(shipmentTask);

            if(ajaxResult.hasErr()){
                return ajaxResult;
            }

        }
        return AjaxResult.success("全部生成完毕");
    }

    /**
     * 取消出库任务
     */
    @Override
    @Transactional(rollbackFor = ServiceException.class)
    public boolean cancelShipment(Integer combineHeaderId) {
        // 回滚组盘主表状态
        ShipmentContainerHeader shipmentContainerHeader = new ShipmentContainerHeader();
        shipmentContainerHeader.setId(combineHeaderId);
        shipmentContainerHeader.setStatus(QuantityConstant.SHIPMENT_CONTAINER_BUILD);
        if (!updateById(shipmentContainerHeader)){
            throw new ServiceException("更新出库组盘头表失败");
        }
        // 回滚组盘明细状态
        LambdaQueryWrapper<ShipmentContainerDetail> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(ShipmentContainerDetail::getShippingContainerId,combineHeaderId);
        List<ShipmentContainerDetail> shipmentContainerDetailList = shipmentContainerDetailService.list(queryWrapper);
        for (ShipmentContainerDetail shipmentContainerDetail : shipmentContainerDetailList) {
            shipmentContainerDetail.setStatus(QuantityConstant.SHIPMENT_CONTAINER_BUILD);
        }
        if (!shipmentContainerDetailService.updateBatchById(shipmentContainerDetailList)){
            throw new ServiceException("更新出库组盘明细失败");
        }
        return true;
    }

    @Override
    public AjaxResult getShipmentInfoByCode(String code) {
        LambdaQueryWrapper<ShipmentContainerDetail> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(ShipmentContainerDetail::getShipmentCode, code)
                .eq(ShipmentContainerDetail::getWarehouseCode, ShiroUtils.getWarehouseCode());

        List<ShipmentContainerDetail> shipmentContainerDetails = shipmentContainerDetailService.list(lambdaQueryWrapper);
        return AjaxResult.success(shipmentContainerDetails);
    }

    @Override
    public int getUnCompleteCombineNumber(String containerCode) {
        LambdaQueryWrapper<ShipmentContainerHeader> shipmentContainerHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        shipmentContainerHeaderLambdaQueryWrapper.eq(ShipmentContainerHeader::getContainerCode, containerCode)
                .lt(ShipmentContainerHeader::getStatus, QuantityConstant.SHIPMENT_CONTAINER_FINISHED);
        int number = 0;
        List<ShipmentContainerHeader> shipmentContainerHeaderList = list(shipmentContainerHeaderLambdaQueryWrapper);
        if(shipmentContainerHeaderList != null && shipmentContainerHeaderList.size() > 0) {
            number = shipmentContainerHeaderList.size();
        }
        return number;
    }

    @Override
    public List<ShipmentContainerHeader> getUnCompleteCombineList() {
        LambdaQueryWrapper<ShipmentContainerHeader> shipmentContainerHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        shipmentContainerHeaderLambdaQueryWrapper.lt(ShipmentContainerHeader::getStatus,
                QuantityConstant.SHIPMENT_CONTAINER_FINISHED);
        List<ShipmentContainerHeader> shipmentContainerHeaderList =
                list(shipmentContainerHeaderLambdaQueryWrapper);
        return  shipmentContainerHeaderList;
    }

}