wms / hhwms · Files

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


import com.huaheng.common.exception.service.ServiceException;
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.general.customer.domain.ShipMaterialDetail;
import com.huaheng.pc.general.location.domain.Location;
import com.huaheng.pc.general.location.service.ILocationService;
import com.huaheng.pc.general.material.domain.Material;
import com.huaheng.pc.general.material.service.IMaterialService;
import com.huaheng.pc.inventory.inventory.domain.Inventory;
import com.huaheng.pc.inventory.inventory.service.IInventoryService;
import com.huaheng.pc.receipt.receiptContainerHeader.domain.ShipmentContainerDetailSearchModel;
import com.huaheng.pc.shipment.shipmentContainerDetail.domain.ShipmentContainerDetail;
import com.huaheng.pc.shipment.shipmentContainerDetail.service.IShipmentContainerDetailService;
import com.huaheng.pc.shipment.shipmentContainerHeader.domain.ShipmentAutoCombinationModel;
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.shipmentContainerHeader.mapper.ShipmentContainerHeaderMapperAuto;
import com.huaheng.pc.shipment.shipmentDetail.domain.ShipmentDetail;
import com.huaheng.pc.shipment.shipmentDetail.service.IShipmentDetailService;
import com.huaheng.pc.shipment.shipmentHeader.domain.ShipmentHeader;
import com.huaheng.pc.shipment.shipmentHeader.service.IShipmentHeaderService;
import com.huaheng.pc.shipment.shippingCombination.domain.ShippingSearch;
import com.huaheng.pc.shipment.shippingCombination.service.ShippingCombinationService;
import com.huaheng.pc.task.task.domain.ShipmentTaskCreateModel;
import com.huaheng.pc.task.task.domain.Task;
import com.huaheng.pc.task.task.service.ITaskService;
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.*;


/**
 * 出库组盘头 服务层实现
 * 
 * @author huaheng
 * @date 2018-08-19
 */
@Service
public class ShipmentContainerHeaderServiceImpl implements IShipmentContainerHeaderService {

    @Resource
    private ShipmentContainerHeaderMapperAuto aotuMapper;
    @Resource
    private ShipmentContainerHeaderMapper shipmentContainerHeaderMapper;
    @Autowired
    ShippingCombinationService shippingCombinationService;
    @Autowired
    IShipmentContainerDetailService shipmentContainerDetailService;
    @Autowired
    IShipmentHeaderService shipmentHeaderService;
    @Autowired
    IShipmentDetailService shipmentDetailService;
    @Autowired
    IInventoryService inventoryService;
    @Autowired
    ILocationService locationService;
    @Autowired
    IMaterialService materialService;
    @Autowired
    ITaskService taskService;


    public List<ShipmentContainerHeader> selectListEntityByLike(ShipmentContainerHeader condition) {
        return aotuMapper.selectListEntityByLike(condition);

    }

    public List<ShipmentContainerHeader> selectListEntityByEqual(ShipmentContainerHeader condition) {
        return aotuMapper.selectListEntityByEqual(condition);
    }

    public ShipmentContainerHeader selectFirstEntity(ShipmentContainerHeader condition) {
        ShipmentContainerHeader item = aotuMapper.selectFirstEntity(condition);
        return item;
    }

    public ShipmentContainerHeader selectEntityById(Integer id) {
        return aotuMapper.selectEntityById(id);
    }

    public List<Map<String, Object>> selectListMapByEqual(String columns, ShipmentContainerHeader condition) {
        return aotuMapper.selectListMapByEqual(columns, condition);
    }

    public Map<String, Object> selectFirstMap(String columns, ShipmentContainerHeader condition) {
        Map<String, Object> item = aotuMapper.selectFirstMap(columns, condition);
        return item;
    }

    public int insert(ShipmentContainerHeader record) {
        return aotuMapper.insert(record);
    }

    public int updateByModel(ShipmentContainerHeader record) {
        return aotuMapper.updateByModel(record);
    }

    public int updateByCondition(ShipmentContainerHeader record, ShipmentContainerHeader condition) {
        return aotuMapper.updateByCondition(record, condition);
    }

    public int deleteById(Integer id) {
        return aotuMapper.deleteById(id);
    }

    public int deleteByCondition(ShipmentContainerHeader condition) {
        return aotuMapper.deleteByCondition(condition);
    }

    /**
     * 返回货箱头列表
     * @param shipmentContainerHeader
     * @return
     */
    @Override
    public List<ShipmentContainerHeader> getShipmentContainerHeaders(ShipmentContainerHeader shipmentContainerHeader) {
        shipmentContainerHeader.setWarehouseId(ShiroUtils.getWarehouseId());
        List<ShipmentContainerHeader>  list = shipmentContainerHeaderMapper.getShipmentContainerHeaders(shipmentContainerHeader);
        return list;
    }

    @Override
    public List<ShipmentContainerHeader> selectAgvListByLike(String shelfNo, String warehouseCode){
        return shipmentContainerHeaderMapper.selectAgvListByLike(shelfNo,warehouseCode);
    }

    @Override
    public int updateList(String shelfNo,String warehouseCode) {
        return shipmentContainerHeaderMapper.updateList(shelfNo,warehouseCode);
    }

    /* 生成任务 */
    @Override
    @Transactional
    public AjaxResult createTask(List<Integer> idList) {
        ShipmentTaskCreateModel shipmentTask = new ShipmentTaskCreateModel();
        for (Integer id : idList)   {
            shipmentTask.setShipmentContainerHeaderIds(id);
            AjaxResult ajaxResult = taskService.createTaskFromShipmentContainers(shipmentTask);
            if(ajaxResult.hasErr()){
                return ajaxResult;
            }
        }
        return AjaxResult.success("全部生成完毕");
    }

