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.huaheng.api.wcs.domain.TaskReceiptCompleteDomain;

import com.huaheng.api.wcs.service.warecellAllocation.WarecellAllocationService;

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.pc.config.container.domain.Container;
import com.huaheng.pc.config.container.service.ContainerService;
import com.huaheng.pc.config.location.domain.Location;
import com.huaheng.pc.config.location.service.LocationService;

import com.huaheng.pc.config.material.domain.Material;
import com.huaheng.pc.config.material.service.MaterialService;
import com.huaheng.pc.config.materialMultiple.domain.MaterialMultiple;
import com.huaheng.pc.config.materialMultiple.service.MaterialMultipleServiceImpl;

import com.huaheng.pc.config.materialWarnning.service.IMaterialWarningService;

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

import com.huaheng.pc.task.taskHeader.mapper.TaskHeaderMapper;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

import java.text.MessageFormat;
import java.util.*;

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

 *

 * @author mahua

 * @date 2020/7/6
 */
@Service
public class ReceiptTaskService {

    @Resource
    private TaskHeaderService taskHeaderService;
    @Resource
    private TaskDetailService taskDetailService;
    @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 ReceiptContainerHeaderService receiptContainerHeaderService;
    @Resource

    private TaskHeaderMapper taskHeaderMapper;
    @Resource

    private ContainerService containerService;
    @Resource
    private LocationService locationService;

    @Resource
    private MaterialService materialService;
    @Resource
    private MaterialMultipleServiceImpl materialMultipleService;

    @Resource
    private IMaterialWarningService materialWarningService;

    @Resource
    private WarecellAllocationService warecellAllocationService;

    @Resource
    private BackInvokeService backInvokeService;

