wms / hhwms · Files

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

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.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.general.customer.domain.ShipMaterialDetail;
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.ShipmentContainerHeaderMapperAuto;
import com.huaheng.pc.shipment.shipmentContainerHeader.mapper.ShipmentContainerHeaderMapper;
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.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.*;
import java.util.ArrayList;


/**
 * 出库组盘明细 服务层实现
 * 
 * @author huaheng
 * @date 2018-08-19
 */
@Service
public class ShipmentContainerHeaderServiceImpl implements IShipmentContainerHeaderService {
    @Autowired
    IInventoryService inventoryService;
    @Autowired
    ILocationService locationService;
    @Autowired
    IShipmentHeaderService shipmentHeaderService;
    @Autowired
    IMaterialService materialService;
    @Autowired
    IShipmentDetailService shipmentDetailService;
    @Autowired
    IShipmentContainerDetailService shipmentContainerDetailService;
    @Autowired
    ITaskService taskService;
    @Autowired
    IShipmentContainerHeaderService shipmentContainerHeaderService;
    @Resource
    private ShipmentContainerHeaderMapper shipmentContainerHeaderMapper;
    @Resource
    private ShipmentContainerHeaderMapperAuto aotuMapper;

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

    /**
     * 出库组盘
     * @param shipmentCombinationModels
     * @return
     */
    @Transactional
    @Override
    public AjaxResult  combination(List<ShipmentCombinationModel> shipmentCombinationModels)  {
        //校验不通过就中止
        System.out.println("shipmentCombinationModels:" + shipmentCombinationModels.toString());
        for (ShipmentCombinationModel shipmentCombinationModel:shipmentCombinationModels){
            AjaxResult AjaxResult = check(shipmentCombinationModel);
            if(AjaxResult.hasErr()){
                return AjaxResult;
            }
        }
        List<Integer> containerHeaderIds = new ArrayList<>();
        for (ShipmentCombinationModel shipmentCombinationModel:shipmentCombinationModels) {
            //查询库存
            Inventory inventory = inventoryService.selectEntityById(shipmentCombinationModel.getInventoryId());
            //库位
            Location locationCondition = new Location();
            locationCondition.setWarehouseCode(inventory.getWarehouseCode());
            locationCondition.setCode(inventory.getLocationCode());
            Location location = locationService.selectFirstEntity(locationCondition);

            if(inventory.getQty().subtract(inventory.getTaskQty()).compareTo(shipmentCombinationModel.getQty()) < 0
                    || shipmentCombinationModel.getQty().compareTo(BigDecimal.ZERO) == 0) {
                return AjaxResult.error("容器"+location.getContainerCode()+"已经完成出库，没有相应货物");
            }
            //查询所有对应位置的出库货箱表头，一次只允许使用一个未被使用的货箱
            //如果状态为0就合并出库明细，状态大于0小于40不能操作库位，所有表单状态40可以重新生成一个出库货箱表头
            ShipmentContainerHeader ShipmentCondition = new ShipmentContainerHeader();
            ShipmentCondition.setShipmentContainerCode(location.getContainerCode());
            ShipmentContainerHeader shipmentContainerHeader = null;
            List<ShipmentContainerHeader> shipmentContainerHeaders = shipmentContainerHeaderMapper.selectUnCompletedShipmentContainer(ShipmentCondition);
            if(shipmentContainerHeaders != null && shipmentContainerHeaders.size() > 0) {
                for(int i=0; i< shipmentContainerHeaders.size(); i++) {
                    ShipmentContainerHeader shipmentContainerHeader1  = shipmentContainerHeaders.get(i);
                    if(shipmentContainerHeader1.getStatus() == 0) {
                        shipmentContainerHeader = shipmentContainerHeader1;
                        //以最后一次希望创建的出库任务类型为准
                        shipmentContainerHeader.setTaskType(shipmentCombinationModel.getTaskType());
                        shipmentContainerHeaderService.updateByModel(shipmentContainerHeader);
                        break;
                    } else if(shipmentContainerHeader1.getStatus() > 0 && shipmentContainerHeader1.getStatus() < 40) {
                        return AjaxResult.error("容器"+location.getContainerCode()+"已经生成任务，不能再添加明细;操作中止；");
                    } else if(shipmentContainerHeader1.getStatus() == 40) {
                        if(i == shipmentContainerHeaders.size() - 1) { //轮询到最后一个表单 状态也是40才允许新建表单头
                            shipmentContainerHeader = newShipmentContainerHeader(location, shipmentCombinationModel);
                        }
                    }
                }
            } else {
                shipmentContainerHeader = newShipmentContainerHeader(location, shipmentCombinationModel);
            }
            //明细单
            ShipmentDetail shipmentDetail = shipmentDetailService.selectEntityById(shipmentCombinationModel.getShipmentDetailId());

            //查询对应的组盘明细
            ShipmentContainerDetail condition = new ShipmentContainerDetail();
            condition.setHeaderId(shipmentContainerHeader.getId());
            List<ShipmentContainerDetail> shipmentContainerDetails = shipmentContainerDetailService.selectListEntityByEqual(condition);
            int flag = 0;
            if(shipmentContainerDetails!=null&&shipmentContainerDetails.size()>0){
                for(ShipmentContainerDetail item : shipmentContainerDetails){
                    if(item.getInventoryId()==shipmentCombinationModel.getInventoryId()&&item.getShipmentDetailId()==shipmentCombinationModel.getShipmentDetailId()){
                        //如果库存Id和出库明细Id一致，则合并
                        item.setQty(item.getQty().add(shipmentCombinationModel.getQty()));
                        shipmentContainerDetailService.updateByModel(item);
                        flag=1;
                        break;
                    }
                }
            }
            if(flag==0){
                //构建明细
                ShipmentContainerDetail shipmentContainerDetail = new ShipmentContainerDetail();
                Material condition2 = new Material();
                condition2.setCode(shipmentDetail.getMaterialCode());
                Material material = materialService.selectFirstEntity(condition2);
                shipmentContainerDetail.setMaterialCode(shipmentDetail.getMaterialCode());
                shipmentContainerDetail.setMaterialName(material.getName());
                shipmentContainerDetail.setHeaderId(shipmentContainerHeader.getId());
                shipmentContainerDetail.setCreated(null);
                shipmentContainerDetail.setCreatedBy(ShiroUtils.getLoginName());
                shipmentContainerDetail.setInventoryId(shipmentCombinationModel.getInventoryId());
                shipmentContainerDetail.setQty(shipmentCombinationModel.getQty());
                shipmentContainerDetail.setShipmentHeaderId(shipmentDetail.getShipmentId());
                shipmentContainerDetail.setShipmentDetailId(shipmentCombinationModel.getShipmentDetailId());
                shipmentContainerDetail.setHeaderId(shipmentContainerHeader.getId());
                shipmentContainerDetailService.insert(shipmentContainerDetail);
            }
            //更新库存分配数、明细单据已发数
            inventory.setTaskQty(inventory.getTaskQty().add(shipmentCombinationModel.getQty()));
            inventoryService.updateByModel(inventory);
            shipmentDetail.setQtyCompleted(shipmentDetail.getQtyCompleted().add(shipmentCombinationModel.getQty()));
            shipmentDetailService.updateByModel(shipmentDetail);
            //更新单据状态
            shipmentHeaderService.updateShipmentStatus(shipmentDetail.getShipmentId());
            containerHeaderIds.add(shipmentContainerHeader.getId());
        }
        return AjaxResult.success(containerHeaderIds);
    }