    /**
     *  出库自动组盘
     * @param shipmentCode
     * @return
     */
    @Override
    @Transactional
    public AjaxResult autoCombination(String shipmentCode) {
        int num=0;
        AjaxResult ajaxResult=new AjaxResult();
        ShipmentDetail shipmentDetail = new ShipmentDetail();
        shipmentDetail.setShipmentCode(shipmentCode);
        shipmentDetail.setWarehouseId(ShiroUtils.getWarehouseId());
        List<ShipmentDetail> shipmentDetailList = shipmentDetailService.selectListDetail(shipmentDetail);
        for (ShipmentDetail item : shipmentDetailList) {
            //库区为null时提示
            if (item.getZoneCode() == null) {
                throw new ServiceException("请分配明细ID为 <br/> “" + item.getId() + "”  的库区,再执行自动组盘！");
            }
            //获取需要出库数量
            BigDecimal shipmentQty = item.getQty().subtract(item.getQtyCompleted());
            //判断是否还有需要出库的物料，如果没有就跳过该物料
            if (shipmentQty.compareTo(BigDecimal.ZERO) <= 0) {
                continue;
            }
            // 根据 仓库编码、货主编码、存货编码，物料状态，项目号来查找可以出库的物料
            ShippingSearch search = new ShippingSearch();
            search.setWarehouseCode(ShiroUtils.getWarehouseCode());
            search.setCompanyCode(item.getCompanyCode());
            search.setZoneCode(item.getZoneCode());
            search.setMaterialCode(item.getMaterialCode());
            search.setInventoryStatus(item.getInventoryStatus()); //物料状态
            search.setProject(item.getProject());//项目号

            List<Inventory> inventoryList = shippingCombinationService.getInventory(search);
            if (inventoryList.size() < 1) {
                num = num + 1;
            } else {
                for (Inventory inventory : inventoryList) {
                    //判断是否组盘完毕，完毕就退出内循环
                    if (shipmentQty.compareTo(BigDecimal.ZERO) <= 0) {
                        break;
                    }
                    BigDecimal inventoryQty = inventory.getQty().subtract(inventory.getTaskQty());
                    ShipmentCombinationModel shipmentCombination = new ShipmentCombinationModel();
                    shipmentCombination.setInventoryId(inventory.getId());
                    shipmentCombination.setShipmentDetailId(item.getId());
                    shipmentCombination.setType((short) 300);
                    List<Integer> list=new ArrayList<>();
                    //如果库存数 >= 待出库数，组盘数就是待出库数并且结束组盘，否则组盘数就是库存数
                    if (inventoryQty.compareTo(shipmentQty) > -1) {
                        shipmentCombination.setQty(shipmentQty);
                        ShipmentContainerHeader shipmentContainerHeader=this.combination(shipmentCombination);

                    } else {
                        shipmentCombination.setQty(inventoryQty);
                        ShipmentContainerHeader shipmentContainerHeader=this.combination(shipmentCombination);
                        list.add(shipmentContainerHeader.getId());

                    }
                    shipmentQty = shipmentQty.subtract(shipmentCombination.getQty());
                }
            }
        }
        if(num==shipmentDetailList.size()){
            throw new ServiceException("单据物料在此库区没有库存,无法出库");
        }
        return AjaxResult.success("");
    }



    /**
     * 出库组盘单条保存
     * @param shipmentCombination
     * @return
     */
    @Transactional
    @Override
    public ShipmentContainerHeader combination(ShipmentCombinationModel shipmentCombination) {
        //获取库存, 然后检查货物是否足够操作，更新库存分配数
        Inventory inventory = inventoryService.selectEntityById(shipmentCombination.getInventoryId());
        if (inventory == null) {
            throw new ServiceException("库存ID(" + shipmentCombination.getInventoryId() + ")不存在");
        }
        if(inventory.getQty().subtract(inventory.getTaskQty()).compareTo(shipmentCombination.getQty()) < 0
                || shipmentCombination.getQty().compareTo(BigDecimal.ZERO) == 0) {
            throw new ServiceException("容器" + inventory.getContainerCode() + "已经完成出库，没有相应货物");
        }
        inventory.setTaskQty(inventory.getTaskQty().add(shipmentCombination.getQty()));
        inventoryService.updateByModel(inventory);
        //获取库位，然后锁定
        Location location = new Location();
        location.setWarehouseCode(inventory.getWarehouseCode());
        location.setCode(inventory.getLocationCode());
        location = locationService.selectFirstEntity(location);
        location.setStatus("lock");
        locationService.updateByModel(location);
        //更新单据明细的已出库数量
        ShipmentDetail shipmentDetail = shipmentDetailService.selectEntityById(shipmentCombination.getShipmentDetailId());
        if(shipmentDetail.getQtyCompleted().add(shipmentCombination.getQty()).compareTo(shipmentDetail.getQty()) > 0) {
            throw new ServiceException("组盘数量超出单据数量");
        }
        shipmentDetail.setQtyCompleted(shipmentDetail.getQtyCompleted().add(shipmentCombination.getQty()));
        int i = shipmentDetail.getQty().compareTo(shipmentDetail.getQtyCompleted());
        if(i > 0){
            shipmentDetail.setStatus((short)200);
        }else if(i == 0){
            shipmentDetail.setStatus((short)300);
        }else if(i < 0){
            throw new ServiceException("出库数量不能大于单据数量！");
        }
        shipmentDetailService.updateByModel(shipmentDetail);

        //自动判定出库任务状态，根据库存数量减去预定库存相等就是整盘出--预计任务状态
        BigDecimal inventoryQty = inventory.getQty().subtract(inventory.getTaskQty());
        if(inventoryQty.compareTo(new BigDecimal(0)) <= 0) {
            shipmentCombination.setTaskType(300);
        } else {
            shipmentCombination.setTaskType(400);
        }
        //增加出库组盘头
        ShipmentContainerHeader shipmentContainerHeader = ShipmentContainerHeaderAdd(location, shipmentDetail, shipmentCombination);
        //增加出库组盘明细
        ShipmentContainerDetail shipmentContainerDetail = ShipmentContainerDetailAdd(shipmentDetail, shipmentContainerHeader, shipmentCombination);
        //更新单据状态
        shipmentHeaderService.updateShipmentStatus(shipmentDetail.getShipmentId());

        return  shipmentContainerHeader;
    }

