wms / wms_changshushengyi · Files

package com.huaheng.pc.sap.service;

import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

import javax.annotation.Resource;

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

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.huaheng.api.sap.domain.ZarDomain;
import com.huaheng.api.sap.service.ZarApiService;
import com.huaheng.common.constant.QuantityConstant;
import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.common.utils.bean.BeanUtils;
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.station.service.StationService;
import com.huaheng.pc.config.zone.service.ZoneService;
import com.huaheng.pc.monitor.apilog.domain.ApiLog;
import com.huaheng.pc.monitor.apilog.service.IApiLogService;
import com.huaheng.pc.receipt.receiptContainerHeader.service.ReceiptContainerHeaderService;
import com.huaheng.pc.receipt.receiptHeader.domain.ReceiptHeader;
import com.huaheng.pc.receipt.receiptHeader.service.ReceiptHeaderService;
import com.huaheng.pc.sap.domain.Zarsh;
import com.huaheng.pc.sap.domain.Zarsi;
import com.huaheng.pc.sap.mapper.ZarshMapper;
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.shipmentHeader.domain.ShipmentHeader;
import com.huaheng.pc.shipment.shipmentHeader.service.ShipmentHeaderService;
import com.huaheng.pc.task.taskDetail.domain.TaskDetail;
import com.huaheng.pc.task.taskHeader.domain.TaskHeader;
import com.huaheng.pc.task.taskHeader.service.TaskHeaderService;
import com.huaheng.pc.task.taskHeader.service.WorkTaskEmptyContainerService;
import com.huaheng.pc.task.taskHeader.service.WorkTaskService;

import io.jsonwebtoken.lang.Assert;

/**
 * Created by Enzo Cotter on 2022/5/11.
 * @author zhouhong
 */
@Service
public class ZarshService extends ServiceImpl<ZarshMapper, Zarsh> {
    @Resource
    private ZarsiService zarsiService;
    @Resource
    private ReceiptContainerHeaderService receiptContainerHeaderService;
    @Resource
    private ShipmentContainerHeaderService shipmentContainerHeaderService;
    @Resource
    private ReceiptHeaderService receiptHeaderService;
    @Resource
    private ShipmentContainerDetailService shipmentContainerDetailService;
    @Resource
    private ShipmentHeaderService shipmentHeaderService;
    @Resource
    private TaskHeaderService taskHeaderService;
    @Resource
    private ContainerService containerService;
    @Resource
    private LocationService locationService;
    @Resource
    private IApiLogService apiLogService;
    @Resource
    private BackSapStatusService backSapStatusService;
    @Resource
    private ZoneService zoneService;
    @Resource
    private StationService stationService;
    @Resource
    private WorkTaskService workTaskService;
    @Resource
    private WorkTaskEmptyContainerService workTaskEmptyContainerService;
    @Resource
    private ZarshService zarshService;
    @Resource
    private ZarApiService zarApiService;

    public Zarsh checkZarshByUniqueId(String uniqueId) {
        LambdaQueryWrapper<Zarsh> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(Zarsh::getUniqueId, uniqueId);
        lambdaQueryWrapper.last("limit 1");
        Zarsh zarsh = this.getOne(lambdaQueryWrapper);
        if (zarsh != null) {
            return zarsh;
        }
        return null;
    }

    public boolean saveZarsh(Zarsh zarsh) {
        Date date = new Date();
        String uniqueId = UUID.randomUUID().toString();
        zarsh.setUniqueId(uniqueId);
        zarsh.setCreated(date);
        zarsh.setCreateBy("wms");
        zarsh.setLastUpdatedBy("wms");
        zarsh.setLastUpdated(date);
        return this.save(zarsh);
    }

    public boolean editZarsh(Zarsh zarsh) {
        Date date = new Date();
        zarsh.setLastUpdatedBy("wms");
        zarsh.setLastUpdated(date);
        return this.updateById(zarsh);
    }