    /**
     * 创建入库任务(整盘入库、补充入库)
     *
     * @param ids 入库组盘头表id

     * @return AjaxResult 创建结果

     */
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult createReceiptTask(List<Integer> ids) {

        List<String> taskIds = new ArrayList<>();

        for (Integer id : ids) {
            ReceiptContainerHeader receiptContainerHeader = receiptContainerHeaderService.getById(id);

            //检查组盘信息，托盘是否锁定，锁定容器，检查组盘明细

            checkReceiptTask(receiptContainerHeader, id);

            //查询入库组盘明细

            LambdaQueryWrapper<ReceiptContainerDetail> lam = Wrappers.lambdaQuery();

            lam.eq(ReceiptContainerDetail::getReceiptContainerId, id);
            lam.lt(ReceiptContainerDetail::getStatus, QuantityConstant.RECEIPT_CONTAINER_TASK);

            List<ReceiptContainerDetail> list = receiptContainerDetailService.list(lam);
//            List<ReceiptContainerDetail> list = receiptContainerDetailService.getReceiptContainerDetailByHeaderId(id);

            if (list.isEmpty()) {
                throw new ServiceException("id:" + id + "的入库组盘，没有组盘明细，请先组盘！");
            }

            String containerCode = receiptContainerHeader.getContainerCode();
            Container container = containerService.getContainerByCode(containerCode);

            if (StringUtils.isNotNull(container) && ("D".equals(container.getContainerType()) || "A".equals(container.getContainerType()))) {

                receiptContainerHeader.setToLocation(container.getLocationCode());
                receiptContainerHeader.setFromLocation(container.getLocationCode());
                receiptContainerHeader.setTaskType(QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT);
                receiptContainerHeaderService.updateById(receiptContainerHeader);
                for (ReceiptContainerDetail receiptContainerDetail : list) {
                    receiptContainerDetail.setLocationCode(container.getLocationCode());
                    receiptContainerDetail.setTaskType(QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT);
                }
                receiptContainerDetailService.updateBatchById(list);
            }

            //检查库位容器，修改状态
            checkLocationContainer(receiptContainerHeader);

            if (receiptContainerHeader.getStatus() <= QuantityConstant.RECEIPT_CONTAINER_TASK.intValue()) {

                if (receiptContainerHeader.getStatus() < QuantityConstant.RECEIPT_CONTAINER_TASK) {
                    receiptContainerHeader.setStatus(QuantityConstant.RECEIPT_CONTAINER_TASK);
                    receiptContainerHeaderService.updateById(receiptContainerHeader);
                }
                //添加任务主表

                TaskHeader task = taskHeaderService.createTaskByReceipt(receiptContainerHeader);

                LambdaQueryWrapper<TaskHeader> lambdaQuery = Wrappers.lambdaQuery();
                lambdaQuery.lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);

                lambdaQuery.eq(TaskHeader::getContainerCode, containerCode);
                lambdaQuery.eq(TaskHeader::getInternalTaskType, 100);

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

                TaskHeader taskHeader = taskHeaderService.getOne(lambdaQuery);
                if (taskHeader != null) {
                    task = taskHeader;

                }

                task.setGoodsShelfNo(container.getGoodsShelfNo());

                if (task.getWarehouseCode().equals(QuantityConstant.WAREHOUSE_CS) && containerCode.startsWith("S")) {
                    task.setPort("P1004");

                }

                if (taskHeaderService.saveOrUpdate(task)) {

                    //添加任务明细表
                    for (ReceiptContainerDetail item : list) {

                        // 保存任务详情

                        taskDetailService.createTaskDetailByReceipt(task, item);

                        //更新入库组盘明细状态
                        item.setStatus(QuantityConstant.RECEIPT_CONTAINER_TASK);
                        if (!receiptContainerDetailService.updateById(item)) {
                            throw new ServiceException("更新入库组盘明细状态出错");
                        }

                        /* 修改明细状态为上架*/

                        ReceiptDetail receiptDetail = receiptDetailService.getById(item.getReceiptDetailId());
                        receiptDetail.setProcessStamp(String.valueOf(QuantityConstant.RECEIPT_HEADER_SHELF));
                        if (!receiptDetailService.updateById(receiptDetail)) {
                            throw new ServiceException("更新入库单详情失败");
                        }
                        //更新头表状态
                        receiptDetailService.updateReceiptHeaderLastStatus(receiptDetail.getReceiptId());
                    }

                    String taskId = String.valueOf(task.getId());
                    taskIds.add(taskId);

                    //昆山pk库区和xn库区直接完成任务

                    if (task.getWarehouseCode().equals(QuantityConstant.WAREHOUSE_KS)) {
                        if (task.getZoneCode().equals("PK") || task.getZoneCode().equals("XN")) {

                            AjaxResult ajaxResult = taskHeaderService.completeTask(task);

                            if (!ajaxResult.hasErr()) {
                                try {

                                    backInvokeService.invokeBack(Integer.valueOf(task.getId()));

                                } catch (Exception e) {

                                    e.printStackTrace();
                                }

                            }

                        }
                    }

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

        return AjaxResult.success("生成上架任务成功").setData(taskIds);

    }

    /**
     * 检查组盘信息，托盘是否锁定，锁定容器，检查组盘明细
     */
    public void checkReceiptTask(ReceiptContainerHeader receiptContainerHeader, Integer id) {

        if (receiptContainerHeader == null) {
            throw new ServiceException("id:" + id + "的入库组盘不存在！");
        }
        if (!receiptContainerHeader.getWarehouseCode().equals(ShiroUtils.getWarehouseCode())) {
            throw new ServiceException("id:" + id + "的入库组盘不能在" + ShiroUtils.getWarehouseCode() + "仓库操作");
        }
        Container container = containerService.getContainerByCode(receiptContainerHeader.getContainerCode());

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

//            throw new ServiceException("托盘已经锁定，不能生成任务，托盘号："+receiptContainerHeader.getContainerCode());

        }
        //锁定容器
        containerService.updateStatus(receiptContainerHeader.getContainerCode(),
                QuantityConstant.STATUS_CONTAINER_LOCK, container.getWarehouseCode());
    }

    /**
     * 检查库位容器，修改状态
     */
    public void checkLocationContainer(ReceiptContainerHeader receiptContainerHeader) {
        if (StringUtils.isNotEmpty(receiptContainerHeader.getFromLocation())) {

            locationService.updateStatus(receiptContainerHeader.getFromLocation(),
                    QuantityConstant.STATUS_LOCATION_LOCK);
        }
        String locationCode = receiptContainerHeader.getToLocation();

        if (StringUtils.isNotEmpty(locationCode)) {

            locationService.updateStatus(locationCode, QuantityConstant.STATUS_LOCATION_LOCK);
            Location desLocation = locationService.getLocationByCode(locationCode);
            String loginWarehouse = ShiroUtils.getWarehouseCode();

            if (!desLocation.getWarehouseCode().equals(loginWarehouse)) {

                throw new ServiceException("库位对应仓库不对");
            }

            /*if (taskHeaderService.getUncompleteTaskInNear(desLocation) > 0) {

                throw new ServiceException("目标库位：" + desLocation + "旁边存在任务，请完成任务以后再分配");

            }*/

        }
    }

    /**
     * 自动生成容器编码

     *

     * @return 容器编码
     */
    @Transactional

    public String createContainer() {

        String code = MessageFormat.format("{0}{1}",
                "LS",
                String.format("%d", Calendar.getInstance().getTimeInMillis()));
        Container container = new Container();
        container.setCode(code);
        container.setWarehouseCode(ShiroUtils.getWarehouseCode());
        container.setCompanyCode(ShiroUtils.getCompanyCodeList().get(0));
        container.setContainerType("LS");
        container.setCreatedBy(ShiroUtils.getLoginName());
        container.setLastUpdated(new Date());
        container.setLastUpdatedBy(ShiroUtils.getLoginName());
        container.setEnable(true);
        container.setStatus(QuantityConstant.STATUS_CONTAINER_EMPTY);

        if (!containerService.save(container)) {

            throw new ServiceException("新增容器失败");
        }
        return code;
    }

    /**
     * 完成入库任务

     *

     * @param task 任务
     * @return AjaxResult 完成入库任务结果

     */
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult completeReceiptTask(TaskHeader task) {

        /* 判断任务状态*/
        if (task.getStatus().equals(QuantityConstant.TASK_STATUS_COMPLETED)) {
            return AjaxResult.error("任务已完成");

        }

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

        String warehouseCode = task.getWarehouseCode();

        BigDecimal totalQty = BigDecimal.ZERO;
        List<TaskDetail> taskDetailList = taskDetailService.findByTaskId(task.getId());
        if (taskDetailList.isEmpty()) {
            throw new ServiceException("任务明细为空");
        }

        InventoryHeader inventoryHeader = null;

        //补充入库把原来库存详情库位换成最新的库位

        inventoryHeader = checkSUPPLEMENTRECEIPT(task, inventoryHeader, warehouseCode);

        if (StringUtils.isNull(inventoryHeader)) {

            inventoryHeader = inventoryHeaderService.getByContainerLocation(task.getToLocation(), task.getContainerCode(), warehouseCode);

        }

        /* 如果库存 头明细不存在则新增库存头表记录*/
        if (StringUtils.isNull(inventoryHeader)) {

            inventoryHeader = this.saveInventeryByTask(task, warehouseCode);

        }
        if (StringUtils.isNull(inventoryHeader)) {
            throw new ServiceException("库存添加失败");

        }

        /* 遍历任务明细，修改关联的入库组盘、入库单状态、添加库存*/

        TaskReceiptCompleteDomain taskReceiptCompleteDomain = new TaskReceiptCompleteDomain();

        taskReceiptCompleteDomain.setTotalQty(inventoryHeader.getTotalQty());
        taskReceiptCompleteDomain.setInventoryHeader(inventoryHeader);

        List<ReceiptContainerDetail> receiptContainerDetails = new ArrayList<>();
        List<ReceiptDetail> receiptDetails = new ArrayList<>();
        List<TaskDetail> taskDetails = new ArrayList<>();
        Set<Integer> receiptHeaderIdSet = new HashSet<>();

        for (TaskDetail taskDetail : taskDetailList) {
            if (taskDetail.getStatus() < QuantityConstant.TASK_STATUS_COMPLETED) {

//                totalQty = totalQty.add(taskDetail.getQty());

                /*查询入库单明细*/
                ReceiptDetail receiptDetail = receiptDetailService.getById(taskDetail.getBillDetailId());
                if (StringUtils.isNotNull(receiptDetail)) {

                    taskReceiptCompleteDomain = this.addInventoryDetail(taskDetail, receiptDetail, inventoryHeader, taskReceiptCompleteDomain);

                    //修改组盘表状态为完成
                    ReceiptContainerDetail receiptContainerDetail = new ReceiptContainerDetail();

                    receiptContainerDetail.setId(taskDetail.getAllocationId());

                    receiptContainerDetail.setStatus(QuantityConstant.RECEIPT_CONTAINER_FINISHED);

                    receiptContainerDetail.setLastUpdatedBy(receiptDetail.getCreatedBy());

                    receiptContainerDetails.add(receiptContainerDetail);

                } else {
                    throw new ServiceException("未找到id:" + taskDetail.getBillDetailId() + "入库单明细");

                }

                receiptDetail.setProcessStamp(String.valueOf(QuantityConstant.RECEIPT_HEADER_POSTING));

                if (StringUtils.isNull(receiptDetail.getBackQty())) {

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

                } else {

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

                receiptDetails.add(receiptDetail);
//                receiptDetailService.updateById(receiptDetail);
                receiptHeaderIdSet.add(receiptDetail.getReceiptId());
//                receiptDetailService.updateReceiptHeaderLastStatus(receiptDetail.getReceiptId());

                materialWarningService.materialWarning(taskDetail.getMaterialCode(), taskDetail.getCompanyCode(), task.getWarehouseCode());

                taskDetail.setStatus(QuantityConstant.TASK_STATUS_COMPLETED);

                taskDetails.add(taskDetail);
//                taskDetailService.updateById(taskDetail);

            }

        }

        taskReceiptCompleteDomain.setReceiptDetailList(receiptDetails);
        taskReceiptCompleteDomain.setTaskDetailList(taskDetails);
        taskReceiptCompleteDomain.setReceiptHeaderIdSet(receiptHeaderIdSet);
        taskReceiptCompleteDomain.setReceiptContainerDetailList(receiptContainerDetails);
        //save批量提交数据
        saveOrUpdateTaskCompleteTable(taskReceiptCompleteDomain);

        //修改库位状态和对应的容器

        locationService.updateContainerCodeAndStatus(task.getToLocation(), task.getContainerCode(), QuantityConstant.STATUS_LOCATION_EMPTY, warehouseCode);

        //修改任务主表状态，因为立库任务表单头只对应一个货箱，表单详情的任务会同时完成
        task.setStatus(QuantityConstant.TASK_STATUS_COMPLETED);

        task.setCompleteStatus(1);

        LambdaUpdateWrapper<TaskHeader> taskHeaderLambdaUpdateWrapper = Wrappers.lambdaUpdate();
        taskHeaderLambdaUpdateWrapper.eq(TaskHeader::getId, task.getId());

        if (!taskHeaderService.update(task, taskHeaderLambdaUpdateWrapper)) {

            throw new ServiceException("更新任务主表失败");
        }

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

        container.setLocationCode(task.getToLocation());

        container.setStatus(QuantityConstant.STATUS_CONTAINER_SOME);

        LambdaUpdateWrapper<Container> containerLambdaUpdateWrapper = Wrappers.lambdaUpdate();
        containerLambdaUpdateWrapper.eq(Container::getCode, task.getContainerCode());

        containerLambdaUpdateWrapper.eq(Container::getWarehouseCode, task.getWarehouseCode());

        if (!containerService.update(container, containerLambdaUpdateWrapper)) {
            throw new ServiceException("更新容器失败");
        }

        //修改入库组盘头表状态
        ReceiptContainerHeader receiptContainerHeader = new ReceiptContainerHeader();
        receiptContainerHeader.setId(task.getAllocationHeadId());

        receiptContainerHeader.setLastUpdatedBy(task.getCreatedBy());

        receiptContainerHeader.setStatus(QuantityConstant.RECEIPT_CONTAINER_FINISHED);

        if (!receiptContainerHeaderService.updateById(receiptContainerHeader)) {
            throw new ServiceException("更新入库组盘头表状态失败");
        }

        return AjaxResult.success();

    }

    public InventoryHeader checkSUPPLEMENTRECEIPT(TaskHeader task, InventoryHeader inventoryHeader, String warehouseCode) {
        if (task.getTaskType().equals(QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT)) {

            LambdaQueryWrapper<InventoryHeader> lambdaQueryWrapper = Wrappers.lambdaQuery();
            lambdaQueryWrapper.eq(InventoryHeader::getWarehouseCode, warehouseCode)
                    .eq(InventoryHeader::getLocationCode, task.getFromLocation())
                    .eq(InventoryHeader::getContainerCode, task.getContainerCode());
            lambdaQueryWrapper.last("limit 1");

            inventoryHeader = inventoryHeaderService.getOne(lambdaQueryWrapper);
            if (inventoryHeader != null) {

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

//                location.setContainerCode("");
//                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());
                        inventoryDetail.setZoneCode(location.getZoneCode());
                        inventoryDetailService.updateById(inventoryDetail);
                    }
                }
            }
        }
        return inventoryHeader;
    }