    /**
     * 出库组盘批量保存
     * @param shipmentCombinationModels
     * @return
     */
    @Transactional
    @Override
    public AjaxResult  Batchcombination(List<ShipmentCombinationModel> shipmentCombinationModels)  {
        //校验不通过就中止
        //System.out.println("=*=*=*=*=*=*=*=*=*=*=*=*=shipmentCombinationModels:" + shipmentCombinationModels.toString());
        for (ShipmentCombinationModel shipmentCombinationModel:shipmentCombinationModels){
            AjaxResult AjaxResult = checkCombination(shipmentCombinationModel);
            if(AjaxResult.hasErr()){
                return AjaxResult;
            }
        }
        List<Integer> containerHeaderIds = new ArrayList<>();
        for (ShipmentCombinationModel shipmentCombinationModel:shipmentCombinationModels) {
            ShipmentContainerHeader shipmentContainerHeader = combination(shipmentCombinationModel);
            containerHeaderIds.add(shipmentContainerHeader.getId());
        }
        return AjaxResult.success(containerHeaderIds);
    }

    /**
     * 在组盘表中查找任务状态小于20的容器，如果状态为0就合并出库明细，状态大于0就提示不能组盘。如果找不到就新增一条组盘表头
     * @param location
     * @param shipmentCombination
     * @return
     */
    private ShipmentContainerHeader ShipmentContainerHeaderAdd(Location location,
                                                               ShipmentDetail shipmentDetail,
                                                               ShipmentCombinationModel shipmentCombination) {
        ShipmentContainerHeader ShipmentCondition = new ShipmentContainerHeader();
        ShipmentCondition.setShipmentContainerCode(location.getContainerCode());
        ShipmentCondition.setWarehouseId(ShiroUtils.getWarehouseId());
        ShipmentContainerHeader shipmentContainerHeader = shipmentContainerHeaderMapper.selectUnPickted(ShipmentCondition);
        if(shipmentContainerHeader != null)  {
            throw new ServiceException("容器"+location.getContainerCode()+"已经生成任务，不能再添加明细;操作中止；");
//            if(shipmentContainerHeader.getStatus() == 0)  {
//                //以最后一次希望创建的出库任务类型为准
//                if (shipmentContainerHeader.getTaskType() != shipmentCombination.getTaskType())  {
//                    shipmentContainerHeader.setTaskType((short)shipmentCombination.getTaskType());
//                    this.updateByModel(shipmentContainerHeader);
//                }
//        }
//            else  {
//                throw new ServiceException("容器"+location.getContainerCode()+"已经生成任务，不能再添加明细;操作中止；");
//            }
        }
        else {
            shipmentContainerHeader = new ShipmentContainerHeader();
            shipmentContainerHeader.setShipmentContainerCode(location.getContainerCode());
            shipmentContainerHeader.setWarehouseId(ShiroUtils.getWarehouseId());
            shipmentContainerHeader = shipmentContainerHeaderMapper.selectUnPickteds(ShipmentCondition);
            if (shipmentContainerHeader == null) {
                shipmentContainerHeader = new ShipmentContainerHeader();
                shipmentContainerHeader.setTaskType((short) shipmentCombination.getTaskType());
                //AGV库区的只能分拣出库,钱柜库区的只能分拣出库
                if (location.getZoneCode().equals("AGV") || location.getZoneCode().equals("QG")) {
                    shipmentContainerHeader.setTaskType((short) 400);
                }
//            else    {
//                shipmentContainerHeader.setTaskType((short)shipmentCombination.getTaskType());
//            }
                ////从主单获取u8的仓库
                ShipmentHeader shipmentHeader = new ShipmentHeader();
                shipmentHeader.setCode(shipmentDetail.getShipmentCode());
                shipmentHeader = shipmentHeaderService.selectFirstEntity(shipmentHeader);

                shipmentContainerHeader.setTaskTypeReal((short) shipmentCombination.getTaskType());//预期任务类型
                shipmentContainerHeader.setShipmentContainerCode(location.getContainerCode());
                shipmentContainerHeader.setLocationCode(location.getCode());
                shipmentContainerHeader.setWarehouseCode(ShiroUtils.getWarehouseCode());
                shipmentContainerHeader.setWarehouseId(ShiroUtils.getWarehouseId());
                //赋值u8仓库
                shipmentContainerHeader.setuWarehouseCode(shipmentHeader.getuWarehouseCode());
                shipmentContainerHeader.setCompanyId(shipmentDetail.getCompanyId());
                shipmentContainerHeader.setCompanyCode(shipmentDetail.getCompanyCode());
                shipmentContainerHeader.setZoneCode(shipmentDetail.getZoneCode());
                shipmentContainerHeader.setStatus((short) 0);
                shipmentContainerHeader.setCreatedBy(ShiroUtils.getLoginName());
                shipmentContainerHeader.setCreated(null);
//            Material material=new Material();
//            material.setCode(shipmentDetail.getMaterialCode());
//            shipmentContainerHeader.setZoneCode(materialService.selectFirstEntity(material).getZoneCode());
                this.insert(shipmentContainerHeader);
            }
        }
        return shipmentContainerHeader;
    }