    public void removeByZarshId(String uniqueId, Integer id) {
        LambdaQueryWrapper<Zarsh> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(StringUtils.isNotEmpty(uniqueId), Zarsh::getUniqueId, uniqueId);
        queryWrapper.eq(StringUtils.isNotNull(id), Zarsh::getId, id);
        queryWrapper.last("limit 1");
        Zarsh zarsh = this.getOne(queryWrapper);
        if (zarsh != null) {
            LambdaQueryWrapper<Zarsi> query = Wrappers.lambdaQuery();
            query.eq(Zarsi::getUniqueId, zarsh.getUniqueId());
            List<Zarsi> list = zarsiService.list(query);
            List<Integer> ids = list.stream().map(detail -> detail.getId()).collect(Collectors.toList());
            if (ids.size() > 0){
                zarsiService.removeByIds(ids);
            }
            this.removeById(zarsh.getId());
        }

    }

    public Zarsh getZarshByUnique(String uniqueId) {
        LambdaQueryWrapper<Zarsh> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(StringUtils.isNotEmpty(uniqueId), Zarsh::getUniqueId, uniqueId);
        queryWrapper.last("limit 1");
        Zarsh zarsh = this.getOne(queryWrapper);
        return zarsh;
    }

    /**
     * 生成任务保存同步表
     * @param task
     * @param taskDetailList
     * @param container
     */
    public void saveZarshByTask(TaskHeader task, List<TaskDetail> taskDetailList, Container container) {
        Zarsh zarsh = saveZarshTask(task, taskDetailList, container);
        // 保存子表
        saveZarsiTask(taskDetailList, zarsh);
    }

    public Zarsh saveZarshTask(TaskHeader task, List<TaskDetail> taskDetailList, Container container) {
        Zarsh zarsh = new Zarsh();
        zarsh.setMandt("2");
        zarsh.setWerks("3");
        zarsh.setDrumId(task.getContainerCode());
        if (container.getContainerType().equals("D1") || container.getContainerType().equals("E1")) {
            // 片状托架
            zarsh.setPlType(1);
        } else if (container.getContainerType().equals("D2") || container.getContainerType().equals("E2") || container.getContainerType().equals("D3")
            || container.getContainerType().equals("E3")) {
            // 卷状托架
            zarsh.setPlType(0);
        } else {
            // 特殊托架
            zarsh.setPlType(2);
        }

        if (taskDetailList != null && taskDetailList.size() > 0) {
            // 有料
            zarsh.setInKind(1);
        } else {
            // 无料
            zarsh.setInKind(2);
        }
        zarsh.setInitDate(new Date());
        zarsh.setCFlag("R");
        int taskType = task.getTaskType();
        if (taskType == QuantityConstant.TASK_TYPE_WHOLERECEIPT || taskType == QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT
            || taskType == QuantityConstant.TASK_TYPE_EMPTYRECEIPT || taskType == QuantityConstant.TASK_TYPE_MANY_EMPTYRECEIPT) {
            // 入库
            zarsh.setMFlag(2);
            zarsh.setFromPos(task.getPort());
            if (StringUtils.isNotEmpty(task.getFromLocation())) {
                zarsh.setLocation(task.getFromLocation());
            } else {
                zarsh.setLocation(task.getToLocation());
            }
        } else {
            // 出库
            zarsh.setMFlag(3);
            zarsh.setToPos(task.getPort());
            if (StringUtils.isNotEmpty(task.getFromLocation())) {
                zarsh.setLocation(task.getFromLocation());
            } else {
                zarsh.setLocation(task.getToLocation());
            }
        }
        zarsh.setTaskId(task.getId());
        if (saveZarsh(zarsh)) {
            return zarsh;
        } else {
            throw new ServiceException("zarsh保存失败");
        }
    }

    public void saveZarsiTask(List<TaskDetail> taskDetailList, Zarsh zarsh) {
        List<Zarsi> zarsilist = new ArrayList<>();
        for (TaskDetail taskDetail : taskDetailList) {
            Zarsi zarsi = new Zarsi();
            BeanUtils.copyBeanProp(zarsi, zarsh);
            zarsi.setId(null);
            zarsi.setMatnr(taskDetail.getMaterialCode());
            zarsi.setVerme(taskDetail.getQty());
            // 批号
            zarsi.setCharg(taskDetail.getLot());
            // 项目号（板台上由多个位置得具体位置）
            zarsi.setPosnr(taskDetail.getContainerDetailNumber());
            zarsilist.add(zarsi);
        }
        if (zarsiService.saveBatch(zarsilist)) {
        } else {
            throw new ServiceException("zarsi保存失败");
        }
    }