    /**
     * 添加库存明细与库存交易记录

     *
     * @param taskDetail      任务明细
     * @param receiptDetail   入库单明细

     * @param inventoryHeader 库存头表

     * @return 任务数量

     */

    private TaskReceiptCompleteDomain addInventoryDetail(TaskDetail taskDetail, ReceiptDetail receiptDetail,

                                                         InventoryHeader inventoryHeader, TaskReceiptCompleteDomain taskReceiptCompleteDomain) {

        List<InventoryDetail> inventoryDetailList = taskReceiptCompleteDomain.getInventoryDetailList();
        List<InventoryTransaction> inventoryTransactionList = taskReceiptCompleteDomain.getInventoryTransactionList();

        String warehouseCode = inventoryHeader.getWarehouseCode();

        /*该入库明细是否已存在库存明细记录，已存在更新数量、不存在新增记录*/

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

        inventory.eq(InventoryDetail::getContainerCode, inventoryHeader.getContainerCode())
                .eq(InventoryDetail::getWarehouseCode, warehouseCode)

                .eq(InventoryDetail::getLocationCode, inventoryHeader.getLocationCode())
                .eq(InventoryDetail::getMaterialCode, taskDetail.getMaterialCode())
                .eq(InventoryDetail::getCompanyCode, taskDetail.getCompanyCode())

                .eq(InventoryDetail::getBatch, taskDetail.getBatch())

                .eq(InventoryDetail::getReceiptDetailId, taskDetail.getBillDetailId());
        InventoryDetail inventoryDetail = inventoryDetailService.getOne(inventory);

        Material material = materialService.getMaterialByCode(receiptDetail.getMaterialCode(), warehouseCode);

        /*单位换算*/
        BigDecimal receiptQty = taskDetail.getQty();
        if (StringUtils.isNotEmpty(receiptDetail.getMaterialUnit()) &&
                StringUtils.isNotEmpty(material.getUnit()) &&
                !receiptDetail.getMaterialUnit().equals(material.getUnit())) {
            LambdaQueryWrapper<MaterialMultiple> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper.eq(MaterialMultiple::getMaterialCode, receiptDetail.getMaterialCode())
                    .eq(MaterialMultiple::getUnitId1, receiptDetail.getMaterialUnit())
                    .eq(MaterialMultiple::getUnitId2, material.getUnit());
            MaterialMultiple materialMultiple = materialMultipleService.getOne(queryWrapper);
            if (StringUtils.isNull(materialMultiple)) {
                throw new ServiceException("入库单单位与物料绑定主单位不一致且单位换算不存在");
            } else {
                receiptQty = receiptQty.multiply(materialMultiple.getMultiple());
            }
        }

        if (StringUtils.isNotNull(inventoryDetail)) {
            inventoryDetail.setQty(inventoryDetail.getQty().add(taskDetail.getQty()));

        } else {

//            ReceiptHeader receiptHeader = receiptHeaderService.getById(receiptDetail.getReceiptId());

            inventoryDetail = new InventoryDetail();
            inventoryDetail.setInventoryHeaderId(inventoryHeader.getId());
            inventoryDetail.setWarehouseCode(taskDetail.getWarehouseCode());

            ReceiptHeader receiptHeader = receiptHeaderService.getById(receiptDetail.getReceiptId());

            inventoryDetail.setUWarehouseCode(receiptHeader.getUWarehouseCode());

//            inventoryDetail.

            inventoryDetail.setZoneCode(inventoryHeader.getZoneCode());

            inventoryDetail.setCompanyCode(taskDetail.getCompanyCode());
            inventoryDetail.setLocationCode(taskDetail.getToLocation());
            inventoryDetail.setContainerCode(taskDetail.getContainerCode());
            inventoryDetail.setMaterialCode(taskDetail.getMaterialCode());
            inventoryDetail.setMaterialName(taskDetail.getMaterialName());
            inventoryDetail.setMaterialSpec(taskDetail.getMaterialSpec());

            inventoryDetail.setMaterialUnit(material.getUnit());
            inventoryDetail.setQty(receiptQty);

            inventoryDetail.setTaskQty(new BigDecimal(0));

            inventoryDetail.setInventorySts(QuantityConstant.GOOD);

            inventoryDetail.setSupplierCode(receiptDetail.getSupplierCode());

            inventoryDetail.setReferCode(receiptHeader.getReferCode());

            inventoryDetail.setReferDetailId(receiptDetail.getReferLineNum());
            inventoryDetail.setBatch(receiptDetail.getBatch());
            inventoryDetail.setLot(receiptDetail.getLot());

            inventoryDetail.setProjectNo(receiptDetail.getProjectNo());
            inventoryDetail.setMoCode(receiptDetail.getMoCode());

            inventoryDetail.setGoodsShelfNo(taskDetail.getGoodsShelfNo());

            if (taskDetail.getWarehouseCode().equals("KS0001")) {
                Container container = containerService.getContainerByCode(taskDetail.getContainerCode(), taskDetail.getWarehouseCode());

                inventoryDetail.setUWarehouseCode(container.getUWarehouseCode());

            } else {

                inventoryDetail.setUWarehouseCode(receiptDetail.getUWarehouseCode());
            }

            inventoryDetail.setManufactureDate(receiptDetail.getManufactureDate());
            inventoryDetail.setExpirationDate(receiptDetail.getExpirationDate());
            inventoryDetail.setAgingDate(receiptDetail.getAgingDate());
            inventoryDetail.setAttribute1(receiptDetail.getAttribute1());
            inventoryDetail.setAttribute2(receiptDetail.getAttribute2());
            inventoryDetail.setAttribute3(receiptDetail.getAttribute3());

            inventoryDetail.setReceiptCode(receiptDetail.getReceiptCode());

            inventoryDetail.setReceiptDetailId(receiptDetail.getId());

            inventoryHeader.setTotalLines(inventoryHeader.getTotalLines() + 1);

        }
        if (!inventoryDetailService.saveOrUpdate(inventoryDetail)) {
            throw new ServiceException("保存库存明细失败");

        }

//        inventoryHeader.setTotalQty(inventoryHeader.getTotalQty().add(taskDetail.getQty()));
//        inventoryHeaderService.updateById(inventoryHeader);

        //记录库存交易记录
        InventoryTransaction inventoryTransaction = new InventoryTransaction();
        inventoryTransaction.setTransactionType(QuantityConstant.INVENTORY_TRANSACTION_RECEIPT);
        inventoryTransaction.setWarehouseCode(taskDetail.getWarehouseCode());
        inventoryTransaction.setCompanyCode(taskDetail.getCompanyCode());
        inventoryTransaction.setLocationCode(inventoryHeader.getLocationCode());
        inventoryTransaction.setContainerCode(inventoryHeader.getContainerCode());
        inventoryTransaction.setMaterialCode(taskDetail.getMaterialCode());
        inventoryTransaction.setMaterialName(taskDetail.getMaterialName());
        inventoryTransaction.setMaterialSpec(taskDetail.getMaterialSpec());

        inventoryTransaction.setMaterialUnit(material.getUnit());

        inventoryTransaction.setBillCode(taskDetail.getBillCode());
        inventoryTransaction.setBillDetailId(taskDetail.getBillDetailId());
        inventoryTransaction.setBatch(receiptDetail.getBatch());
        inventoryTransaction.setLot(receiptDetail.getLot());
        inventoryTransaction.setInventorySts(receiptDetail.getInventorySts());

        inventoryTransaction.setTaskQty(receiptQty);

        inventoryTransaction.setInventoryDetailId(inventoryDetail.getId());

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

        inventoryTransaction.setReferCode(taskDetail.getReferenceCode());

        inventoryDetailList.add(inventoryDetail);
        inventoryTransactionList.add(inventoryTransaction);
        taskReceiptCompleteDomain.setInventoryDetailList(inventoryDetailList);
        taskReceiptCompleteDomain.setInventoryTransactionList(inventoryTransactionList);
        taskReceiptCompleteDomain.setTotalQty(taskReceiptCompleteDomain.getTotalQty().add(taskDetail.getQty()));

        return taskReceiptCompleteDomain;
    }