    /**
     * 查询 容器编码、库存Id、出库明细Id 一致的组盘明细，如果存在则增加组盘数量，如果不存在就新增一条组盘明细
     * @param shipmentDetail
     * @param shipmentContainerHeader
     * @param shipmentCombinationModel
     * @return
     */
    private ShipmentContainerDetail ShipmentContainerDetailAdd(ShipmentDetail shipmentDetail,
                                                               ShipmentContainerHeader shipmentContainerHeader,
                                                               ShipmentCombinationModel shipmentCombinationModel) {
        ShipmentContainerDetail condition = new ShipmentContainerDetail();
        condition.setHeaderId(shipmentContainerHeader.getId());
        condition.setShipmentDetailId(shipmentCombinationModel.getShipmentDetailId());
        condition.setInventoryId(shipmentCombinationModel.getInventoryId());
        ShipmentContainerDetail shipmentContainerDetail = shipmentContainerDetailService.selectFirstEntity(condition);
        if(shipmentContainerDetail != null)    {
            shipmentContainerDetail.setQty(shipmentContainerDetail.getQty().add(shipmentCombinationModel.getQty()));
            shipmentContainerDetailService.updateByModel(shipmentContainerDetail);
        }
        else    {
            //构建明细
            Material material = materialService.getEnableMaterialByCode(shipmentDetail.getMaterialCode());
            if (material == null)
                throw new ServiceException("出库单(" + shipmentDetail.getShipmentCode() + ")的物料("+ shipmentDetail.getMaterialCode() +")不存在！");
            shipmentContainerDetail = new ShipmentContainerDetail();
            shipmentContainerDetail.setHeaderId(shipmentContainerHeader.getId());
            shipmentContainerDetail.setShipmentCode(shipmentDetail.getShipmentCode());
            shipmentContainerDetail.setShipmentHeaderId(shipmentDetail.getShipmentId());
            shipmentContainerDetail.setShipmentDetailId(shipmentCombinationModel.getShipmentDetailId());
            shipmentContainerDetail.setMaterialCode(material.getCode());
            shipmentContainerDetail.setMaterialName(material.getName());
            shipmentContainerDetail.setInventoryId(shipmentCombinationModel.getInventoryId());
            shipmentContainerDetail.setQty(shipmentCombinationModel.getQty());
            shipmentContainerDetail.setCreated(null);
            shipmentContainerDetail.setCreatedBy(ShiroUtils.getLoginName());
            shipmentContainerDetail.setProject(shipmentDetail.getProject());

            shipmentContainerDetailService.insert(shipmentContainerDetail);
        }
        return shipmentContainerDetail;
    }
    //PDA出库自动组盘
    @Override
    public AjaxResult autoCombination(List<ShipmentAutoCombinationModel> shipmentAutoCombinationModels) {
        AjaxResult AjaxResult = checkAutoCombination(shipmentAutoCombinationModels);
        if(AjaxResult.hasErr()){
            return AjaxResult;
        }
        List<ShipmentDetail> shipmentDetails = getShipDetails(shipmentAutoCombinationModels);
        if(shipmentDetails == null) {
            return AjaxResult.error("出库明细未找到");
        }
        Map<Integer, BigDecimal> qtyCompleteList = new HashMap<>();
        for(ShipmentDetail shipmentDetail :shipmentDetails) {
            qtyCompleteList.put(shipmentDetail.getId(), shipmentDetail.getQtyCompleted());
        }
        List<ShipmentCombinationModel> shipmentCombinationModels = new ArrayList<>();
        List<ShipMaterialDetail> shipMaterialDetails = getShipmentMaterial(shipmentDetails, shipmentAutoCombinationModels); //合并相同物品的明细
        for(ShipMaterialDetail shipMaterialDetail : shipMaterialDetails) {
            int flag = 0;
            BigDecimal totalShipmentQty = shipMaterialDetail.getQty().subtract(shipMaterialDetail.getQtyCompleted());
            List<Inventory> inventorys = getInventorys(shipMaterialDetail.getMaterialCode(),
                    shipMaterialDetail.getWarehouseCode(), totalShipmentQty,
                    shipmentAutoCombinationModels.get(0));
            if (inventorys == null) {
                return AjaxResult.error("库存未找到");
            }
            //前面校验的时候已经判断出库存是够的，然后对库存按照先进先出进行了排序，现在优先整盘先出
            for (Inventory inventory : inventorys) {
                //有单个库位库存是大于等于某个物品总出库单详情
                if (inventory.getQty().subtract(inventory.getTaskQty()).compareTo(totalShipmentQty) >= 0) {
                    for (int shipmentDetailId : shipMaterialDetail.getShipDetailId()) {
                        ShipmentDetail shipmentDetail = shipmentDetailService.selectEntityById(shipmentDetailId);
                        ShipmentAutoCombinationModel shipmentAutoCombinationModel = getShipmentAutoCombinationModel(shipmentAutoCombinationModels, shipmentDetailId);
                        if(shipmentAutoCombinationModel != null && shipmentAutoCombinationModel.getQty().compareTo(BigDecimal.ZERO) != 0) {
                            BigDecimal modelQty = shipmentAutoCombinationModel.getQty();
                            shipmentCombinationModels.add(newShipmentCombinationModel(inventory, modelQty, shipmentDetailId, shipmentAutoCombinationModels.get(0).getCompanyId(),
                                    shipmentAutoCombinationModels.get(0).getCompanyCode()));
                        } else {
                            BigDecimal shipmentQty = shipmentDetail.getQty().subtract(shipmentDetail.getQtyCompleted());
                            shipmentCombinationModels.add(newShipmentCombinationModel(inventory, shipmentQty, shipmentDetailId, shipmentAutoCombinationModels.get(0).getCompanyId(),
                                    shipmentAutoCombinationModels.get(0).getCompanyCode()));
                        }
                    }
                    flag = 1;
                    break;
                }
            }
            //没有一个盘够出，那么组两个及以上的盘出库
            if(flag == 0) {
                shipmentCombinationModels.addAll(divideCoutainerShipment(inventorys, shipMaterialDetail, shipmentAutoCombinationModels));
            }
        }
        //清除缓存的影响
        for(Integer key:qtyCompleteList.keySet())
        {
            BigDecimal qtyComplete = qtyCompleteList.get(key);
            ShipmentDetail shipmentDetail = shipmentDetailService.selectEntityById(key);
            shipmentDetail.setQtyCompleted(qtyComplete);
        }
        AjaxResult result =  Batchcombination(shipmentCombinationModels);
        return result;
    }

    private ShipmentAutoCombinationModel getShipmentAutoCombinationModel(List<ShipmentAutoCombinationModel> shipmentAutoCombinationModels, int shipmentDetailId) {
        for(ShipmentAutoCombinationModel shipmentAutoCombinationMode : shipmentAutoCombinationModels) {
            if(shipmentAutoCombinationMode.getShipmentDetailId() == shipmentDetailId) {
                return shipmentAutoCombinationMode;
            }
        }
        return null;
    }

