wms / hhwms · Files

package com.huaheng.pc.task.taskHeader.service;

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

import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;

import com.huaheng.api.acs.domain.AgvTaskCS;
import com.huaheng.api.acs.service.AcsCSService;
import com.huaheng.api.acs.service.AgvTaskCSService;

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

import com.huaheng.common.utils.Wrappers;

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

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

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.materialWarnning.service.IMaterialWarningService;

import com.huaheng.pc.config.shipmentPreference.service.ShipmentPreferenceService;

import com.huaheng.pc.config.station.domain.Station;
import com.huaheng.pc.config.station.service.StationService;

import com.huaheng.pc.inventory.inventoryDetail.domain.InventoryDetail;
import com.huaheng.pc.inventory.inventoryDetail.service.InventoryDetailService;
import com.huaheng.pc.inventory.inventoryHeader.domain.InventoryHeader;
import com.huaheng.pc.inventory.inventoryHeader.service.InventoryHeaderService;
import com.huaheng.pc.inventory.inventoryTransaction.domain.InventoryTransaction;
import com.huaheng.pc.inventory.inventoryTransaction.service.InventoryTransactionService;
import com.huaheng.pc.shipment.shipmentContainerDetail.domain.ShipmentContainerDetail;
import com.huaheng.pc.shipment.shipmentContainerDetail.service.ShipmentContainerDetailService;
import com.huaheng.pc.shipment.shipmentContainerHeader.domain.ShipmentContainerHeader;
import com.huaheng.pc.shipment.shipmentContainerHeader.service.ShipmentContainerHeaderService;
import com.huaheng.pc.shipment.shipmentDetail.domain.ShipmentDetail;
import com.huaheng.pc.shipment.shipmentDetail.service.ShipmentDetailService;
import com.huaheng.pc.shipment.shipmentHeader.domain.ShipmentHeader;
import com.huaheng.pc.shipment.shipmentHeader.service.ShipmentHeaderService;

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

import com.huaheng.pc.task.agvTask.domain.AgvTask;

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 org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

import java.util.*;

/**
 * 入库任务创建和完成

 *

 * @author mahua

 * @date 2020/7/14
 */
@Service
public class ShipmentTaskService {

    @Resource
    private ShipmentContainerHeaderService containerHeaderService;
    @Resource
    private ShipmentContainerDetailService shipmentContainerDetailService;
    @Resource
    private LocationService locationService;
    @Resource
    private InventoryDetailService inventoryDetailService;
    @Resource
    private TaskHeaderService taskHeaderService;
    @Resource
    private TaskDetailService taskDetailService;
    @Resource
    private ShipmentDetailService shipmentDetailService;
    @Resource
    private ShipmentHeaderService shipmentHeaderService;
    @Resource
    private InventoryHeaderService inventoryHeaderService;
    @Resource
    private InventoryTransactionService inventoryTransactionService;
    @Resource
    private ContainerService containerService;

    @Resource
    private IMaterialWarningService materialWarningService;

    @Resource
    private ShipmentPreferenceService shipmentPreferenceService;

    @Resource
    private ConfigService configService;

    @Resource
    private StationService stationService;

    @Resource
    private IDictDataService dictDataService;

    @Resource
    private AgvTaskCSService agvTaskCSService;

    /**
     * 创建出库任务

     *

     * @param shipmentTaskCreateModel
     * @return
     */
    @Transactional(rollbackFor = Exception.class)