    /**
     * 根据保存库存

     *

     * @param task
     * @param warehouseCode
     * @return
     */

    public InventoryHeader saveInventeryByTask(TaskHeader task, String warehouseCode) {

        InventoryHeader inventoryHeader = new InventoryHeader();

        inventoryHeader.setWarehouseCode(warehouseCode);
        inventoryHeader.setLocationCode(task.getToLocation());
        Location location = locationService.getLocationByCode(task.getToLocation(), warehouseCode);
        inventoryHeader.setZoneCode(location.getZoneCode());
        inventoryHeader.setTotalWeight(task.getWeight());
        inventoryHeader.setContainerCode(task.getContainerCode());
        inventoryHeader.setContainerStatus(QuantityConstant.STATUS_CONTAINER_SOME);
        inventoryHeader.setTotalQty(new BigDecimal(0));
        inventoryHeader.setTotalLines(0);
        inventoryHeader.setLocking(1);
        inventoryHeader.setEnable(1);
        inventoryHeader.setCompanyCode(task.getCompanyCode());
        inventoryHeader.setCreated(new Date());
        inventoryHeader.setCreatedBy("");
        inventoryHeader.setLastUpdated(new Date());
        inventoryHeader.setLastUpdatedBy("");
        if (!inventoryHeaderService.save(inventoryHeader)) {
            throw new ServiceException("添加库存单失败");
        }

        return inventoryHeader;

    }