    /**
     * 分多盘出库
     * @param inventorys
     * @param shipMaterialDetail
     * @return
     */
    private List<ShipmentCombinationModel> divideCoutainerShipment(List<Inventory> inventorys, ShipMaterialDetail shipMaterialDetail, List<ShipmentAutoCombinationModel> shipmentAutoCombinationModels) {
        String companyId = shipmentAutoCombinationModels.get(0).getCompanyId();
        String companyCode = shipmentAutoCombinationModels.get(0).getCompanyCode();
        List<ShipmentCombinationModel> shipmentCombinationModels = new ArrayList<>();
        List<Integer> shipmentDetailIds = shipMaterialDetail.getShipDetailId();
        for(Inventory inventory : inventorys) {
            BigDecimal inventoryQty = inventory.getQty().subtract(inventory.getTaskQty());
            BigDecimal shipmentQty = new BigDecimal(0);
            if(shipmentDetailIds != null) {
                if(shipmentDetailIds.size() == 0) {
                    break;
                }
                BigDecimal oneInventoryQty = inventory.getQty().subtract(inventory.getTaskQty());
                int shipmentDetailIdsSize = shipmentDetailIds.size();
                for (int i=0; i < shipmentDetailIdsSize; i++) {
                    int shipmentDetailId = shipmentDetailIds.get(0);
                    ShipmentDetail shipmentDetail1 = shipmentDetailService.selectEntityById(shipmentDetailId);
                    ShipmentAutoCombinationModel shipmentAutoCombinationModel = getShipmentAutoCombinationModel(shipmentAutoCombinationModels, shipmentDetailId);
                    if(shipmentAutoCombinationModel != null && shipmentAutoCombinationModel.getQty().compareTo(BigDecimal.ZERO) != 0) {
                        shipmentQty = shipmentQty.add(shipmentAutoCombinationModel.getQty().subtract(shipmentDetail1.getQtyCompleted()));
                    } else {
                        shipmentQty = shipmentQty.add(shipmentDetail1.getQty().subtract(shipmentDetail1.getQtyCompleted()));
                    }
                    if (inventoryQty.compareTo(shipmentQty) <= 0) {
                        shipmentCombinationModels.add(newShipmentCombinationModel(inventory, oneInventoryQty, shipmentDetailId, companyId, companyCode));
                        BigDecimal qtyCompleted = shipmentDetail1.getQtyCompleted();
                        shipmentDetail1.setQtyCompleted(qtyCompleted.add(oneInventoryQty));
                        break;
                    } else {
                        shipmentCombinationModels.add(newShipmentCombinationModel(inventory, shipmentQty, shipmentDetailId, companyId, companyCode));
                        oneInventoryQty = oneInventoryQty.subtract(shipmentQty);
                        shipmentDetail1.setQtyCompleted(oneInventoryQty);
                        shipmentDetailIds.remove((Integer) shipmentDetailId);
                    }
                }
            }
        }
        return shipmentCombinationModels;
    }

    @Override
    public AjaxResult checkAutoCombination(List<ShipmentAutoCombinationModel> shipmentAutoCombinationModels) {
        List<ShipmentDetail> shipmentDetails = getShipDetails(shipmentAutoCombinationModels);
        if(shipmentDetails == null) {
            return AjaxResult.error("出库明细未找到");
        }
        for(ShipmentDetail shipmentDetail : shipmentDetails) {
            if(shipmentDetail.getQty().subtract(shipmentDetail.getQtyCompleted()).compareTo(BigDecimal.ZERO) <= 0) {
                return AjaxResult.error("出库明细已经配盘");
            }
        }
        for(ShipmentAutoCombinationModel shipmentAutoCombinationModel : shipmentAutoCombinationModels) {
            int shipmentDetailId = shipmentAutoCombinationModel.getShipmentDetailId();
            ShipmentDetail shipmentDetail = shipmentDetailService.selectEntityById(shipmentDetailId);
            if(shipmentAutoCombinationModel.getQty().compareTo(shipmentDetail.getQty().subtract(shipmentDetail.getQtyCompleted())) > 0) {
                return AjaxResult.error("指定出库数量大于可出数量");
            }
        }
        List<ShipMaterialDetail> shipMaterialDetails = getShipmentMaterial(shipmentDetails, shipmentAutoCombinationModels); //合并相同物品的明细
        AjaxResult AjaxResult = checkShipDetails(shipMaterialDetails);
        if(AjaxResult.hasErr()){
            return AjaxResult;
        }
        return AjaxResult.success("");
    }


    private ShipmentCombinationModel newShipmentCombinationModel(Inventory inventory, BigDecimal qty, int shipmentDetailId, String companyId, String companyCode) {
        ShipmentCombinationModel shipmentCombinationModel = new ShipmentCombinationModel();
        shipmentCombinationModel.setInventoryId(inventory.getId());
        shipmentCombinationModel.setQty(qty);
        shipmentCombinationModel.setShipmentDetailId(shipmentDetailId);
        shipmentCombinationModel.setCompanyId(companyId);
        BigDecimal inventoryQty = inventory.getQty().subtract(inventory.getTaskQty());
        if(inventoryQty.subtract(qty).compareTo(new BigDecimal(0)) <= 0) {
            shipmentCombinationModel.setTaskType(300);
        } else {
            shipmentCombinationModel.setTaskType(400);
        }
        shipmentCombinationModel.setCompanyCode(companyCode);
        return shipmentCombinationModel;
    }

