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.conditions.update.UpdateWrapper;

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

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

import com.huaheng.common.utils.DataUtils;

import com.huaheng.common.utils.StringUtils;

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

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.inventory.cycleCountDetail.domain.CycleCountDetail;
import com.huaheng.pc.inventory.cycleCountDetail.service.CycleCountDetailService;

import com.huaheng.pc.inventory.cycleCountHeader.domain.CycleCountHeader;

import com.huaheng.pc.inventory.cycleCountHeader.service.CycleCountHeaderService;

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.receipt.receiptContainerDetail.domain.ReceiptContainerDetail;
import com.huaheng.pc.receipt.receiptContainerDetail.service.ReceiptContainerDetailService;

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

import com.huaheng.pc.receipt.receiptHeader.domain.ReceiptHeader;
import com.huaheng.pc.receipt.receiptHeader.service.ReceiptHeaderService;

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.task.taskDetail.domain.TaskDetail;
import com.huaheng.pc.task.taskDetail.service.TaskDetailService;
import com.huaheng.pc.task.taskHeader.domain.ShipmentTaskCreateModel;

import org.apache.poi.ss.formula.functions.T;

import org.jsoup.helper.DataUtil;

import org.springframework.stereotype.Service;

import java.math.BigDecimal;

import java.text.SimpleDateFormat;
import java.util.ArrayList;

import java.util.Date;

import java.util.List;

import java.util.Map;

import java.util.*;

import java.util.concurrent.CopyOnWriteArrayList;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.huaheng.pc.task.taskHeader.domain.TaskHeader;
import com.huaheng.pc.task.taskHeader.mapper.TaskHeaderMapper;

import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

@Service

public class TaskHeaderServiceImpl extends ServiceImpl<TaskHeaderMapper, TaskHeader> implements TaskHeaderService {

    @Resource

    private ShipmentContainerHeaderService shipmentContainerHeaderService;

    @Resource

    private ShipmentContainerDetailService shipmentContainerDetailService;

    @Resource

    private LocationService locationService;

    @Resource

    private ContainerService containerService;
    @Resource

    private TaskDetailService taskDetailService;

    @Resource

    private TaskHeaderService taskHeaderService;

    @Resource

    private InventoryHeaderService inventoryHeaderService;

    @Resource
    private InventoryDetailService inventoryDetailService;
    @Resource

    private InventoryTransactionService inventoryTransactionService;

    @Resource

    private ReceiptHeaderService receiptHeaderService;

    @Resource
    private ReceiptDetailService receiptDetailService;

    @Resource

    private ReceiptContainerDetailService receiptContainerDetailService;

    @Resource
    private ShipmentHeaderService shipmentHeaderService;
    @Resource
    private ShipmentDetailService shipmentDetailService;

    @Resource
    private CycleCountDetailService cycleCountDetailService;

    @Resource

    private CycleCountHeaderService cycleCountHeaderService;
    @Resource

    private ReceiptContainerHeaderService receiptContainerHeaderService;

    @Resource

    private TaskHeaderMapper taskHeaderMapper;

    /**

     * 查询容器有无任务

     */

    @Override
    public Integer UncompleteCount(String ContainerCode) {
        return taskHeaderMapper.UncompleteCount(ContainerCode, ShiroUtils.getWarehouseCode());
    }

    /**
     * 取消任务
     * */
    @Override

    @Transactional