    /**
     * TaskHeader task 修改状态
     * @param task
     */
    public void updateZarshByTaskComplete(TaskHeader task, String cFlag) {
        int taskType = task.getTaskType();
        String location = null;
        LambdaQueryWrapper<Zarsh> lambdaQueryWrapper = Wrappers.lambdaQuery();
        if (taskType == QuantityConstant.TASK_TYPE_WHOLERECEIPT || taskType == QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT
            || taskType == QuantityConstant.TASK_TYPE_EMPTYRECEIPT || taskType == QuantityConstant.TASK_TYPE_MANY_EMPTYRECEIPT) {
            // 入库
            location = task.getToLocation();
            lambdaQueryWrapper.eq(Zarsh::getMFlag, 2);
        } else {
            location = task.getFromLocation();
            lambdaQueryWrapper.eq(Zarsh::getMFlag, 3);
        }

        /*
         * lambdaQueryWrapper.eq(Zarsh::getDrunId, task.getContainerCode())
         * .eq(Zarsh::getLocation,location);
         */
        lambdaQueryWrapper.eq(Zarsh::getTaskId, task.getId());
        lambdaQueryWrapper.orderByDesc(Zarsh::getCFlag);
        // .eq(Zarsh::getCFlag, "R");
        List<Zarsh> list = this.list(lambdaQueryWrapper);
        if (null != list && list.size() > 0) {
            Zarsh zarsh = list.get(0);
            zarsh.setCFlag(cFlag);
            zarsh.setLocation(task.getToLocation());
            zarsh.setFromPos(task.getPort());
            zarsh.setToPos(task.getPort());
            zarsh.setTaskId(task.getId());
            zarsh.setLastUpdatedBy("wms");
            zarsh.setLastUpdated(new Date());
            this.updateById(zarsh);
        } else {
            // throw new ServiceException("未找到Zarsh对象");
        }
    }

    /**
     * RyTask扫描同步表保存逻辑
     * @param zarsh
     */
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult saveDataBySap(Zarsh zarsh) {
        // 用主表UniqueId查找子表zarsi信息
        LambdaQueryWrapper<Zarsi> zarsilambdaQueryWrapper = Wrappers.lambdaQuery();
        zarsilambdaQueryWrapper.eq(Zarsi::getUniqueId, zarsh.getUniqueId());
        List<Zarsi> zarsiList = zarsiService.list(zarsilambdaQueryWrapper);
        // 检测数据为空情况
//        checkDataBySap(zarsh, zarsiList);
        // 判断出库、入库，然后在判断是否空托盘出入库
        if (StringUtils.isEmpty(zarsh.getLgnum())) {
            throw new ServiceException("仓库号为空");
        }
        String zoneCode = zoneService.getZoneCodeByNick(zarsh.getLgnum());
        if (StringUtils.isEmpty(zoneCode)) {
            throw new ServiceException("找不到对应的仓库");
        }
        zarsh.setLgnum(zoneCode);
        TaskHeader taskHeader = null;
        switch (zarsh.getMFlag()) {
            // 整盘入库、补充入库
            case 2:
            case 8:
                // 入库
                if (StringUtils.isEmpty(zarsh.getFromPos())) {
                    throw new ServiceException("入库的站台为空");
                }
                if (zarsiList == null) {
                    zarsiList = Collections.EMPTY_LIST;
                }
                taskHeader = receiptBySap(zarsiList, zarsh);
                break;
            case 1:
            case 3:
                // 出库
                if (StringUtils.isEmpty(zarsh.getToPos())) {
                    throw new ServiceException("出库的站台为空");
                }
                taskHeader = shipmentBySap(zarsiList, zarsh);
                break;
            default:
                throw new ServiceException("MFlag不支持的业务类型");
        }
        /*
         * if(taskHeader!=null){
         * //修改同步表C_FLAG命令状态
         * this.updateZarshByTaskComplete(taskHeader,"R");
         * }
         */
        return AjaxResult.success("", taskHeader);
    }