    private List<Inventory> getInventorys(String materialCode, String warehouseCode, BigDecimal totalShipmentQty, ShipmentAutoCombinationModel shipmentAutoCombinationModel) {
        String companyId =  shipmentAutoCombinationModel.getCompanyId();
        String companyCode = shipmentAutoCombinationModel.getCompanyCode();
        String locationCode = shipmentAutoCombinationModel.getLocation();
        Inventory condition = new Inventory();
        condition.setWarehouseId(ShiroUtils.getWarehouseId());
        condition.setMaterialCode(materialCode);
        if(locationCode != null) {
            condition.setLocationCode(locationCode);
        }
        String reason = "库存未找到";
        List<Inventory> inventoryList = inventoryService.selectListEntityByEqual(condition);
        BigDecimal shipmentQty = new BigDecimal(0);
        if(inventoryList == null){
            return inventoryList;
        }
        List<Inventory> inventorys = new ArrayList<>();
        for(Inventory inventory : inventoryList) {
            //排除不是本仓库的库存
            int flag = 0;
            if(!inventory.getWarehouseCode().equals(warehouseCode)) {
                continue;
            }
            if(locationCode == null && !inventory.getLocationCode().substring(0,1).equals("L")) {
                continue;
            }
            //排除库存已经出完的库位
            if(inventory.getQty().compareTo(inventory.getTaskQty()) == 0) {
                continue;
            }
            //排除正在执行任务的库位
            Task taskCondition = new Task();
            taskCondition.setSourceLocation(inventory.getLocationCode());
            List<Task> tasks = taskService.selectListEntityByEqual(taskCondition);
            for(Task task : tasks) {
                if(task.getFirstStatus() < 40 && task.getFirstStatus() > 0) {
                    flag = 1;
                    reason = "库存货位正在执行任务";
                    break;
                }
            }

            //排除出库表单头里正在执行任务的库位
            Location locationCondition = new Location();
            locationCondition.setCode(inventory.getLocationCode());
            locationCondition.setWarehouseId(ShiroUtils.getWarehouseId());
            Location location = locationService.selectFirstEntity(locationCondition);
            if(location == null) {
                continue;
            }
            if(!location.getStatus().equals("empty")){
                reason = "库存货位"  + location.getCode() + "被锁定";
                continue;
            }
            ShipmentContainerHeader shipmentCondition = new ShipmentContainerHeader();
            shipmentCondition.setShipmentContainerCode(location.getContainerCode());
            shipmentCondition.setCompanyId(Integer.parseInt(companyId));
            shipmentCondition.setCompanyCode(companyCode);
            List<ShipmentContainerHeader> shipmentContainerHeaders = this.selectListEntityByEqual(shipmentCondition);
            for(ShipmentContainerHeader shipmentContainerHeader : shipmentContainerHeaders) {
                if(shipmentContainerHeader.getStatus() > 0 && shipmentContainerHeader.getStatus() < 20) {
                    flag = 1;
                    reason = "出库表单头里库位正在执行任务";
                    break;
                }
            }
            if(flag == 0) {
                inventorys.add(inventory);
                shipmentQty = shipmentQty.add(inventory.getQty().subtract(inventory.getTaskQty()));
            }
        }
        if(!(inventorys != null && inventorys.size() > 0)){
            throw new ServiceException(reason);
        }
        if(shipmentQty.subtract(totalShipmentQty).compareTo(BigDecimal.ZERO) < 0) {
            throw new ServiceException("库存可出数量小于出库数量");
        }
        //按照先进先出的原则排序  id小的是先进
        Collections.sort(inventorys, new Comparator<Inventory>(){
            public int compare(Inventory inventory1, Inventory inventory2) {
                if(inventory1.getId() > inventory2.getId()){
                    return 1;
                }
                return -1;
            }
        });
        return inventorys;
    }

    private List<ShipmentDetail> getShipDetails(List<ShipmentAutoCombinationModel> shipmentAutoCombinationModels) {
        List<ShipmentDetail> shipmentDetails = new ArrayList<>();
        for(ShipmentAutoCombinationModel shipmentAutoCombinationModel: shipmentAutoCombinationModels) {
            int shipmentDetailId = shipmentAutoCombinationModel.getShipmentDetailId();
            ShipmentDetail shipmentDetail = shipmentDetailService.selectEntityById(shipmentDetailId);
            if(shipmentDetail==null){
                return null;
            }
            shipmentDetails.add(shipmentDetail);
        }
        return shipmentDetails;
    }

    /**
     * 校验出库单据
     * @param shipMaterialDetails
     * @return
     */
    private AjaxResult checkShipDetails(List<ShipMaterialDetail> shipMaterialDetails) {
        for(ShipMaterialDetail shipMaterialDetail: shipMaterialDetails) {
            //查询库存
            Inventory condition = new Inventory();
            condition.setMaterialCode(shipMaterialDetail.getMaterialCode());
            List<Inventory> inventorys = inventoryService.selectListEntityByEqual(condition);
            if(inventorys == null){
                return AjaxResult.error("库存未找到");
            }
            BigDecimal inventoryQty = new BigDecimal(0);
            BigDecimal shipmentQty = shipMaterialDetail.getQty().subtract(shipMaterialDetail.getQtyCompleted());
            for(Inventory inventory : inventorys) {
                if(!inventory.getWarehouseCode().equals(shipMaterialDetail.getWarehouseCode())) {
                    continue;
                }
                //排除库存已经出完的库位
                if(inventory.getQty().compareTo(inventory.getTaskQty()) == 0) {
                    continue;
                }
                inventoryQty = inventoryQty.add(inventory.getQty().subtract(inventory.getTaskQty()));
            }
            if(inventoryQty.compareTo(shipmentQty) < 0){
                return AjaxResult.error("录入数量超出可出数量");
            }
        }
        return AjaxResult.success("success");
    }