    public AjaxResult createTaskFromShipmentContainers(ShipmentTaskCreateModel shipmentTaskCreateModel) {

        Integer taskId;

        Integer preTaskNo = 0;

        Integer shipmentContainerHeaderId = shipmentTaskCreateModel.getShipmentContainerHeaderIds();
        //获取表头
        ShipmentContainerHeader shipmentContainerHeader = containerHeaderService.getById(shipmentContainerHeaderId);

        String zoneCode = shipmentContainerHeader.getZoneCode();

        if (shipmentContainerHeader == null) {
            return AjaxResult.error("出库货箱" + shipmentContainerHeaderId + "未找到,操作中止");
        }
        if (shipmentContainerHeader.getStatus() >= QuantityConstant.SHIPMENT_CONTAINER_TASK) {

//            return AjaxResult.error("出库货箱" + shipmentContainerHeader.getContainerCode() + "已经生成任务，请不要重复生成，操作中止");

        }

        //获取所有该组盘头下的组盘子表

        List<ShipmentContainerDetail> shipmentContainerDetails = shipmentContainerDetailService.selectByShippingContainerIdUnComplete(shipmentContainerHeader.getId());

        if (shipmentContainerDetails.isEmpty()) {
            return AjaxResult.error("货箱" + shipmentContainerHeader.getContainerCode() + "没有子任务，操作中止");
        }

        List<ShipmentContainerDetail> shipmentContainerDetails2 = shipmentContainerDetailService.selectByShippingContainerId(shipmentContainerHeader.getId());

        List<TaskHeader> taskHeaders = taskHeaderService.list(new LambdaQueryWrapper<TaskHeader>()
                .eq(TaskHeader::getContainerCode, shipmentContainerHeader.getContainerCode())
                .eq(TaskHeader::getWarehouseCode, ShiroUtils.getWarehouseCode())
                .lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED)
        );

        if (CollectionUtils.isNotEmpty(taskHeaders)) {

            String createdBy = taskHeaders.get(0).getCreatedBy();

            if (!createdBy.equals(ShiroUtils.getUserName())) {
                return AjaxResult.error(shipmentContainerHeader.getContainerCode() + "：有其他人生成了任务");

            }
        }

        //检测库位
        LambdaQueryWrapper<Location> locationLambdaQueryWrapper = Wrappers.lambdaQuery();
        locationLambdaQueryWrapper.eq(Location::getCode, shipmentContainerHeader.getLocationCode())
                .eq(Location::getWarehouseCode, ShiroUtils.getWarehouseCode())
                .eq(Location::getDeleted, false);
        Location location = locationService.getOne(locationLambdaQueryWrapper);
        if (StringUtils.isNull(location)) {
            return AjaxResult.error("库位禁用或不存在！");
        }

        if (location.getRowFlag() == QuantityConstant.ROW_OUT) {

            Location location1 = locationService.getNear(location);

            if (location1 != null) {

                String locationCode = location1.getCode();
                LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
                taskHeaderLambdaQueryWrapper.eq(TaskHeader::getToLocation, locationCode)
                        .lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);
                List<TaskHeader> taskHeaderList = taskHeaderService.list(taskHeaderLambdaQueryWrapper);

                if (taskHeaderList != null && taskHeaderList.size() > 0) {

                    preTaskNo = taskHeaderList.get(0).getPreTaskNo();
                }
            }
        }

        LambdaQueryWrapper<Container> containerLambdaQueryWrapper = Wrappers.lambdaQuery();
        containerLambdaQueryWrapper.eq(Container::getCode, shipmentContainerHeader.getContainerCode())
                .eq(Container::getWarehouseCode, ShiroUtils.getWarehouseCode());
        Container container = containerService.getOne(containerLambdaQueryWrapper);
        if (StringUtils.isNull(container)) {
            return AjaxResult.error("托盘不存在！");
        }

        if (container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_LOCK)) {

//            return AjaxResult.error("托盘已经锁定！");

        }

        container.setStatus(QuantityConstant.STATUS_CONTAINER_LOCK);

        containerService.update(container, containerLambdaQueryWrapper);

        locationService.updateStatus(location.getCode(), QuantityConstant.STATUS_LOCATION_LOCK);

        //创建任务头

        TaskHeader task = new TaskHeader();

        LambdaQueryWrapper<TaskHeader> lambdaQuery = Wrappers.lambdaQuery();

        lambdaQuery.eq(TaskHeader::getWarehouseCode, shipmentContainerHeader.getWarehouseCode());

        lambdaQuery.lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);

        lambdaQuery.eq(TaskHeader::getContainerCode, shipmentContainerHeader.getContainerCode());
        lambdaQuery.eq(TaskHeader::getInternalTaskType, 200);

        lambdaQuery.last("limit 1");
        lambdaQuery.orderByDesc(TaskHeader::getId);

        TaskHeader taskHeader = taskHeaderService.getOne(lambdaQuery);
        int taskIdCheck = 0;
        if (taskHeader != null) {
            task = taskHeader;
            taskIdCheck = task.getId();

        }

        task.setTaskType(QuantityConstant.TASK_TYPE_SORTINGSHIPMENT);
        task.setFromLocation(shipmentContainerHeader.getLocationCode());
        //判断是否整出任务，钱柜和AGV不能整出
        //表示整出优先
        //判断当前子货箱所有数量是否等于该托盘对应的所有库存的数量，
        //这里必须与库存的在库数量对比，后期可能存在一个配盘在执行任务，后一个配盘又在配这个的情况(这个时候不能整出)
        //如果相等，则说明这个货箱包含了所有的数量，则可以整出，否则，创建拣选任务；
        //查询所有库存

        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();

        inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getContainerCode, shipmentContainerHeader.getContainerCode())
                .eq(InventoryDetail::getWarehouseCode, shipmentContainerHeader.getWarehouseCode());

        List<InventoryDetail> inventories = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);
        BigDecimal inventoryTotal = new BigDecimal("0");
        for (InventoryDetail item : inventories) {

            BigDecimal lastQty = item.getQty().subtract(item.getTaskQty());
            inventoryTotal = inventoryTotal.add(lastQty);

        }
        BigDecimal containerTotal = new BigDecimal("0");

        for (ShipmentContainerDetail item : shipmentContainerDetails) {

            containerTotal = containerTotal.add(item.getQty());
        }

        String value = dictDataService.getDictValueByLabel(QuantityConstant.RULE_SHIPMENT_TASK, zoneCode, ShiroUtils.getWarehouseCode());

        int shipmentTaskRule = Integer.parseInt(value);

        // 当onlyPicking为1，只允许分拣出库

        //组盘头下的明细数量=该容器库存下的明细数量

        //剩余库存小于等于0