    private ShipmentContainerHeader newShipmentContainerHeader(Location location, ShipmentCombinationModel shipmentCombinationModel) {
        ShipmentContainerHeader shipmentContainerHeader = new ShipmentContainerHeader();
        shipmentContainerHeader.setStatus((short)0);
        shipmentContainerHeader.setShipmentContainerCode(location.getContainerCode());
        shipmentContainerHeader.setCreated(null);
        shipmentContainerHeader.setCreatedBy(ShiroUtils.getLoginName());
        shipmentContainerHeader.setWarehouseCode(ShiroUtils.getWarehouseCode());
        shipmentContainerHeader.setWarehouseId(ShiroUtils.getWarehouseId());
        BigDecimal qty = shipmentCombinationModel.getQty();
        shipmentContainerHeader.setTaskType(shipmentCombinationModel.getTaskType());
        this.insert(shipmentContainerHeader);
        return shipmentContainerHeader;
    }

    @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;
            List<Inventory> inventorys = getInventorys(shipMaterialDetail.getMaterialCode(), shipMaterialDetail.getWarehouseCode());
            if (inventorys == null) {
                return AjaxResult.error("库存未找到");
            }
            //前面校验的时候已经判断出库存是够的，然后对库存按照先进先出进行了排序，现在优先整盘先出
            BigDecimal totalShipmentQty = shipMaterialDetail.getQty().subtract(shipMaterialDetail.getQtyCompleted());
            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));
                        } else {
                            BigDecimal shipmentQty = shipmentDetail.getQty().subtract(shipmentDetail.getQtyCompleted());
                            shipmentCombinationModels.add(newShipmentCombinationModel(inventory, shipmentQty, shipmentDetailId));
                        }
                    }
                    flag = 1;
                    break;
                }
            }
            //没有一个盘够出，那么组两个及以上的盘出库
            if(flag == 0) {
                shipmentCombinationModels.addAll(divideCoutainerShipment(inventorys, totalShipmentQty, shipMaterialDetail, shipmentAutoCombinationModels));
            }
        }
        //清除缓存的影响
        for(Integer key:qtyCompleteList.keySet())
        {
            BigDecimal qtyComplete = qtyCompleteList.get(key);
            ShipmentDetail shipmentDetail = shipmentDetailService.selectEntityById(key);
            shipmentDetail.setQtyCompleted(qtyComplete);
        }
        AjaxResult result =  combination(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 totalShipmentQty
     * @param shipMaterialDetail
     * @return
     */
    private List<ShipmentCombinationModel> divideCoutainerShipment(List<Inventory> inventorys, BigDecimal totalShipmentQty,
                                                                   ShipMaterialDetail shipMaterialDetail, List<ShipmentAutoCombinationModel> shipmentAutoCombinationModels) {
        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));
                        BigDecimal qtyCompleted = shipmentDetail1.getQtyCompleted();
                        shipmentDetail1.setQtyCompleted(qtyCompleted.add(oneInventoryQty));
                        break;
                    } else {
                        shipmentCombinationModels.add(newShipmentCombinationModel(inventory, shipmentQty, shipmentDetailId));
                        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) {
        ShipmentCombinationModel shipmentCombinationModel = new ShipmentCombinationModel();
        shipmentCombinationModel.setInventoryId(inventory.getId());
        shipmentCombinationModel.setQty(qty);
        shipmentCombinationModel.setShipmentDetailId(shipmentDetailId);
        return shipmentCombinationModel;
    }

    private List<Inventory> getInventorys(String materialCode, String warehouseCode) {
        Inventory condition = new Inventory();
        condition.setMaterialCode(materialCode);
        List<Inventory> inventoryList = inventoryService.selectListEntityByEqual(condition);
        if(inventoryList == null){
            return inventoryList;
        }
        List<Inventory> inventorys = new ArrayList<>();
        for(Inventory inventory : inventoryList) {
            //排除不是本仓库的库存
            int flag = 0;
            if(!inventory.getWarehouseCode().equals(warehouseCode)) {
                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;
                    break;
                }
            }
            //排除出库表单头里正在执行任务的库位
            Location locationCondition = new Location();
            locationCondition.setCode(inventory.getLocationCode());
            Location location = locationService.selectFirstEntity(locationCondition);
            ShipmentContainerHeader shipmentCondition = new ShipmentContainerHeader();
            shipmentCondition.setShipmentContainerCode(location.getContainerCode());
            List<ShipmentContainerHeader> shipmentContainerHeaders = shipmentContainerHeaderService.selectListEntityByEqual(shipmentCondition);
            for(ShipmentContainerHeader shipmentContainerHeader : shipmentContainerHeaders) {
                if(shipmentContainerHeader.getStatus() > 0 && shipmentContainerHeader.getStatus() < 40) {
                    flag = 1;
                    break;
                }
            }
            if(flag == 0) {
                inventorys.add(inventory);
            }
        }
        if(!(inventorys != null && inventorys.size() > 0)){
            return null;
        }
        //按照先进先出的原则排序  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 check(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("配盘物料不一致");
        }
        Task condition = new Task();
        condition.setSourceLocation(inventory.getLocationCode());
        List<Task> tasks = taskService.selectListEntityByEqual(condition);
        for(Task task : tasks) {
            if(task.getFirstStatus() < 40 && task.getFirstStatus() > 0) {
                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){
            ShipmentContainerHeader shipmentContainerHeader = this.selectEntityById(id);
            ShipmentContainerDetail condition = new ShipmentContainerDetail();
            condition.setHeaderId(shipmentContainerHeader.getId());
            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());
            //单据明细
            ShipmentDetail shipmentDetail = shipmentDetailService.selectEntityById(shipmentContainerDetail.getShipmentDetailId());
            //恢复占用库存
            inventory.setTaskQty(inventory.getTaskQty().subtract(shipmentContainerDetail.getQty()));
            inventoryService.updateByModel(inventory);
            //恢复单据发货数量
            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<ShipmentContainerDetail> shipmentContainerDetailsList= shipmentContainerDetailService.selectListEntityByEqual(condition);
            if(shipmentContainerDetailsList==null||shipmentContainerDetailsList.size() == 0){
                this.deleteById(shipmentContainerHeader.getId());
            }
            //更新单据状态
            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);
        //在<20的状态下查找，本方法只在任务相关中才调用到
        List<ShipmentContainerHeader> shipmentContainerHeaders = shipmentContainerHeaderMapper.selectUnCompletedShipmentContainer(condition);
        if(shipmentContainerHeaders != null && shipmentContainerHeaders.size() > 0){
            shipmentContainerHeaders.get(0).setStatus(status);
            this.updateByModel(shipmentContainerHeaders.get(0));
        }
    }

    @Override
    public void resetStatusShipmentContainer(int alloctionId, Short status) {
        ShipmentContainerHeader shipmentContainerHeader = shipmentContainerHeaderService.selectEntityById(alloctionId);
        if(shipmentContainerHeader!=null){
            shipmentContainerHeader.setStatus(status);
            if(status==0){
                //如果回到新建状态，则删掉实际任务类型
                shipmentContainerHeader.setTaskTypeReal((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);
    }

}