   private List<ShipMaterialDetail> getShipmentMaterial(List<ShipmentDetail> shipmentDetails, List<ShipmentAutoCombinationModel> shipmentAutoCombinationModels) {
       List<ShipMaterialDetail> shipMaterialDetails = new ArrayList<>();
       for(int i=0; i < shipmentDetails.size(); i++) {
           ShipmentDetail shipmentDetail = shipmentDetails.get(i);
           ShipmentAutoCombinationModel shipmentAutoCombinationModel = shipmentAutoCombinationModels.get(i);
           boolean flag = false;
           List<Integer> shipmentDetailIds = new ArrayList<>();
           for (ShipMaterialDetail shipMaterialDetail : shipMaterialDetails) {
               if (shipMaterialDetail.getMaterialCode().equals(shipmentDetail.getMaterialCode())
                       && shipMaterialDetail.getWarehouseCode().equals(shipmentDetail.getWarehouseCode())) {
                   shipMaterialDetails.remove(shipMaterialDetail);
                   BigDecimal qty = shipmentDetail.getQty();
                   if(shipmentAutoCombinationModel.getQty().compareTo(BigDecimal.ZERO) != 0) {
                       qty = qty.add(shipmentAutoCombinationModel.getQty());
                   } else {
                       qty = qty.add(shipMaterialDetail.getQty());
                   }
                   shipMaterialDetail.setQty(qty);
                   BigDecimal qtyCompleted = shipmentDetail.getQtyCompleted();
                   qtyCompleted = qtyCompleted.add(shipMaterialDetail.getQtyCompleted());
                   shipMaterialDetail.setQtyCompleted(qtyCompleted);
                   shipmentDetailIds = shipMaterialDetail.getShipDetailId();
                   shipmentDetailIds.add(shipmentDetail.getId());
                   shipMaterialDetail.setShipDetailId(shipmentDetailIds);
                   shipMaterialDetails.add(shipMaterialDetail);
                   flag = true;
               }
           }
           if (!flag) {
               if(shipmentAutoCombinationModel.getQty().compareTo(BigDecimal.ZERO) != 0) {
                   shipmentDetail.setQty(shipmentAutoCombinationModel.getQty().add(shipmentDetail.getQtyCompleted()));
               }
               shipmentDetailIds.add(shipmentDetail.getId());
               shipMaterialDetails.add(newShipMaterialDetail(shipmentDetail, shipmentDetailIds));
           }
       }
       return shipMaterialDetails;
   }

   private ShipMaterialDetail newShipMaterialDetail(ShipmentDetail shipmentDetail, List shipmentDetailIds) {
       ShipMaterialDetail shipMaterialDetail = new ShipMaterialDetail();
       shipMaterialDetail.setMaterialCode(shipmentDetail.getMaterialCode());
       shipMaterialDetail.setQty(shipmentDetail.getQty());
       shipMaterialDetail.setQtyCompleted(shipmentDetail.getQtyCompleted());
       shipMaterialDetail.setWarehouseCode(shipmentDetail.getWarehouseCode());
       shipMaterialDetail.setShipDetailId(shipmentDetailIds);
       return shipMaterialDetail;
   }


    /**
     * 校验
     * @param shipmentCombinationModel
     * @return
     */
    @Override
    public AjaxResult checkCombination(ShipmentCombinationModel shipmentCombinationModel) {
        if(shipmentCombinationModel.getQty().compareTo(new BigDecimal("0")) <= 0){
            return AjaxResult.error("出库数量必须大于0");
        }
        ShipmentDetail shipmentDetail = shipmentDetailService.selectEntityById(shipmentCombinationModel.getShipmentDetailId());
        if(shipmentDetail==null){
            return AjaxResult.error("出库明细未找到");
        }
        Inventory inventory = inventoryService.selectEntityById((shipmentCombinationModel.getInventoryId()));
        if(inventory==null){
            return AjaxResult.error("库存未找到");
        }
        //校验数量是否超出
        if((shipmentDetail.getQty().subtract(shipmentDetail.getQtyCompleted())).compareTo(shipmentCombinationModel.getQty())<0){
            return AjaxResult.error("录入数量超出明细待出数量");
        }
        //校验库存可用数量
        if(inventory.getQty().subtract(inventory.getTaskQty()).compareTo(shipmentCombinationModel.getQty())<0){
            return AjaxResult.error("录入数量超出可出数量");
        }
        if(!shipmentDetail.getMaterialCode().equals(inventory.getMaterialCode())){
            return AjaxResult.error("配盘物料不一致");
        }
        //库位
        Location locationCondition = new Location();
        locationCondition.setWarehouseCode(inventory.getWarehouseCode());
        locationCondition.setCode(inventory.getLocationCode());
        Location location = locationService.selectFirstEntity(locationCondition);
        if (location == null)
            return AjaxResult.error("库位 "+ inventory.getLocationCode() +" 不存在");
        if (location.getStatus().equals("lock"))    {
            //如果库位状态是锁定的话，就查找出库组盘表，如果存在未下发
            ShipmentContainerHeader ShipmentCondition = new ShipmentContainerHeader();
            ShipmentCondition.setWarehouseId(ShiroUtils.getWarehouseId());
            ShipmentCondition.setShipmentContainerCode(location.getContainerCode());
            ShipmentCondition.setStatus((short)0);
            ShipmentContainerHeader shipmentContainerHeader = selectFirstEntity(ShipmentCondition);
            if (shipmentContainerHeader == null)    {
                return AjaxResult.error("库位已经锁定不能使用");
            }
        }
        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){
            ShipmentContainerDetail condition = new ShipmentContainerDetail();
            condition.setHeaderId(id);
            List<ShipmentContainerDetail> shipmentContainerDetails = shipmentContainerDetailService.selectListEntityByEqual(condition);
            result = cancelCombinationDetailInner(shipmentContainerDetails);
            if(result.hasErr()){
                return result;
            }
        }

        return AjaxResult.success("");
    }