    /**
     * RyTask扫描同步表保存逻辑
     * @param zarDomain
     */
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult saveSapDataByApi(ZarDomain zarDomain) {
        // 用主表UniqueId查找子表zarsi信息
        List<Zarsi> zarsiList = zarDomain.getZarsiList();
        Zarsh zarsh = zarDomain.getZarsh();

        Zarsh zarsh1 = zarshService.checkZarshByUniqueId(zarsh.getUniqueId());
        if (StringUtils.isNotEmpty(zarsh.getCFlag()) && zarsh.getCFlag().equals("D")) {
            // 取消
            return zarApiService.cancelTaskBySap(zarsh);
        }
        if (zarsh1 != null) {
            throw new ServiceException("单据已存在，请不要重复下发");
        }
        if (!zarshService.save(zarsh)) {
            throw new ServiceException("保存主表数据失败");
        }
        if (!zarsiService.saveBatchs(zarsiList, zarsh)) {
            throw new ServiceException("保存子表数据失败");
        }

        // 判断出库、入库，然后在判断是否空托盘出入库
        if (StringUtils.isEmpty(zarsh.getLgnum())) {
            throw new ServiceException("仓库号为空");
        }
        String zoneCode = zoneService.getZoneCodeByNick(zarsh.getLgnum());
        if (StringUtils.isEmpty(zoneCode)) {
            throw new ServiceException("找不到对应的仓库");
        }
        if (StringUtils.isNull(zarsh.getMFlag())) {
            throw new ServiceException("入库出库标志为空");
        }
        zarsh.setLgnum(zoneCode);
        TaskHeader taskHeader = null;
        switch (zarsh.getMFlag()) {
            // 整盘入库、补充入库
            case 2:
            case 8:
                // 入库
                if (StringUtils.isEmpty(zarsh.getFromPos())) {
                    throw new ServiceException("入库的站台为空");
                }
                String code = stationService.getStationCodeByNick(zarsh.getFromPos());
                if (StringUtils.isEmpty(code)) {
                    throw new ServiceException("找不到对应的站台" + zarsh.getFromPos());
                }
                zarsh.setFromPos(code);
                zarsh.setToPos(code);
                taskHeader = zarshService.receiptBySap(zarsiList, zarsh);
                break;
            case 1:
            case 3:
                // 出库
                if (StringUtils.isEmpty(zarsh.getToPos())) {
                    throw new ServiceException("出库的站台为空");
                }
                // 根据SAP站台编号 获取立库站台 1F01 -> P1001
                String code1 = stationService.getStationCodeByNick(zarsh.getToPos());
                if (StringUtils.isEmpty(code1)) {
                    throw new ServiceException("找不到对应的站台" + zarsh.getToPos());
                }
                zarsh.setToPos(code1);
                taskHeader = zarshService.shipmentBySap(zarsiList, zarsh);
                break;
            default:
                throw new ServiceException("MFlag不支持的业务类型");
        }
        return AjaxResult.success("添加任务成功", taskHeader);
    }