    public AjaxResult cancelTask(Integer[] taskIds) {
        for(int taskId : taskIds){
            TaskHeader taskHeader = taskHeaderService.getById(taskId);
            if(taskHeader==null){
                return AjaxResult.error("任务"+taskId+"未找到，操作中止");
            }
            if(taskHeader.getStatus() > 9){
                return AjaxResult.error("存在任务"+taskHeader.getId()+"已下发或执行，操作中止");
            }

            //查出任务明细
            TaskDetail taskDetail1 = new TaskDetail();
            taskDetail1.setTaskId(taskHeader.getId());
            taskDetail1.setWarehouseCode(taskHeader.getWarehouseCode());
            taskDetail1.setCompanyCode(taskHeader.getCompanyCode());
            LambdaQueryWrapper<TaskDetail> td = Wrappers.lambdaQuery(taskDetail1);
            List<TaskDetail> taskDetailList = taskDetailService.list(td);
            TaskDetail taskDetail = taskDetailList.get(0);
            if(taskDetail == null){
                throw new ServiceException("任务明细条目错误");
            }

            //删除子任务
            LambdaQueryWrapper<TaskDetail> lambdaQueryWrapper = Wrappers.lambdaQuery();
            lambdaQueryWrapper.eq(TaskDetail::getTaskId,taskHeader.getId());
            taskDetailService.remove(lambdaQueryWrapper);
            //删除主任务
            taskHeaderService.removeById(taskHeader.getId());
            // 更改库位状态（整盘入库任务除外）
            if(taskHeader.getInternalTaskType() == 100 )
            {
                ReceiptContainerHeader record =new ReceiptContainerHeader();
                record.setStatus((short)0);
                record.setId(taskHeader.getAllocationHeadId());

                if (receiptContainerHeaderService.updateById(record)){throw new ServiceException("回滚组盘明细失败");}

            }
            //根据任务类型来更新货箱状态
            //修改关联的货箱状态
            if(taskHeader.getInternalTaskType() == 200)  {
                ShipmentContainerHeader shipmentContainerHeader = new ShipmentContainerHeader();
                shipmentContainerHeader.setId(taskHeader.getAllocationHeadId());
                shipmentContainerHeader.setStatus(0);
                shipmentContainerHeaderService.updateById(shipmentContainerHeader);
            }

            //盘点取消任务，恢复明细状态为1
            if(taskHeader.getInternalTaskType() == 700)   {

                CycleCountDetail cycleCountDetail = new CycleCountDetail();
                cycleCountDetail.setCompanyCode(taskDetail.getCompanyCode());
                cycleCountDetail.setWarehouseCode(taskDetail.getWarehouseCode());
                cycleCountDetail.setLocationCode(taskDetail.getFromLocation());
                cycleCountDetail.setContainerCode(taskDetail.getContainerCode());
                cycleCountDetail.setCycleCountHeadCode(taskDetail.getBillCode());//盘点单Code
                cycleCountDetail.setId(taskDetail.getBillDetailId());//盘点细单ID
                LambdaQueryWrapper<CycleCountDetail> lam = Wrappers.lambdaQuery(cycleCountDetail);
                List<CycleCountDetail> cycleCountDetailList = cycleCountDetailService.list(lam);//
                for(CycleCountDetail item:cycleCountDetailList){
                    item.setTaskHeaderId(null);
                    item.setTaskHeaderId(null);
                    item.setLastUpdated(new Date());
                    item.setLastUpdatedBy(ShiroUtils.getLoginName());
                    item.setEnableStatus(1);
                    cycleCountDetailService.saveOrUpdate(item);
                }

            }

            if(taskHeader.getInternalTaskType()==100||taskHeader.getInternalTaskType()==200){
                if(taskHeader.getToLocation()!=null){
                    //更新托盘、库位状态
                    locationService.updateStatus(taskHeader.getToLocation(), "empty");
                }
            }
//            if(task.getType()==900){
//                //出库查看任务没有关联的货箱，不做处理
//            }
        }

        return AjaxResult.success("取消任务成功！");
    }

    /**
     * 生成出库任务

     *

     * @param shipmentTaskCreateModel
     * @return
     */
    @Override
    @Transactional