/**
 * 原来的流程：出库组盘的时候不锁定库位，生成任务锁定库位，   取消任务的时候取消任务锁定，取消组盘的时候不需要库位锁定
 * 新流程：出库组盘锁定库位，生成任务的时候不需要锁定库位，   取消任务的时候不需要锁定库位，取消组盘的时候取消库位锁定
 *
 * */




    /**
     * 检查是否可以进行取消配盘
     * @param shipmentContainerIds
     * @return
     */
    @Override
    public AjaxResult checkForCancelCombination(List<Integer> shipmentContainerIds) {
        for(int id : shipmentContainerIds){
            ShipmentContainerHeader shipmentContainerHeader = this.selectEntityById(id);
            if(shipmentContainerHeader.getStatus()>9){
                return AjaxResult.error("存在已生成任务的记录，请先取消任务再取消组盘");
            }
        }
        return AjaxResult.success("");
    }

    /**
     * 根据出库货箱头id获取出库货箱明细
     * @param shipmentContainerDetailSearchModel
     * @return
     */
    @Override
    public List<ShipmentContainerDetail> listDetails(ShipmentContainerDetailSearchModel shipmentContainerDetailSearchModel)  {
        ShipmentContainerDetail condition = new ShipmentContainerDetail();
        condition.setHeaderId(shipmentContainerDetailSearchModel.getShipmentContainerHeaderId());
        List<ShipmentContainerDetail> list = shipmentContainerDetailService.selectListEntityByEqual(condition);
        return list;
    }

    /**
     * 取消组盘的一组明细
     * @param detailIds
     * @return
     */
    @Override
    public AjaxResult cancelCombinationDetail(List<Integer> detailIds)  {
        List<ShipmentContainerDetail> shipmentContainerDetails = new ArrayList<>();
        for(int detailId:detailIds){
            ShipmentContainerDetail shipmentContainerDetail = shipmentContainerDetailService.selectEntityById(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.selectEntityById(shipmentContainerDetail.getHeaderId());
            if(shipmentContainerHeader.getStatus()>9){
                return AjaxResult.error("容器"+shipmentContainerHeader.getShipmentContainerCode()+"非新建状态，不允许取消明细");
            }
            //恢复占用库存
            Inventory inventory = inventoryService.selectEntityById(shipmentContainerDetail.getInventoryId());
            inventory.setTaskQty(inventory.getTaskQty().subtract(shipmentContainerDetail.getQty()));
            inventoryService.updateByModel(inventory);
            //恢复单据发货数量
            ShipmentDetail shipmentDetail = shipmentDetailService.selectEntityById(shipmentContainerDetail.getShipmentDetailId());
            shipmentDetail.setQtyCompleted(shipmentDetail.getQtyCompleted().subtract(shipmentContainerDetail.getQty()));
            if(shipmentDetail.getQtyCompleted().compareTo(BigDecimal.ZERO) != 0 ){
                shipmentDetail.setStatus((short) 200);//明细状态恢复,如果删除后还有以出数量就是波次
            }else{
                shipmentDetail.setStatus((short) 0 );//明细状态
            }
            shipmentDetailService.updateByModel(shipmentDetail);
            //删除这个配盘明细
            shipmentContainerDetailService.deleteById(shipmentContainerDetail.getId());
            //查询头表下还有没有明细，如果没有，则删了这个头表
            ShipmentContainerDetail condition = new ShipmentContainerDetail();
            condition.setHeaderId(shipmentContainerDetail.getHeaderId());
            List<Map<String, Object>> list= shipmentContainerDetailService.selectListMapByEqual("id", condition);
            if(list==null||list.size() == 0){
                this.deleteById(shipmentContainerHeader.getId());
                locationService.updateStatus(shipmentContainerHeader.getLocationCode(),"empty");
            }
            //更新单据状态
            shipmentHeaderService.updateShipmentStatus(shipmentDetail.getShipmentId());
        }
        return AjaxResult.success("");
    }

    /**
     * 强制重置货箱为指定的状态
     * @param containerCode
     * @param status
     */
    @Override
    public void resetStatusShipmentContainer(String containerCode, Short status)  {
        //找到这个货箱
        ShipmentContainerHeader condition = new ShipmentContainerHeader();
        condition.setShipmentContainerCode(containerCode);
        ShipmentContainerHeader shipmentContainerHeader = shipmentContainerHeaderMapper.selectUnPickted(condition);
        if (shipmentContainerHeader != null) {
                shipmentContainerHeader.setStatus(status);
                this.updateByModel(shipmentContainerHeader);
        }
    }

    @Override
    public void resetStatusShipmentContainer(int alloctionId, Short status) {
//        ShipmentContainerHeader shipmentContainerHeader = this.selectEntityById(alloctionId);
        ShipmentContainerHeader shipmentContainerHeader = new ShipmentContainerHeader();
        shipmentContainerHeader.setId(alloctionId);
        if(shipmentContainerHeader!=null){
            shipmentContainerHeader.setStatus(status);
            if(status==0){
                //如果回到新建状态，则删掉任务类型
                shipmentContainerHeader.setTaskTypeReal((short)0);
                shipmentContainerHeader.setTaskType((short)0);
            }
            updateByModel(shipmentContainerHeader);
        }
    }


    @Override
    public List<ShipmentHeader> listShipmentHeaders(ShipmentHeader shipmentHeader) {
        return shipmentContainerHeaderMapper.listShipmentHeaders(shipmentHeader);
    }

    @Override
    public ShipmentContainerHeader getShipmentContainerHeaderByContainerCode(String containerCode) {
        return shipmentContainerHeaderMapper.getShipmentContainerHeaderByContainerCode(containerCode);
    }

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

    @Override
    public AjaxResult AddAgvcombination(Integer shipmentDetailId,String shipmentCode,String materialCode,String qty,String containerCode){
        ShipmentCombinationModel shipmentCombination =new ShipmentCombinationModel();
        //查找当前组盘的子单
        ShipmentDetail shipmentDetail=new ShipmentDetail();
        shipmentDetail.setShipmentCode(shipmentCode);
        shipmentDetail.setWarehouseCode(ShiroUtils.getWarehouseCode());
        shipmentDetail.setId(shipmentDetailId);
        shipmentDetail=shipmentDetailService.selectFirstEntity(shipmentDetail);

        //查找当前组盘的库存
        Inventory inventory=new Inventory();
        inventory.setWarehouseCode(ShiroUtils.getWarehouseCode());
        inventory.setContainerCode(containerCode);
        inventory.setMaterialCode(materialCode);
        inventory=inventoryService.selectFirstEntity(inventory);

        shipmentCombination.setShipmentDetailId(shipmentDetail.getId());
        shipmentCombination.setInventoryId(inventory.getId());
        shipmentCombination.setTaskType(400);
        shipmentCombination.setQty(new BigDecimal(qty));
        shipmentCombination.setType((short)1);
        shipmentCombination.setAuto(false);
        AjaxResult AjaxResult = checkCombination(shipmentCombination);
        if(AjaxResult.hasErr()){
            return AjaxResult;
        }
        ShipmentContainerHeader shipmentContainerHeader = combination(shipmentCombination);
        return  AjaxResult.success(shipmentContainerHeader.getId());

    }

}