//        if (inventoryTotal.compareTo(new BigDecimal(0)) <= 0 && !container.getContainerType().equals(QuantityConstant.AGV_CONTAINER_TYPE)) {
        if (inventoryTotal.compareTo(new BigDecimal(0)) <= 0){

            //整盘出库

            if(shipmentTaskRule == QuantityConstant.RULE_TASK_WHOLE_SHIPMENT) {
                task.setTaskType(QuantityConstant.TASK_TYPE_WHOLESHIPMENT);

            }else{
                value = dictDataService.getDictValueByLabel(QuantityConstant.RULE_TASK_LOCATION, zoneCode, ShiroUtils.getWarehouseCode());
                int taskLocationRule = Integer.parseInt(value);
                if (taskLocationRule == QuantityConstant.RULE_TASK_SET_LOCATION) {
                    task.setToLocation(shipmentContainerHeader.getLocationCode());
                }

            }

        } else {

            value = dictDataService.getDictValueByLabel(QuantityConstant.RULE_TASK_LOCATION, zoneCode, ShiroUtils.getWarehouseCode());

            int taskLocationRule = Integer.parseInt(value);

            if (taskLocationRule == QuantityConstant.RULE_TASK_SET_LOCATION) {

                task.setToLocation(shipmentContainerHeader.getLocationCode());
            }

        }

        task.setZoneCode(location.getZoneCode());

        task.setInternalTaskType(QuantityConstant.TASK_INTENERTYPE_SHIPMENT);

        task.setAllocationHeadId(shipmentContainerHeader.getId());
        task.setWarehouseCode(shipmentContainerHeader.getWarehouseCode());
        task.setAssignedUser(ShiroUtils.getLoginName());
        task.setConfirmedBy(ShiroUtils.getLoginName());

        task.setCreatedBy(ShiroUtils.getUserName());

        //东厂默认分配站台 KS0001 LK

        if (location.getWarehouseCode().equals("KS0001") && location.getZoneCode().equals(QuantityConstant.ZONE_CODE_TYPE_LK)) {

            Station station = stationService.getOne(
                    new LambdaQueryWrapper<Station>()
                            .eq(Station::getWarehouseCode, "KS0001")

                            .eq(Station::getArea, 5)

                            .eq(Station::getRoadway, 1)

                            .last("limit 1"));
            if (station != null) {
                task.setPort(station.getCode());
            }

        } else {

            task.setPort(shipmentContainerHeader.getPort());
        }

        task.setStatus(QuantityConstant.TASK_STATUS_BUILD);
        task.setContainerCode(shipmentContainerHeader.getContainerCode());

        task.setGoodsShelfNo(container.getGoodsShelfNo());

        task.setCompanyCode(shipmentContainerHeader.getCompanyCode());

        task.setPreTaskNo(preTaskNo);

        if (!taskHeaderService.saveOrUpdate(task)) {

            throw new ServiceException("生成任务失败");
        }

        taskId = task.getId();

        for (ShipmentContainerDetail shipmentContainerDetail : shipmentContainerDetails) {

            if (taskIdCheck != 0) {

                //任务存在时，判断该组盘明细有无,有则修改明细状态

                LambdaQueryWrapper<TaskDetail> lambdaQuerydetail = Wrappers.lambdaQuery();
                lambdaQuerydetail.eq(TaskDetail::getWarehouseCode, shipmentContainerHeader.getWarehouseCode());
                lambdaQuerydetail.eq(TaskDetail::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);

                lambdaQuerydetail.eq(TaskDetail::getTaskId, taskIdCheck);
                lambdaQuerydetail.eq(TaskDetail::getAllocationId, shipmentContainerDetail.getId());

                lambdaQuerydetail.last("limit 1");

                TaskDetail detail = taskDetailService.getOne(lambdaQuerydetail);
                if (detail != null) {

                    shipmentContainerDetail.setStatus(QuantityConstant.SHIPMENT_CONTAINER_TASK);
                    shipmentContainerDetailService.updateById(shipmentContainerDetail);

                    continue;
                }
            }

            TaskDetail taskDetail = new TaskDetail();
            taskDetail.setTaskId(task.getId());
            taskDetail.setInternalTaskType(task.getInternalTaskType());
            taskDetail.setWarehouseCode(task.getWarehouseCode());

            taskDetail.setUWarehouseCode(shipmentContainerDetail.getUWarehouseCode());

            taskDetail.setCompanyCode(task.getCompanyCode());
            taskDetail.setTaskType(task.getTaskType());
            taskDetail.setToInventoryId(shipmentContainerDetail.getInventoryId());
            taskDetail.setAllocationId(shipmentContainerDetail.getId());
            taskDetail.setBillCode(shipmentContainerDetail.getShipmentCode());
            taskDetail.setBillDetailId(shipmentContainerDetail.getShipmentDetailId());
            taskDetail.setMaterialCode(shipmentContainerDetail.getMaterialCode());
            taskDetail.setMaterialName(shipmentContainerDetail.getMaterialName());
            taskDetail.setMaterialSpec(shipmentContainerDetail.getMaterialSpec());
            taskDetail.setMaterialUnit(shipmentContainerDetail.getMaterialUnit());
            taskDetail.setFromInventoryId(shipmentContainerDetail.getInventoryId());
            taskDetail.setQty(shipmentContainerDetail.getQty());
            taskDetail.setContainerCode(task.getContainerCode());

            taskDetail.setGoodsShelfNo(container.getGoodsShelfNo());

            taskDetail.setFromLocation(task.getFromLocation());

            String shipmentCode = shipmentContainerDetail.getShipmentCode();

            ShipmentHeader shipmentHeader = shipmentHeaderService.getOne(new LambdaQueryWrapper<ShipmentHeader>()
                    .eq(ShipmentHeader::getCode, shipmentCode)

                    .eq(ShipmentHeader::getWarehouseCode, shipmentContainerHeader.getWarehouseCode())

            );
//            ShipmentHeader shipmentHeader=shipmentHeaderService.getOne(shipmentId);

            taskDetail.setReferenceCode(shipmentHeader.getReferCode());

//            taskDetail.setToLocation(task.getToLocation());

            taskDetail.setLot(shipmentContainerDetail.getLot());
            taskDetail.setBatch(shipmentContainerDetail.getBatch());
            taskDetail.setProjectNo(shipmentContainerDetail.getProjectNo());
            taskDetail.setStatus(QuantityConstant.TASK_STATUS_BUILD);
            taskDetail.setWaveId(shipmentContainerDetail.getWaveId());
            taskDetail.setInventorySts(shipmentContainerDetail.getInventorySts());

            taskDetail.setCreatedBy(shipmentContainerDetail.getCreatedBy());

            if (!taskDetailService.save(taskDetail)) {
                throw new ServiceException("新建任务明细失败，sql报错");
            }
            shipmentContainerDetail.setStatus(QuantityConstant.SHIPMENT_CONTAINER_TASK);
            if (!shipmentContainerDetailService.updateById(shipmentContainerDetail)) {
                throw new ServiceException("修改组盘明细状态失败");
            }
        }
        //更新货位状态
        shipmentContainerHeader.setStatus(QuantityConstant.SHIPMENT_CONTAINER_TASK);
        if (!containerHeaderService.updateById(shipmentContainerHeader)) {
            throw new ServiceException("修改组盘头状态失败，sql报错");
        }

        //判断长沙agv库则添加agv任务
