wms / wms_changshushengyi · Files

package com.huaheng.api.general.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.huaheng.api.general.domain.ReceiptDomain;
import com.huaheng.common.constant.QuantityConstant;
import com.huaheng.common.exception.service.ServiceException;
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.config.material.domain.Material;
import com.huaheng.pc.config.material.service.MaterialService;

import com.huaheng.pc.inventory.inventoryDetail.service.InventoryDetailService;

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.domain.ReceiptContainerView;
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.service.TaskHeaderService;

import org.springframework.beans.factory.annotation.Autowired;

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

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

@Component
@Transactional
public class ReceiptContainerApiService {
    @Resource
    private ReceiptHeaderService receiptHeaderService;
    @Resource
    private ReceiptDetailService receiptDetailService;
    @Resource
    private ContainerService containerService;
    @Resource
    private TaskHeaderService taskHeaderService;
    @Resource
    private TaskDetailService taskDetailService;
    @Resource
    private MaterialService materialService;
    @Resource
    private ReceiptContainerHeaderService receiptContainerHeaderService;
    @Resource
    private ReceiptContainerDetailService receiptContainerDetailService;
    @Resource
    private LocationService locationService;

    @Autowired
    private InventoryDetailService inventoryDetailService;

    /**
     * 入库组盘，生成任务
     *
     * @param receiptDomain 入库组盘
     * @return 是否下发成功
     */
    @Transactional(rollbackFor = Exception.class)

    public AjaxResult saveReceiptContainer(ReceiptDomain receiptDomain) {

        String companyCode = receiptDomain.getReceiptHeader().getCompanyCode();

        ReceiptHeader receiptHeaders = receiptDomain.getReceiptHeader();
        List<ReceiptDetail> details = receiptDomain.getReceiptDetails();
        int taskId = 0;

        if (receiptHeaders == null || details == null) {
            return AjaxResult.error("入库主单或入库子单为空");
        }

        if (StringUtils.isEmpty(receiptHeaders.getZoneCode())) {

            return AjaxResult.error("库区为空");
        }

        String zoneCode = receiptHeaders.getZoneCode();

        String containerCode = receiptHeaders.getContainerCode();
        String locationCode = receiptHeaders.getLocationCode();

        if (StringUtils.isEmpty(containerCode)) {

            return AjaxResult.error("容器为空");
        }
        LambdaQueryWrapper<Container> containerQueryWrapper = Wrappers.lambdaQuery();
        containerQueryWrapper.eq(Container::getCode, containerCode);
        Container container = containerService.getOne(containerQueryWrapper);

        if (container == null) {

            return AjaxResult.error("不存在这个托盘");
        }
        //保存入库信息和组盘信息和任务信息
        ReceiptContainerView record = new ReceiptContainerView();

        record.setContainerCode(containerCode);

        record.setLocationCode(locationCode);

        record.setTaskType((short) 100);

        record.setCompanyCode(details.get(0).getCompanyCode());
        receiptContainerHeaderService.checkContainer(record);

        if (locationCode != null) {

            receiptContainerHeaderService.mobileCheckLocationCode(record);
        }
        // 保存ReceiptHeader，没有则生成，有则返回id

        int receiptHeaderId = receiptHeaderService.createHeader(companyCode, receiptHeaders.getZoneCode());

        ReceiptHeader receiptHeader = receiptHeaderService.getById(receiptHeaderId);
        // 保存ReceiptDetail

        List<Integer> receiptDetailIds = insertReceiptDetail(receiptHeaderId, details, companyCode);
        if (receiptDetailIds != null && receiptDetailIds.size() > 0) {

            //保存ReceiptContainerHeader

            ReceiptContainerHeader containerHeader = insertReceiptContainerHeader(details.get(0), container, locationCode, zoneCode);
            if (containerHeader != null && containerHeader.getId() > 0) {

                // 保存ReceiptcContainerDetail

                List<Integer> receiptContainerDetailIds = insertReceiptcContainerDetail(containerHeader.getId(), receiptHeaderId, receiptDetailIds, details, container);
                if (receiptContainerDetailIds != null && receiptContainerDetailIds.size() > 0) {

                    //保存任务task

                    taskId = saveTaskHeader(container, containerHeader);

                } else {
                    return AjaxResult.error("入库组盘失败");
                }
            } else {
                return AjaxResult.error("插入入库容器表单头失败");
            }
        } else {
            return AjaxResult.error("插入入库明细表单失败");
        }
        return AjaxResult.success().setData(taskId);
    }