    // 入库
    public TaskHeader receiptBySap(List<Zarsi> zarsiList, Zarsh zarsh) {
        TaskHeader taskHeader = null;
        // 空托盘入库
        if (zarsiList == null || zarsiList.size() == 0) {
            String area = zoneService.getZoneAreaByCode(zarsh.getLgnum());
            // SAP创建 空容器号的入库任务
            AjaxResult result = workTaskEmptyContainerService.createEmptyIn(zarsh.getDrumId(), "", area, zarsh.getFromPos());
            if (result.hasErr()) {
                throw new ServiceException(result.getMsg());
            }
            Integer taskId = (Integer)result.getData();
            taskHeader = taskHeaderService.getById(taskId);
            taskHeader.setUniqueIds(zarsh.getUniqueId());
            taskHeaderService.updateById(taskHeader);
            // 调用sap的api，传递任务状态
            backSapStatusService.saveBackSapStatus(zarsh.getUniqueId(), zarsh.getLgnum(), null, 1, "1", null, null);
            return taskHeader;
        }
        // 保存入库信息
        ReceiptHeader receiptHeader = null;
        for (Zarsi zarsi : zarsiList) {
            if (zarsi.getVerme() == null || zarsi.getVerme().compareTo(BigDecimal.ZERO) == 0) {
                throw new ServiceException("入库数量不能为0");
            }
        }
        AjaxResult ajaxResult = receiptHeaderService.saveReceiptBySap(zarsh, zarsiList);
        if (ajaxResult != null && ajaxResult.hasErr()) {
            throw new ServiceException(ajaxResult.getMsg());
        }
        receiptHeader = (ReceiptHeader)ajaxResult.getData();
        // 调用sap的api，传递任务状态
        backSapStatusService.saveBackSapStatus(zarsh.getUniqueId(), zarsh.getLgnum(), null, 1, "1", null, null);
        // 判断有没有托盘号，有则生成组盘
        if (StringUtils.isNotEmpty(zarsh.getDrumId())) {
            // 保存组盘,生成任务信息
            // 设置wcs固定登录缓存，调用公共组盘接口
            ShiroUtils.setUserByWcsZone("SAP", QuantityConstant.WAREHOUSECODE, receiptHeader.getZoneCode());
            AjaxResult ajaxResult_receiptcontainerH = receiptContainerHeaderService.saveContainerByReceiptHeaderId(receiptHeader.getId(), zarsh.getDrumId());
            if (ajaxResult_receiptcontainerH != null && ajaxResult_receiptcontainerH.hasErr()) {
                throw new ServiceException(ajaxResult_receiptcontainerH.getMsg());
            }
        }
        return taskHeader;
    }