//        String warehouseCode=task.getWarehouseCode();
//        String containerType=container.getContainerType();
//        if(warehouseCode.equals(QuantityConstant.WAREHOUSE_CS)&&containerType.contains("V")){
//            AgvTaskCS agvTask=agvTaskCSService.saveAGVTaskByTask(task);
//            //分拣任务回库指令
//            if(task.getTaskType().equals(QuantityConstant.TASK_TYPE_SORTINGSHIPMENT)){
//                AgvTaskCS agvTask1=agvTaskCSService.saveAGVTaskByTaskReturn(task,agvTask);
//            }else{
//                //当整盘出库时，判断有没有生成回库任务,有则删除
//                AgvTaskCS agvTaskPre=agvTaskCSService.getAgvTaskByHeaderId(task,QuantityConstant.AGV_TYPE_TAKE);
//                if(agvTaskPre!=null){
//                    agvTaskCSService.removeById(agvTaskPre.getId());
//                }
//            }
//        }

        return AjaxResult.success(taskId);

    }

    /**
     * 完成出库任务

     *

     * @param task
     */
    @Transactional(rollbackFor = Exception.class)

    public AjaxResult completeShipmentTask(TaskHeader task) {

        //获取任务明细
        List<TaskDetail> taskDetails = taskDetailService.findByTaskId(task.getId());

        if (task.getStatus().intValue() == QuantityConstant.TASK_STATUS_COMPLETED) {

            throw new ServiceException("任务已完成");
        }

        if (StringUtils.isEmpty(task.getFromLocation())) {
            throw new ServiceException("任务" + task.getId() + "没有起始库位，执行中止");
        }

        if (StringUtils.isEmpty(task.getToLocation())
                && task.getTaskType().equals(QuantityConstant.TASK_TYPE_SORTINGSHIPMENT)) {

            throw new ServiceException("任务" + task.getId() + "没有目的库位，执行中止");
        }

        String warehouseCode = task.getWarehouseCode();

        InventoryHeader inventoryHeader = null;

        if (task.getTaskType().equals(QuantityConstant.TASK_TYPE_SORTINGSHIPMENT)) {

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

            lambdaQueryWrapper.eq(InventoryHeader::getWarehouseCode, warehouseCode)

                    .eq(InventoryHeader::getLocationCode, task.getFromLocation())
                    .eq(InventoryHeader::getContainerCode, task.getContainerCode());

            inventoryHeader = inventoryHeaderService.getOne(lambdaQueryWrapper);

            if (inventoryHeader != null) {

                String locationCode = inventoryHeader.getLocationCode();

                Location location = locationService.getLocationByCode(locationCode, warehouseCode);

                location.setStatus(QuantityConstant.STATUS_LOCATION_EMPTY);

                locationService.updateById(location);
                inventoryHeader.setLocationCode(task.getToLocation());
                inventoryHeaderService.updateById(inventoryHeader);
                LambdaQueryWrapper<InventoryDetail> lambdaQueryWrapper2 = Wrappers.lambdaQuery();

                lambdaQueryWrapper2.eq(InventoryDetail::getWarehouseCode, warehouseCode)

                        .eq(InventoryDetail::getInventoryHeaderId, inventoryHeader.getId());
                List<InventoryDetail> inventoryDetails = inventoryDetailService.list(lambdaQueryWrapper2);

                if (inventoryDetails != null && inventoryDetails.size() > 0) {
                    for (InventoryDetail inventoryDetail : inventoryDetails) {

                        inventoryDetail.setLocationCode(task.getToLocation());
                        inventoryDetailService.updateById(inventoryDetail);
                    }
                }
            }
        }

        for (TaskDetail taskDetail : taskDetails) {
            if (taskDetail.getStatus() < QuantityConstant.TASK_STATUS_RUNNING) {
                //获取出库子货箱
                ShipmentContainerDetail shipmentContainerDetail = shipmentContainerDetailService.getById(taskDetail.getAllocationId());
                //获取对应库存记录
                InventoryDetail inventoryDetail = inventoryDetailService.getById(taskDetail.getToInventoryId());
                if (inventoryDetail == null) {
                    throw new ServiceException("任务明细对应的库存ID【" + taskDetail.getToInventoryId().toString() + "】不存在！");
                }
                //减扣库存单

                inventoryHeader = inventoryHeaderService.getById(inventoryDetail.getInventoryHeaderId());

                //扣减库存明细
                inventoryDetail.setTaskQty(inventoryDetail.getTaskQty().subtract(taskDetail.getQty()));
                inventoryDetail.setQty(inventoryDetail.getQty().subtract(taskDetail.getQty()));

                if (inventoryDetail.getQty().signum() == -1) {
                    throw new ServiceException("扣减库存大于wms库存");
                }
                if (inventoryDetail.getQty().signum() == 0

                        && inventoryDetail.getTaskQty().signum() == 0) {

                    //如果库存没有了，就删除这个库存
                    inventoryDetailService.removeById(inventoryDetail.getId());
                    inventoryHeader.setTotalQty(inventoryHeader.getTotalQty().subtract(taskDetail.getQty()));
                    inventoryHeader.setTotalLines(inventoryHeader.getTotalLines() - 1);

                    if (inventoryHeader.getTotalQty().signum() == 0) {

                        inventoryHeaderService.removeById(inventoryHeader.getId());
                    } else {
                        inventoryHeaderService.updateById(inventoryHeader);
                    }
                } else {
                    //否则更新这个库存
                    inventoryDetailService.updateById(inventoryDetail);
                    inventoryHeader.setTotalQty(inventoryHeader.getTotalQty().subtract(taskDetail.getQty()));
                    inventoryHeaderService.updateById(inventoryHeader);
                }
                //设置子任务状态为已执行
                taskDetail.setStatus(QuantityConstant.TASK_STATUS_COMPLETED);
                taskDetailService.updateById(taskDetail);
                //修改出库组盘明细状态
                shipmentContainerDetail.setStatus(QuantityConstant.SHIPMENT_CONTAINER_FINISHED);
                shipmentContainerDetailService.updateById(shipmentContainerDetail);
                //记录库存交易记录
                InventoryTransaction inventoryTransaction = new InventoryTransaction();

                inventoryTransaction.setWarehouseCode(warehouseCode);

                inventoryTransaction.setCompanyCode(inventoryDetail.getCompanyCode());

                inventoryTransaction.setLocationCode(inventoryDetail.getLocationCode());
                inventoryTransaction.setContainerCode(inventoryDetail.getContainerCode());
                inventoryTransaction.setTransactionType(QuantityConstant.INVENTORY_TRANSACTION_SHIPMENT);

                inventoryTransaction.setMaterialCode(inventoryDetail.getMaterialCode());
                inventoryTransaction.setMaterialName(inventoryDetail.getMaterialName());
                inventoryTransaction.setMaterialSpec(inventoryDetail.getMaterialSpec());
                inventoryTransaction.setMaterialUnit(inventoryDetail.getMaterialUnit());

                inventoryTransaction.setReferCode(taskDetail.getReferenceCode());

                inventoryTransaction.setBillCode(taskDetail.getBillCode());

                inventoryTransaction.setInventoryDetailId(inventoryDetail.getId());

                inventoryTransaction.setMoCode(inventoryDetail.getMoCode());
                inventoryTransaction.setUWarehouseCode(inventoryDetail.getUWarehouseCode());
                inventoryTransaction.setGoodsShelfNo(inventoryDetail.getGoodsShelfNo());
                inventoryTransaction.setZoneCode(inventoryDetail.getZoneCode());

                //取出子单据
                ShipmentDetail shipmentDetail = shipmentDetailService.getById(taskDetail.getBillDetailId());

                if (shipmentDetail != null) {

                    inventoryTransaction.setBillDetailId(shipmentDetail.getId());
                }
                inventoryTransaction.setBatch(inventoryDetail.getBatch());
                inventoryTransaction.setLot(inventoryDetail.getLot());
                inventoryTransaction.setProjectNo(inventoryDetail.getProjectNo());

                inventoryTransaction.setQcCheck(inventoryDetail.getQcCheck());
                inventoryTransaction.setSupplierCode(inventoryDetail.getSupplierCode());

                inventoryTransaction.setManufactureDate(inventoryDetail.getManufactureDate());
                inventoryTransaction.setExpirationDate(inventoryDetail.getExpirationDate());

                inventoryTransaction.setInventorySts(inventoryDetail.getInventorySts());
                //这里取反，更符合出库的语义，同时方便对记录进行统计
                inventoryTransaction.setTaskQty(taskDetail.getQty());
                inventoryTransactionService.save(inventoryTransaction);

//                materialWarningService.materialWarning(taskDetail.getMaterialCode(), taskDetail.getCompanyCode());

            }
        }
        //设置主任务为已执行
        task.setStatus(QuantityConstant.TASK_STATUS_COMPLETED);

        task.setCompleteStatus(1);

        taskHeaderService.updateById(task);

        /* 更新库位和容器*/

        updateShipmentLocationContainer(task.getFromLocation(), task.getToLocation(),
                task.getContainerCode(), task.getTaskType(), warehouseCode);

        //设置出库货箱表头状态为拣货任务完成
        LambdaUpdateWrapper<ShipmentContainerHeader> shipmentContainerHeaderLambdaUpdateWrapper = Wrappers.lambdaUpdate();
        shipmentContainerHeaderLambdaUpdateWrapper.eq(ShipmentContainerHeader::getId, task.getAllocationHeadId())

                .set(ShipmentContainerHeader::getStatus, QuantityConstant.SHIPMENT_CONTAINER_FINISHED);

        if (!containerHeaderService.update(shipmentContainerHeaderLambdaUpdateWrapper)) {
            throw new ServiceException("更新组盘头状态失败");
        }

        //修改出库单状态
        List<TaskDetail> taskDetailList = taskDetailService.findByTaskId(task.getId());
        HashSet<Integer> ids = new HashSet<>();
        for (TaskDetail taskDetail : taskDetailList) {
            ShipmentDetail shipmentDetail = shipmentDetailService.getById(taskDetail.getBillDetailId());

            if (StringUtils.isNotNull(shipmentDetail)) {

                if (shipmentDetail.getBackQty() == null || shipmentDetail.getBackQty().compareTo(BigDecimal.ZERO) == 0) {

                    shipmentDetail.setBackQty(BigDecimal.ZERO.add(taskDetail.getQty()));

                } else {

                    shipmentDetail.setBackQty(shipmentDetail.getBackQty().add(taskDetail.getQty()));
                }

                if (shipmentDetail.getQty().compareTo(shipmentDetail.getTaskQty()) == 0) {

                    shipmentDetail.setStatus(QuantityConstant.SHIPMENT_HEADER_COMPLETED);
                    shipmentDetailService.updateById(shipmentDetail);

                } else {

                    shipmentDetailService.updateById(shipmentDetail);

                }
                ids.add(shipmentDetail.getShipmentId());

            }

        }

        /*更新出库单状态*/
        for (Integer id : ids) {
            ShipmentHeader shipmentHeader = shipmentHeaderService.getById(id);
            if (shipmentHeader != null) {
                Map<String, Integer> status = shipmentDetailService.selectStatus(shipmentHeader.getId());
                Integer maxStatus = status.get("maxStatus");
                Integer minStatus = status.get("minStatus");
                if (maxStatus.equals(QuantityConstant.SHIPMENT_HEADER_COMPLETED)) {
                    shipmentHeader.setFirstStatus(QuantityConstant.SHIPMENT_HEADER_COMPLETED);
                }
                if (minStatus.equals(QuantityConstant.SHIPMENT_HEADER_COMPLETED)) {
                    shipmentHeader.setLastStatus(QuantityConstant.SHIPMENT_HEADER_COMPLETED);
                }

                shipmentHeader.setLastUpdatedBy(task.getLastUpdatedBy());

                shipmentHeader.setLastUpdated(new Date());
                shipmentHeaderService.updateById(shipmentHeader);
            }
        }

        return AjaxResult.success("完成出库任务成功");

    }

    /**
     * 出库任务完成时更新库位和容器状态

     *
     * @param fromLocation  源库位
     * @param toLocation    目标库位

     * @param containerCode 容器编码

     * @param taskType      任务类型

     */

    public void updateShipmentLocationContainer(String fromLocation, String toLocation,

                                                String containerCode, Integer taskType, String warehouseCode) {

        //将库位状态改为空闲，如果是整出的对应的容器也清空

        Location fromLocationRecord = locationService.getLocationByCode(fromLocation, warehouseCode);

        if (StringUtils.isNull(fromLocationRecord)) {
            throw new ServiceException("系统没有" + fromLocation + "库位");
        }

        if (taskType.equals(QuantityConstant.TASK_TYPE_WHOLESHIPMENT)) {
            fromLocationRecord.setStatus(QuantityConstant.STATUS_LOCATION_EMPTY);

            if (!fromLocationRecord.getZoneCode().equals("XN")) {
                fromLocationRecord.setContainerCode("");
            }

            locationService.updateById(fromLocationRecord);

        } else {

            Location toLocationRecord = locationService.getLocationByCode(toLocation, warehouseCode);

            if (StringUtils.isNull(fromLocationRecord)) {
                throw new ServiceException("系统没有" + toLocation + "库位");
            }

            toLocationRecord.setStatus(QuantityConstant.STATUS_LOCATION_EMPTY);

            toLocationRecord.setContainerCode(containerCode);

            locationService.updateById(toLocationRecord);
        }

        //昆山立库出库不需要删除原库位,昆山有个提前解锁库位接口
        if (warehouseCode.equals(QuantityConstant.WAREHOUSE_KS) &&fromLocationRecord.getZoneCode().equals("LK")){
        }else{
            //分拣出库，原库位和目的库位不同则解绑原库位
            if (taskType.equals(QuantityConstant.TASK_TYPE_SORTINGSHIPMENT)&&!fromLocation.equals(toLocation)) {

                fromLocationRecord.setContainerCode("");
                fromLocationRecord.setStatus(QuantityConstant.STATUS_LOCATION_EMPTY);
                locationService.updateById(fromLocationRecord);
            }

        }

//        if (warehouseCode.equals(QuantityConstant.WAREHOUSE_XZ) && (taskType.equals(QuantityConstant.TASK_TYPE_SORTINGSHIPMENT) || taskType.equals(QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT))) {
//            if (fromLocationRecord.getZoneCode().equals("LK")) {
//                fromLocationRecord.setContainerCode("");
//                fromLocationRecord.setStatus(QuantityConstant.STATUS_LOCATION_EMPTY);
//                locationService.updateById(fromLocationRecord);
//            }
//        }

        Container container = containerService.getContainerByCode(containerCode, warehouseCode);

        if (StringUtils.isEmpty(containerCode)) {

            throw new ServiceException("系统无" + container + "容器");

        }

        if (taskType.equals(QuantityConstant.TASK_TYPE_WHOLESHIPMENT)) {
            if ("LS".equals(container.getContainerType())) {
                if (!containerService.removeById(container.getId())) {
                    throw new ServiceException("删除临时容器失败");
                }
            } else {

                if (!container.getZoneCode().equals("XN")) {
                    containerService.updateLocationCodeAndStatus(containerCode, "",
                            QuantityConstant.STATUS_CONTAINER_EMPTY, warehouseCode);
                } else {
                    containerService.updateLocationCodeAndStatus(containerCode, container.getLocationCode(),
                            QuantityConstant.STATUS_CONTAINER_EMPTY, warehouseCode);
                }

            }
        } else {
            //查询是否存在关联的库存，入如果没有就修改容器状态为empty
            LambdaQueryWrapper<InventoryDetail> inventoryDetaillambdaQueryWrapper = Wrappers.lambdaQuery();
            inventoryDetaillambdaQueryWrapper.eq(InventoryDetail::getContainerCode, containerCode);