    public void saveOrUpdateTaskCompleteTable(TaskReceiptCompleteDomain taskReceiptCompleteDomain) {
        List<InventoryTransaction> inventoryTransactionList = taskReceiptCompleteDomain.getInventoryTransactionList();
        List<InventoryDetail> inventoryDetailList = taskReceiptCompleteDomain.getInventoryDetailList();
        List<ReceiptDetail> receiptDetailList = taskReceiptCompleteDomain.getReceiptDetailList();
        List<TaskDetail> taskDetails = taskReceiptCompleteDomain.getTaskDetailList();
        List<ReceiptContainerDetail> receiptContainerDetailList = taskReceiptCompleteDomain.getReceiptContainerDetailList();
        InventoryHeader inventoryHeader = taskReceiptCompleteDomain.getInventoryHeader();
        Set<Integer> receiptHeaderIdSet = taskReceiptCompleteDomain.getReceiptHeaderIdSet();
        BigDecimal totalQty = taskReceiptCompleteDomain.getTotalQty();

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

            inventoryDetailService.saveOrUpdateBatch(inventoryDetailList);
        }
        inventoryHeader.setTotalQty(totalQty);
        inventoryHeaderService.saveOrUpdate(inventoryHeader);

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

            inventoryTransactionService.saveBatch(inventoryTransactionList);
        }

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

            receiptDetailService.updateBatchById(receiptDetailList);
        }

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

            taskDetailService.updateBatchById(taskDetails);
        }

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

            receiptContainerDetailService.updateBatchById(receiptContainerDetailList);

        }

        receiptDetailService.updateReceiptHeaderLastStatusV2(receiptHeaderIdSet);

    }
}