    /**
     * 保存ReceiptDetail

     *

     * @return
     */

    public List<Integer> insertReceiptDetail(int headerId, List<ReceiptDetail> receiptDetails, String companyCode) {

        List<Integer> mReceiptDetailIds = new ArrayList<>();
        ReceiptHeader receiptHeader = receiptHeaderService.getById(headerId);

        for (ReceiptDetail receiptBill : receiptDetails) {

            ReceiptDetail receiptDetail = receiptBill;
            receiptDetail.setId(null);

            receiptDetail.setWarehouseCode(ShiroUtils.getWarehouseCode());

            receiptDetail.setCompanyCode(companyCode);
            receiptDetail.setReceiptId(receiptHeader.getId());
            receiptDetail.setReceiptCode(receiptHeader.getCode());

            receiptDetail.setInventorySts(receiptDetail.getInventorySts() == null ? QuantityConstant.GOOD : receiptDetail.getInventorySts());

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

                    receiptHeader.getWarehouseCode());
            receiptDetail.setMaterialName(material.getName());
            receiptDetail.setMaterialSpec(material.getSpec());
            receiptDetail.setMaterialUnit(material.getUnit());
            receiptDetail.setAbcClass(material.getAbcClass());
            receiptDetail.setMaterialType(material.getMaterialType());

            if (StringUtils.isNotEmpty(receiptDetail.getRollNumber())) {
                boolean tag = inventoryDetailService.isRollNumber(null, receiptDetail);
                if (tag) {
//                卷号已存在
                    throw new ServiceException(receiptDetail.getRollNumber() + "卷号已存在");

                }
            }

            receiptDetail.setInventorySts(QuantityConstant.GOOD);

            receiptDetail.setQty(receiptBill.getQty());

            receiptDetail.setTaskQty(receiptBill.getQty());

            receiptDetail.setCreatedBy(QuantityConstant.LOGINNAME);
            receiptDetail.setLastUpdatedBy(QuantityConstant.LOGINNAME);
            receiptDetail.setDeleted(false);

            receiptDetailService.save(receiptDetail);
            mReceiptDetailIds.add(receiptDetail.getId());
        }
        return mReceiptDetailIds;
    }

    /**
     * ReceiptContainerHeader

     *

     * @return
     */

    public ReceiptContainerHeader insertReceiptContainerHeader(ReceiptDetail receiptDetail, Container container, String locationCode, String zoneCode) {

        String receiptContainerCode = container.getCode();
        String companyCode = receiptDetail.getCompanyCode();
        ReceiptContainerHeader recorder = new ReceiptContainerHeader();
        recorder.setContainerCode(receiptContainerCode);
        recorder.setToLocation(locationCode);

        recorder.setWarehouseCode(ShiroUtils.getWarehouseCode());

        recorder.setCompanyCode(companyCode);
        //如果该容器已绑定库位，则补充入库TASK_TYPE_SUPPLEMENTRECEIPT，否则整盘入库TASK_TYPE_WHOLERECEIPT

        if (StringUtils.isEmpty(container.getLocationCode())) {

            recorder.setTaskType(QuantityConstant.TASK_TYPE_WHOLERECEIPT);

        } else {

            recorder.setTaskType(QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT);

            recorder.setFromLocation(container.getLocationCode());

        }
        recorder.setStatus(QuantityConstant.RECEIPT_CONTAINER_BUILD);
        recorder.setCreatedBy(QuantityConstant.LOGINNAME);
        recorder.setLastUpdatedBy(QuantityConstant.LOGINNAME);
        recorder.setZoneCode(zoneCode);

        LambdaQueryWrapper<ReceiptContainerHeader> receiptContainerHeaderLambada = Wrappers.lambdaQuery();
        receiptContainerHeaderLambada.eq(ReceiptContainerHeader::getContainerCode, receiptContainerCode)
                .eq(ReceiptContainerHeader::getCompanyCode, companyCode)
                .eq(ReceiptContainerHeader::getTaskType, String.valueOf(QuantityConstant.TASK_TYPE_WHOLERECEIPT))
                .eq(ReceiptContainerHeader::getStatus, 0);

        ReceiptContainerHeader receiptContainerHeader = receiptContainerHeaderService.getOne(receiptContainerHeaderLambada);

        if (receiptContainerHeader == null) {

            receiptContainerHeaderService.save(recorder);
        } else {
            return recorder;
        }

        locationService.updateStatus(locationCode, QuantityConstant.STATUS_LOCATION_LOCK);
        containerService.updateLocationCodeAndStatus(receiptContainerCode,
                locationCode, QuantityConstant.STATUS_CONTAINER_SOME);
        return recorder;
    }

    /**
     * ReceiptcContainerDetail

     *

     * @return
     */
    public List<Integer> insertReceiptcContainerDetail(int headerId, int receiptId,

                                                       List<Integer> receiptDetailId, List<ReceiptDetail> receiptDetails,
                                                       Container container) {

        List<Integer> mReceiptContainerIds = new ArrayList<>();

        ReceiptHeader receiptHeader = receiptHeaderService.getById(receiptId);

        if (receiptHeader == null) {

            throw new ServiceException("没有找到入库单表头！");
        }

        for (int i = 0; i < receiptDetails.size(); i++) {

            ReceiptDetail receiptDetail = receiptDetails.get(i);
            Material condition2 = new Material();
            condition2.setCode(receiptDetail.getMaterialCode());

            condition2.setWarehouseCode(ShiroUtils.getWarehouseCode());

            condition2.setDeleted(false);
            condition2.setEnable(true);
            LambdaQueryWrapper<Material> lambdaQueryWrapper = Wrappers.lambdaQuery();
            lambdaQueryWrapper.eq(Material::getCode, receiptDetail.getMaterialCode())

                    .eq(Material::getWarehouseCode, ShiroUtils.getWarehouseCode());

            Material material = materialService.getOne(lambdaQueryWrapper);
            ReceiptContainerDetail record = new ReceiptContainerDetail();

            record.setWarehouseCode(ShiroUtils.getWarehouseCode());
            record.setCompanyCode(ShiroUtils.getCompanyCodeList().get(0));

            record.setReceiptContainerId(headerId);
            record.setRollNumber(receiptDetail.getRollNumber());
            record.setReceiptCode(receiptHeader.getCode());
            record.setReceiptId(receiptId);
            record.setReceiptDetailId(receiptDetailId.get(i));
            record.setMaterialCode(receiptDetail.getMaterialCode());
            record.setMaterialName(material.getName());
            record.setMaterialUnit(material.getUnit());
            record.setMaterialSpec(material.getSpec());

            record.setQty(receiptDetail.getQty());

            record.setContainerCode(container.getCode());
            record.setTaskType(QuantityConstant.TASK_TYPE_WHOLERECEIPT);
            record.setContainerType(container.getContainerType());
            record.setInventorySts(receiptDetail.getInventorySts());
            record.setLot(receiptDetail.getLot());
            record.setBatch(receiptDetail.getBatch());

            record.setContainerDetailNumber(receiptDetail.getContainerDetailNumber());

            record.setRollNumber(receiptDetail.getRollNumber());
            record.setCreatedBy(QuantityConstant.LOGINNAME);
            record.setLastUpdatedBy(QuantityConstant.LOGINNAME);

            LambdaQueryWrapper<ReceiptContainerDetail> detailyWrapper = Wrappers.lambdaQuery();
            detailyWrapper.eq(ReceiptContainerDetail::getReceiptContainerId, headerId)
                    .eq(ReceiptContainerDetail::getReceiptCode, receiptHeader.getCode())
                    .eq(ReceiptContainerDetail::getRollNumber, receiptDetail.getRollNumber());
            ReceiptContainerDetail receiptContainerDetail = receiptContainerDetailService.getOne(detailyWrapper);

            if (receiptContainerDetail == null) {

                receiptContainerDetailService.save(record);
                mReceiptContainerIds.add(record.getId());
            } else {
                mReceiptContainerIds.add(receiptContainerDetail.getId());
            }
        }
        return mReceiptContainerIds;
    }

    /**
     * 生成任务

     *

     * @param container
     * @param receiptContainerHeader
     * @return
     */

    public int saveTaskHeader(Container container, ReceiptContainerHeader receiptContainerHeader) {
        int taskId = 0;

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

        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 + "旁边存在任务，请完成任务以后再分配");
            }
        }
        //查询入库组盘明细
        LambdaQueryWrapper<ReceiptContainerDetail> containerDetailLambda = Wrappers.lambdaQuery();
        containerDetailLambda.eq(ReceiptContainerDetail::getReceiptContainerId, receiptContainerHeader.getId());
        List<ReceiptContainerDetail> list = receiptContainerDetailService.list(containerDetailLambda);

        if (list.isEmpty()) {
            throw new ServiceException("没有组盘明细，请先组盘！");
        }
        if (receiptContainerHeader.getStatus() == QuantityConstant.RECEIPT_CONTAINER_BUILD.intValue()) {
            if (receiptContainerHeader.getStatus() < QuantityConstant.RECEIPT_CONTAINER_TASK) {
                receiptContainerHeader.setStatus(QuantityConstant.RECEIPT_CONTAINER_TASK);
                receiptContainerHeaderService.updateById(receiptContainerHeader);
            }
            //添加任务主表
            TaskHeader task = new TaskHeader();
            task.setAllocationHeadId(receiptContainerHeader.getId());
            task.setInternalTaskType(QuantityConstant.TASK_INTENERTYPE_RECEIPT);
            task.setWarehouseCode(receiptContainerHeader.getWarehouseCode());
            task.setZoneCode(receiptContainerHeader.getZoneCode());
            task.setCompanyCode(receiptContainerHeader.getCompanyCode());
            task.setStatus(QuantityConstant.TASK_STATUS_BUILD);
            task.setTaskType(receiptContainerHeader.getTaskType());
            task.setFromLocation(receiptContainerHeader.getFromLocation());

            if (receiptContainerHeader.getToLocation() != null) {

                task.setToLocation(receiptContainerHeader.getToLocation());
            }
            Location location = locationService.getLocationByCode(

                    task.getToLocation(), ShiroUtils.getWarehouseCode());

            if (location != null) {

                task.setZoneCode(location.getZoneCode());
            }
            task.setContainerCode(receiptContainerHeader.getContainerCode());
            task.setRecvDock(receiptContainerHeader.getRecvDock());
            task.setPort(receiptContainerHeader.getPort());
            task.setCreatedBy(QuantityConstant.LOGINNAME);
            task.setLastUpdatedBy(QuantityConstant.LOGINNAME);
            if (taskHeaderService.save(task)) {
                taskId = task.getId();
                //TaskDetail

                saveTaskDetail(task, list);

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

    public void saveTaskDetail(TaskHeader task, List<ReceiptContainerDetail> list) {

        //添加任务明细表
        for (ReceiptContainerDetail item : list) {
            TaskDetail taskDetail = new TaskDetail();
            taskDetail.setTaskId(task.getId());
            taskDetail.setTaskType(task.getTaskType());
            taskDetail.setInternalTaskType(QuantityConstant.TASK_INTENERTYPE_RECEIPT);
            taskDetail.setWarehouseCode(task.getWarehouseCode());
            taskDetail.setAllocationId(item.getId());
            taskDetail.setCompanyCode(task.getCompanyCode());
            taskDetail.setMaterialCode(item.getMaterialCode());
            taskDetail.setMaterialName(item.getMaterialName());
            taskDetail.setMaterialSpec(item.getMaterialSpec());
            taskDetail.setMaterialUnit(item.getMaterialUnit());
            taskDetail.setInventorySts(item.getInventorySts());
            taskDetail.setRollNumber(item.getRollNumber());

            taskDetail.setContainerDetailNumber(item.getContainerDetailNumber());

            taskDetail.setBillCode(item.getReceiptCode());
            taskDetail.setBillDetailId(item.getReceiptDetailId());
            taskDetail.setQty(item.getQty());
            taskDetail.setContainerCode(task.getContainerCode());
            taskDetail.setFromLocation(task.getFromLocation());

            if (task.getToLocation() != null) {

                taskDetail.setToLocation(task.getToLocation());
            }
            taskDetail.setBatch(item.getBatch());
            taskDetail.setProjectNo(item.getProjectNo());
            taskDetail.setCreatedBy(QuantityConstant.LOGINNAME);
            taskDetail.setLastUpdatedBy(QuantityConstant.LOGINNAME);
            if (!taskDetailService.save(taskDetail)) {
                throw new ServiceException("生成任务明细失败");
            }

            //更新入库组盘明细状态
            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());
        }
    }

}