    public AjaxResult createTaskFromShipmentContainers(ShipmentTaskCreateModel shipmentTaskCreateModel) {

        Boolean flag = true;

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

        if (shipmentContainerHeader == null) {

            return AjaxResult.error("出库货箱" + shipmentContainerHeaderId + "未找到,操作中止");
        }

        if (shipmentContainerHeader.getStatus() > 9) {

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

        LambdaQueryWrapper<ShipmentContainerDetail> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(ShipmentContainerDetail::getShippingContainerId, shipmentContainerHeader.getId());

        List<ShipmentContainerDetail> shipmentContainerDetails = shipmentContainerDetailService.list(lambdaQueryWrapper);

        if (shipmentContainerDetails == null || shipmentContainerDetails.size() == 0) {

            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 (location == null) {

            return AjaxResult.error("库位禁用或不存在！");
        }
        //创建任务头
        TaskHeader task = new TaskHeader();
        //分拣出库
        task.setTaskType(400);

        task.setFromLocation(shipmentContainerHeader.getLocationCode());

        task.setToLocation(shipmentContainerHeader.getLocationCode());

        //判断是否整出任务，钱柜和AGV不能整出

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

            LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getLocationCode, shipmentContainerHeader.getLocationCode())
                    .eq(InventoryDetail::getWarehouseCode, ShiroUtils.getWarehouseCode());

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

            BigDecimal inventoryTotal = new BigDecimal("0");
            for (InventoryDetail item : inventories) {

                inventoryTotal = inventoryTotal.add(item.getQty());
            }
            BigDecimal containerTotal = new BigDecimal("0");

            for (ShipmentContainerDetail item : shipmentContainerDetails) {

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

            if (inventoryTotal.compareTo(containerTotal) == 0) {

                task.setTaskType(300);//整盘出库

                task.setToLocation("");

            }

        task.setInternalTaskType(200);

        task.setAllocationHeadId(shipmentContainerHeader.getId());

        task.setWarehouseCode(shipmentContainerHeader.getWarehouseCode());
        task.setCompanyCode(shipmentContainerHeader.getCompanyCode());
        task.setAssignedUser(ShiroUtils.getLoginName());
        task.setConfirmedBy(ShiroUtils.getLoginName());

        task.setStatus(0);

        task.setContainerCode(shipmentContainerHeader.getContainerCode());
        task.setCreatedBy(ShiroUtils.getLoginName());
        task.setCreated(new Date());
        task.setLastUpdatedBy(ShiroUtils.getLoginName());
        task.setLastUpdated(null);
        this.save(task);
        //遍历子货箱创建子任务

        for (ShipmentContainerDetail shipmentContainerDetail : shipmentContainerDetails) {

            TaskDetail taskDetail = new TaskDetail();
            taskDetail.setTaskId(task.getId());

            taskDetail.setInternalTaskType(task.getInternalTaskType());

            taskDetail.setWarehouseCode(task.getWarehouseCode());
            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.setFromLocation(task.getFromLocation());
            taskDetail.setToLocation(task.getToLocation());

            taskDetail.setLot(shipmentContainerDetail.getLot());
            taskDetail.setBatch(shipmentContainerDetail.getBatch());
            taskDetail.setProjectNo(shipmentContainerDetail.getProjectNo());

            taskDetail.setStatus(0);

            taskDetail.setWaveId(shipmentContainerDetail.getWaveId());

            taskDetail.setInventorySts(shipmentContainerDetail.getInventorySts());

            taskDetail.setCreatedBy(ShiroUtils.getLoginName());

            taskDetail.setLastUpdatedBy(ShiroUtils.getLoginName());

            flag=taskDetailService.save(taskDetail);
            if(flag == false){
                throw new ServiceException("新建任务明细失败，sql报错");
            }

            shipmentContainerDetail.setStatus(10);

        }
        //更新货位状态

        shipmentContainerHeader.setStatus(10);
        flag = shipmentContainerHeaderService.updateById(shipmentContainerHeader);
        if(flag == false){
            throw new ServiceException("修改组盘头状态失败，sql报错");
        }

        flag = shipmentContainerDetailService.updateBatchById(shipmentContainerDetails);
        if(flag == false){
            throw new ServiceException("修改组盘明细状态明细失败，sql报错");
        }

        return AjaxResult.success(task.getId());

    }

    /**

     *下发WCS执行任务

     * 执行任务
     * */

    @Override

    @Transactional

    public AjaxResult<TaskHeader> sendTaskToWcs(Integer[] taskIds) {

        TaskHeader task = null;
        for (Integer taskId : taskIds) {

            task = taskHeaderService.getById(taskId);

            if (task.getStatus() > 9) {

                return AjaxResult.error("任务" + taskId + "已经下发，请不要重复下发，操作中止");
            }
            //修改任务头表

            task.setId(taskId);

            task.setStatus(10);
            task.setStartPickDateTime(new Date());   //生成时间
            task.setLastUpdated(new Date());
            task.setLastUpdatedBy(ShiroUtils.getLoginName());

            taskHeaderService.saveOrUpdate(task);

            //修改任务明细状态

            LambdaQueryWrapper<TaskDetail> lambdaWrapper = Wrappers.lambdaQuery();
            lambdaWrapper.eq(TaskDetail::getTaskId, task.getId());
            List<TaskDetail> taskDetailList = taskDetailService.list(lambdaWrapper);
            List<TaskDetail> taskDetails = new ArrayList<>();
            for (TaskDetail item:taskDetailList){
                item.setStatus(10);
                item.setLastUpdated(new Date());
                item.setLastUpdatedBy(ShiroUtils.getLoginName());
                item.setProcessStamp("100");
                taskDetails.add(item);
                //盘点执行修改盘点单据状态为10
                if(task.getTaskType() == 700){
                    cycleCountDetailService.updataDetailStatus(item.getBillDetailId(),10);
                }

            }

            if (!taskDetailService.saveOrUpdateBatch(taskDetails)){

                throw new ServiceException("更新任务明细失败");
            }

//            //修改入库明细
//            if (task.getInternalTaskType()==100){
//                ReceiptDetail receiptDetail = receiptDetailService.queryflow(receiptDetailService.getById(record.getId()));
//                if (!receiptDetailService.updateById(receiptDetail)){
//                    throw new ServiceException("更新状态失败");
//                }
//                receiptDetailService.updateReceiptHeaderLastStatus(receiptDetail.getReceiptId());
//
//                //修改组盘表状态为20
//                ReceiptContainerDetail receiptContainerDetail = new ReceiptContainerDetail();
//                receiptContainerDetail.setStatus(20);
//                receiptContainerDetail.setLastUpdated(new Date());
//                receiptContainerDetail.setLastUpdatedBy(ShiroUtils.getLoginName());
//                LambdaUpdateWrapper<ReceiptContainerDetail> receiptContainerDetailLambdaUpdateWrapper = Wrappers.lambdaUpdate();
//                receiptContainerDetailLambdaUpdateWrapper.eq(ReceiptContainerDetail::getReceiptId,receiptDetail.getReceiptId());
//                if (! receiptContainerDetailService.update(receiptContainerDetail, receiptContainerDetailLambdaUpdateWrapper))
//                    throw new ServiceException("更新组盘状态失败");
//            }
//
//            //修改出库单状态
//            if (task.getInternalTaskType()==200){
//                LambdaQueryWrapper<TaskDetail> taskDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
//                taskDetailLambdaQueryWrapper.eq(TaskDetail::getTaskId,task.getId());
//               List<TaskDetail> taskDetailList = taskDetailService.list(taskDetailLambdaQueryWrapper);
//
//                for (TaskDetail taskDeatails: taskDetailList) {
//                    LambdaQueryWrapper<ShipmentDetail> shipmentDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
//                    shipmentDetailLambdaQueryWrapper.eq(ShipmentDetail::getId,taskDeatails.getBillDetailId());
//
//                    ShipmentHeader shipmentHeader =new ShipmentHeader();
//                    shipmentHeader.setId(shipmentDetailService.getOne(shipmentDetailLambdaQueryWrapper).getShipmentId());
//                    shipmentHeader.setFirstStatus(100);
//                    shipmentHeader.setLastStatus(100);
//                    shipmentHeader.setLastUpdatedBy(ShiroUtils.getLoginName());
//                    shipmentHeader.setLastUpdated(new Date());
//                    shipmentHeaderService.updateById(shipmentHeader);
//                }
//            }

        }

        return AjaxResult.success("执行下发任务成功", task);

    }

    @Override

    @Transactional
    public AjaxResult completeTaskByWMS(Integer[] taskIds)  {

        for (int taskId : taskIds) {
            TaskHeader task = taskHeaderService.getById(taskId);
            if (task == null) {
                throw new ServiceException("任务" + taskId + "未找到，执行中止");
            }
            //如果已完成则不管
            if (task.getStatus() == 100) {
                throw new ServiceException("任务(" + taskId + ")任务已经是完成的！");
            }
            //如果没有库位不能完成

            if (StringUtils.isEmpty(task.getToLocation())) {

                throw new ServiceException("任务" + taskId + "没有库位，执行中止");
            }
            this.completeTask(task);
        }

        return AjaxResult.success("完成任务成功！");
    }

    /**
     * 完成任务
     *
     * @param task
     */

    @Transactional
    public void completeTask(TaskHeader task) {

        //区分任务类型

        if (task.getInternalTaskType() == 100) {

            //入库任务
            completeReceiptTask(task);
        }

        if (task.getInternalTaskType() == 200) {

//            出库任务
            completeShipmentTask(task);

        }

        // 900 出库查看,空托出库查看

        if ( task.getTaskType() == 900) {
            completeSeeOutTask(task);

        }

        // 700 盘点
        if ( task.getTaskType() == 700) {
            completeCycleCountTask(task);
        }
        if (task.getTaskType() == 800) {

//          //移库

            completeTransferTask(task);

        }

        if (task.getTaskType() == 500) {

            //空托盘入库
           completeEmptyIn(task);

        }

        if (task.getTaskType() == 600) {

           //空托盘出库
            completeEmptyOut(task);

        }
    }

    /**

     *完成入库任务

     */

    @Override

    @Transactional

    public AjaxResult completeReceiptTask(TaskHeader task){

        List<Map<String, Object>> taskReceiptContainerDetail = taskHeaderMapper.getReceiptTask(task.getId());
        if (taskReceiptContainerDetail.size() < 1) {

            return AjaxResult.success("未找到对应任务的入库单号!!!");
        }

        for (Map<String, Object> map : taskReceiptContainerDetail) {
            //将未完成的任务数量更新到库存表
            if (DataUtils.getInteger(map.get("status")) < 100) {

                LambdaQueryWrapper<InventoryDetail> inventory = Wrappers.lambdaQuery();
                inventory.eq(InventoryDetail::getWarehouseCode, ShiroUtils.getWarehouseCode())
                        .eq(InventoryDetail::getLocationCode, task.getFromLocation())
                        .eq(InventoryDetail::getReceiptDetailId, DataUtils.getString(map.get("receiptDetailId")))
                        .eq(InventoryDetail::getContainerCode, DataUtils.getString(map.get("containerCode")));
                InventoryDetail detail = inventoryDetailService.getOne(inventory);
                if (detail == null) {

                    //添加库存单
                    InventoryHeader header = new InventoryHeader();
                    header.setWarehouseCode(DataUtils.getString(map.get("warehouseCode")));//仓库
                    header.setCompanyCode(task.getCompanyCode());//货主
                    header.setContainerCode(DataUtils.getString(map.get("containerCode")));//容器号

                    header.setLocationCode(task.getToLocation());

                    header.setTotalQty(DataUtils.getInteger(map.get("totalQty")));//总数量
                    header.setLocking(1);
                    header.setEnable(1);
                    header.setCreatedBy(ShiroUtils.getLoginName());
                    header.setCreated(new Date());
                    header.setLastUpdated(new Date());

                    if (!inventoryHeaderService.save(header))
                        throw new ServiceException("添加库存单失败");

                    //库存明细添加
                    detail = new InventoryDetail();
                    detail.setInventoryHeaderId(header.getId());//库存头ID
                    detail.setWarehouseCode(DataUtils.getString(map.get("warehouseCode")));//仓库
                    detail.setCompanyCode(task.getCompanyCode());//货主

                    detail.setLocationCode(task.getToLocation());//库位号

                    detail.setContainerCode(DataUtils.getString(map.get("containerCode")));//容器号
                    detail.setMaterialCode(DataUtils.getString(map.get("materialCode")));//物料号
                    detail.setMaterialName(DataUtils.getString(map.get("materialName")));//物料名称
                    detail.setMaterialSpec(DataUtils.getString(map.get("materialSpec")));//物料规格

                    detail.setMaterialUnit(DataUtils.getString(map.get("materialUnit")));//物料单位

                    detail.setReceiptCode(DataUtils.getString(map.get("receiptCode")));//入库单编码

                    detail.setReceiptDetailId(DataUtils.getInteger(map.get("receiptDetailId")));//入库单明细ID

                    detail.setBatch(DataUtils.getString(map.get("batch")));//批次
                    detail.setLot(DataUtils.getString(map.get("lot")));//批号
                    detail.setInventorySts(DataUtils.getString(map.get("inventorySts")));//库存状态

//                    detail.setManufactureDate(new SimpleDateFormat("yyyy-MM-dd").parse(map.get("manufactureDate").toString()));//生产日期

//                    detail.setExpirationDate(new SimpleDateFormat("yyyy-MM-dd").parse(map.get("expirationDate").toString()));//失效日期

                    detail.setQty(DataUtils.getBigDecimal(map.get("qty")));//数量

                    detail.setTaskQty(DataUtils.getBigDecimal(0));

                    detail.setCreatedBy(ShiroUtils.getLoginName());//创建人
                    detail.setLastUpdatedBy(ShiroUtils.getLoginName());//创建时间

                    if (!inventoryDetailService.save(detail))
                        throw new ServiceException("添加库存明细失败");

                    }
                 else {

                    detail.setQty(detail.getQty().add(DataUtils.getBigDecimal(map.get("qty"))));
                    detail.setLastUpdatedBy(ShiroUtils.getLoginName());
                    LambdaUpdateWrapper<InventoryDetail> lambdaUpdateWrapper = Wrappers.lambdaUpdate();

                    lambdaUpdateWrapper.eq(InventoryDetail::getId,DataUtils.getInteger(map.get("receiptDetailId")));

                    if (!inventoryDetailService.update(detail, lambdaUpdateWrapper))

                        throw new ServiceException("更新入库单明细失败");

                }
                //记录库存交易记录
                InventoryTransaction inventoryTransaction = new InventoryTransaction();
                inventoryTransaction.setTransactionType(10);
                inventoryTransaction.setWarehouseCode(DataUtils.getString(map.get("warehouseCode")));
                inventoryTransaction.setCompanyCode(task.getCompanyCode());

                inventoryTransaction.setLocationCode(task.getToLocation());

                inventoryTransaction.setContainerCode(DataUtils.getString(map.get("containerCode")));
                inventoryTransaction.setMaterialCode(DataUtils.getString(map.get("materialCode")));
                inventoryTransaction.setMaterialName(DataUtils.getString(map.get("materialName")));

                inventoryTransaction.setMaterialSpec(DataUtils.getString(map.get("materialSpec")));//物料规格
                inventoryTransaction.setMaterialUnit(DataUtils.getString(map.get("materialUnit")));//物料单位

                inventoryTransaction.setBillCode(DataUtils.getString(map.get("receiptCode")));

                inventoryTransaction.setBillDetailId(DataUtils.getInteger(map.get("receiptDetailId")));

                inventoryTransaction.setBatch(DataUtils.getString(map.get("batch")));
                inventoryTransaction.setLot(DataUtils.getString(map.get("lot")));

//                inventoryTransaction.setManufactureDate(new SimpleDateFormat("yyyy-MM-dd").parse(map.get("manufactureDate").toString()));//生产日期

//                inventoryTransaction.setExpirationDate(DataUtils.getDateTime(map.get("expirationDate")));

                inventoryTransaction.setInventorySts(DataUtils.getString((map.get("inventorySts"))));

                inventoryTransaction.setTaskQty(DataUtils.getBigDecimal(map.get("qty")));

                inventoryTransaction.setCreated(new Date());
                inventoryTransaction.setCreatedBy(ShiroUtils.getLoginName());

                if (!inventoryTransactionService.save(inventoryTransaction))
                    throw new ServiceException("新增库存记录失败");

                //修改任务明细的状态为完成
                TaskDetail taskDetail = new TaskDetail();
                taskDetail.setStatus(100);
                taskDetail.setLastUpdatedBy(ShiroUtils.getLoginName());
                taskDetail.setAgingDate(new Date());   //入库时间
                LambdaUpdateWrapper<TaskDetail> lambdaUpdateWrapper = Wrappers.lambdaUpdate();

                lambdaUpdateWrapper.eq(TaskDetail::getTaskId,task.getId());

                taskDetailService.update(taskDetail, lambdaUpdateWrapper);

                if ( !taskDetailService.update(taskDetail, lambdaUpdateWrapper)){
                    throw new ServiceException("修改入库单明细失败");
                }

                //修改任务主表状态，因为立库任务表单头只对应一个货箱，表单详情的任务会同时完成

                task.setStatus(100);
                task.setLastUpdatedBy(ShiroUtils.getLoginName());
                task.setLastUpdated(new Date());
                LambdaUpdateWrapper<TaskHeader> taskHeaderLambdaUpdateWrapper = Wrappers.lambdaUpdate();
                taskHeaderLambdaUpdateWrapper.eq(TaskHeader::getId, task.getId());

                if (!taskHeaderService.update(task, taskHeaderLambdaUpdateWrapper))
                    throw new ServiceException("更新任务主表失败");

                //修改库位状态和对应的容器
                Location location = new Location();

                location.setContainerCode(task.getContainerCode());
                location.setStatus("empty");

                LambdaUpdateWrapper<Location> locationLambdaUpdateWrapper = Wrappers.lambdaUpdate();

                locationLambdaUpdateWrapper.eq(Location::getCode, task.getToLocation());

                if (!locationService.update(location,locationLambdaUpdateWrapper))

                    throw new ServiceException("更新库位失败");

                //修改容器状态和对应的库位
                Container container = new Container();

                container.setLocationCode(task.getToLocation());

                container.setStatus("some");

                LambdaUpdateWrapper<Container> containerLambdaUpdateWrapper = Wrappers.lambdaUpdate();

                containerLambdaUpdateWrapper.eq(Container::getCode, task.getContainerCode());