    // 出库
    public TaskHeader shipmentBySap(List<Zarsi> zarsiList, Zarsh zarsh) {
        TaskHeader taskHeader = null;
        // 空托盘出库
        if (zarsiList == null || zarsiList.size() == 0) {
            // 获取对应库区编码 zarsh.getLgnum() --> F
            List<Location> list = containerService.getEmptyContainerInLocation(zarsh.getLgnum(), "", "", QuantityConstant.WAREHOUSECODE);
            List<String> emptyContainerCodeList = list.stream().map(t -> t.getContainerCode()).collect(Collectors.toList());
            List<String> removeContainerList = new ArrayList<>();
            for (String containerCode : emptyContainerCodeList) {
                Container container = containerService.getContainerByCode(containerCode, QuantityConstant.WAREHOUSECODE);
                if (container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_LOCK)) {
                    removeContainerList.add(containerCode);
                }
            }
            emptyContainerCodeList.removeAll(removeContainerList);

            if (emptyContainerCodeList == null || emptyContainerCodeList.isEmpty()) {
                throw new ServiceException("库内没有找到空容器");
            }
            // 自动匹配空容器出库
            Container container = null;
            if (StringUtils.isNotEmpty(zarsh.getDrumId())) {
                container = containerService.getContainerByCode(zarsh.getDrumId(), QuantityConstant.WAREHOUSECODE);
            } else {
                container = containerService.getContainerByCode(emptyContainerCodeList.get(0), QuantityConstant.WAREHOUSECODE);
            }
            if (container == null){
                throw new ServiceException("请检查容器码:"+zarsh.getDrumId()+"是否正确！");
            }
            // 创建空容器出库任务
            AjaxResult result = workTaskService.createEmptyOut(container.getCode(), container.getLocationCode(), zarsh.getToPos(), QuantityConstant.WAREHOUSECODE,
                zarsh.getUniqueId());

            if (result.hasErr()) {
                throw new ServiceException(result.getMsg());
            }
            // 调用sap的api，传递任务状态
            backSapStatusService.saveBackSapStatus(zarsh.getUniqueId(), zarsh.getLgnum(), null, 2, "1", null, null);
            return taskHeader;
        }
        // 有料出库
        // 保存出库信息
        ShipmentHeader shipmentHeader = null;
        AjaxResult ajaxResult = shipmentHeaderService.saveShipmentBySap(zarsh, zarsiList);
        if (ajaxResult != null && ajaxResult.hasErr()) {
            throw new ServiceException(ajaxResult.getMsg());
        }
        shipmentHeader = (ShipmentHeader)ajaxResult.getData();
        // 调用sap的api，传递任务状态
        backSapStatusService.saveBackSapStatus(zarsh.getUniqueId(), zarsh.getLgnum(), null, 2, "1", null, null);
        // 判断有没有库位号，有则生成组盘
        if (StringUtils.isNotEmpty(zarsh.getLocation())) {
            // 保存组盘信息
            ShipmentContainerHeader shipmentContainerHeader = null;
            AjaxResult result = shipmentContainerHeaderService.saveShipmentContainerBySap(shipmentHeader, zarsh, zarsiList);
            if (result != null && result.hasErr()) {
                throw new ServiceException(result.getMsg());
            }
            shipmentContainerHeader = (ShipmentContainerHeader)result.getData();
            // 创建任务表数据
            AjaxResult ajaxResult_taskheader = taskHeaderService.saveTaskBySapLK(shipmentContainerHeader);
            // 生成任务成功之后在修改 组盘状态
            if (ajaxResult_taskheader.hasErr()) {
                throw new ServiceException("生成任务失败");
            }
        }
        return taskHeader;
    }

    // 定时任务扫描时，检查数据是否合规，必填字段是否都有，保存进zarsh表
    public void checkDataBySap(Zarsh zarsh, List<Zarsi> zarsiList) {
        Assert.notNull(zarsh.getInKind(), "货物总类不能为空");
        if (StringUtils.isEmpty(zarsh.getCFlag()) || StringUtils.isEmpty(zarsh.getDrumId()) || StringUtils.isEmpty(zarsh.getLocation())) {
            throw new ServiceException("数据id:" + zarsh.getId() + ",命令状态，容器号，库位不能为空");
        }
        for (Zarsi zarsi : zarsiList) {
            if (StringUtils.isEmpty(zarsi.getMatnr()) || StringUtils.isNull(zarsi.getVerme())) {
                throw new ServiceException("数据id:" + zarsi.getId() + ",物料、库存不能为空");
            }
        }
    }

    // 空托盘入库出库检测容器和库位是否空闲
    public void checkEmptyContainerBySap(String containerCode, String locationCode) {
        /*
         * if (StringUtils.isEmpty(containerCode)) {
         * throw new ServiceException("容器号不存在");
         * }
         */
        if (StringUtils.isNotEmpty(containerCode)) {
            Container container = containerService.getContainerByCode(containerCode, QuantityConstant.WAREHOUSECODE);
            if (StringUtils.isNull(container)) {
                throw new ServiceException("容器不存在");
            }
            if (StringUtils.isNotEmpty(container.getLocationCode())) {
                throw new ServiceException("容器已在库位" + container.getLocationCode() + "上");
            }
        }
        if (StringUtils.isNotEmpty(locationCode)) {
            Location location = locationService.getLocationByCode(locationCode, QuantityConstant.WAREHOUSECODE);
            if (StringUtils.isNull(location)) {
                throw new ServiceException("目标库位不存在");
            }
            if (StringUtils.isNotEmpty(location.getContainerCode())) {
                throw new ServiceException(locationCode + "上已存在容器" + location.getContainerCode());
            }
            if (!QuantityConstant.STATUS_LOCATION_EMPTY.equals(location.getStatus())) {
                throw new ServiceException("目标库位非空闲");
            }
        }

    }

    public void saveApiLog(String url, String requestBody, String responseBody) {
        ApiLog apiLog = new ApiLog();
        apiLog.setApiName("审核回传ERP");
        apiLog.setApiMethod("POST");
        apiLog.setRequestFrom("WMS");
        apiLog.setResponseBy("ERP");
        apiLog.setUrl(url);
        apiLog.setRequestTime(new Date());
        apiLog.setResponseTime(new Date());
        apiLog.setRequestBody(requestBody);
        apiLog.setResponseBody(responseBody);
        apiLogService.save(apiLog);
    }
}