WAREAMS/warewms-ams/src/main/java/com/warewms/business/service/impl/BusinessServiceImpl.java

package com.warewms.business.service.impl;

import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.warewms.business.domain.dto.AgvCallDTO;
import com.warewms.business.domain.dto.AgvCallItem;
import com.warewms.business.domain.dto.AgvCallItemDTO;
import com.warewms.business.form.LineCallDetailsForm;
import com.warewms.business.form.LineCallForm;
import com.warewms.business.form.LineCallListFrom;
import com.warewms.business.service.IBusinessService;
import com.warewms.common.AmsConstant;
import com.warewms.common.base.domain.AjaxResult;
import com.warewms.common.constant.WmsConstant;
import com.warewms.common.exception.ServiceException;
import com.warewms.common.utils.redis.RedisCache;
import com.warewms.common.utils.redis.RedisKey;
import com.warewms.common.utils.uuid.SnowflakeIdWorker;
import com.warewms.ndc.common.ByteUtil;
import com.warewms.ndc.common.CRC16Util;
import com.warewms.task.domain.AmsTask;
import com.warewms.wms.asn.form.PaForm;
import com.warewms.wms.asn.service.IWmsDocAsnHeaderService;
import com.warewms.wms.base.dto.BaseLocationInfoSameColDTO;
import com.warewms.wms.base.entity.BaseLocationInfo;
import com.warewms.wms.base.entity.BaseLocationZone;
import com.warewms.wms.base.mapper.BaseLocationInfoMapper;
import com.warewms.wms.base.service.IBaseLocationInfoService;
import com.warewms.wms.box.domain.WmsBoxInfo;
import com.warewms.wms.box.service.IWmsBoxInfoService;
import com.warewms.wms.flow.domain.AsnSoStrategy;
import com.warewms.wms.flow.mapper.AsnSoStrategyMapper;
import com.warewms.wms.flow.service.IFlowConfigHeaderService;
import com.warewms.wms.flow.vo.FlowConfigHeaderVO;
import com.warewms.wms.inv.domain.form.InvLotLocIdMoveForm;
import com.warewms.wms.inv.domain.vo.InvLotLocIdLotattVO;
import com.warewms.wms.inv.dto.LotattDTO;
import com.warewms.wms.inv.service.IInvLotLocIdService;
import com.warewms.wms.order.form.CheckOutInfoForm;
import com.warewms.wms.task.domain.WcsTask;
import com.warewms.wms.task.dto.WcsTaskLocationDTO;
import com.warewms.wms.task.mapper.WcsTaskMapper;
import com.warewms.wms.task.service.IWcsTaskService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

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

@Slf4j
@Service
public class BusinessServiceImpl implements IBusinessService {
    @Autowired
    private IBusinessService businessService;
    @Autowired
    private IBaseLocationInfoService baseLocationInfoService;

    @Autowired
    private IInvLotLocIdService invLotLocIdService;
    @Autowired
    private WcsTaskMapper wcsTaskMapper;
    @Autowired
    private AsnSoStrategyMapper asnSoStrategyMapper;
    @Autowired
    private BaseLocationInfoMapper baseLocationInfoMapper;

    @Autowired
    private RedisCache redisCache;
    @Autowired
    private IWcsTaskService wcsTaskService;
    @Autowired
    private IAmsTaskService amsTaskService;
    @Autowired
    private IFlowConfigHeaderService flowConfigHeaderService;
    @Autowired
    private IWmsDocAsnHeaderService iWmsDocAsnHeaderService;
    @Autowired
    private IWmsBoxInfoService wmsBoxInfoService;

    public static int genIKey(String taskNo) {
        int res = CRC16Util.calcCrc16(ByteUtil.string2byteArray(taskNo));
        return res == 0 ? genIKey(NumberUtil.add(new BigDecimal(taskNo), BigDecimal.ONE).toString()) : res;
    }

    @Transactional
    @Override
    public AjaxResult agvCall(FlowConfigHeaderVO flowConfigHeaderVO, LineCallListFrom lform, LineCallForm lineCallForm
            , String asnNo, int orderRules, boolean superHighMark) {
        Map<String, AgvCallDTO> map = new HashMap<>();
        List<AgvCallDTO> list = new ArrayList<>();
        if (flowConfigHeaderVO.getFlowType().equals("ASN") && org.apache.commons.lang3.StringUtils.isEmpty(lform.getLocationFrom())) {
            return AjaxResult.error("入库任务必须选择起始库位");
        }
        if (flowConfigHeaderVO.getFlowType().equals("SO") && (lform.getQty() == null || lform.getQty().longValue() == 0)) {
            return AjaxResult.error("出库任务必须选择数量");
        }
        AgvCallDTO agvCallDTO;
        if (map.containsKey(lform.getLocationFrom() + "-" + lform.getLocationTo())) {
            agvCallDTO = map.get(lform.getLocationFrom() + "-" + lform.getLocationTo());
        } else {
            agvCallDTO = new AgvCallDTO();
            agvCallDTO.setWarehouseId(1L);//没用暂时写死
            agvCallDTO.setLocationFrom(lform.getLocationFrom());
            agvCallDTO.setLocationTo(lform.getLocationTo());
            agvCallDTO.setId(lform.getId());
            agvCallDTO.setPalletNo(lform.getPalletNo());
            agvCallDTO.setTaskType(lineCallForm.getFlowId().toString());
            agvCallDTO.setOrderNo(asnNo); // 入库单号
            agvCallDTO.setOrderRules(orderRules);
        }
        AgvCallItemDTO agvCallItemDTO = new AgvCallItemDTO();
        agvCallItemDTO.setWarehouseId(1L);
        agvCallItemDTO.setSku(lform.getSku());
        agvCallItemDTO.setQty(lform.getQty());
        agvCallItemDTO.setSupplier(lform.getSupplier());
        agvCallItemDTO.setWeight(lform.getWeight());
        agvCallItemDTO.setLocationFrom(lform.getLocationFrom());
        agvCallItemDTO.setLocationTo(lform.getLocationTo());
        agvCallItemDTO.setSuperHigh(superHighMark);
        agvCallDTO.getAgvCallItemDTOList().add(agvCallItemDTO);
        LotattDTO lotattDTO = new LotattDTO();
        List<LineCallDetailsForm> lineCallDetailsForms = lform.getLineCallDetailsFormList();
        if (lineCallDetailsForms != null && lineCallDetailsForms.size() > 0) {
            for (LineCallDetailsForm detailsForm : lineCallDetailsForms) {
                lotattDTO.setAttr(detailsForm.getLotattId(), detailsForm.getLotattValue());
            }
        }
        agvCallItemDTO.setLotattDTO(lotattDTO);
        map.put(lform.getLocationFrom() + "-" + lform.getLocationTo(), agvCallDTO);
        for (Map.Entry<String, AgvCallDTO> entry : map.entrySet()) {
            AgvCallDTO mapValue = entry.getValue();
            list.add(mapValue);
        }
        return businessService.agvCall(flowConfigHeaderVO, list);
    }

    @Transactional
    @Override
    public AjaxResult agvCall(AgvCallItem agvCallItem, Long flowId) {
        //查询所属流程
        FlowConfigHeaderVO flowConfigHeaderVO = flowConfigHeaderService.selectFlowConfigHeaderById(flowId);

        AgvCallItemDTO agvCallItemDTO = new AgvCallItemDTO();
        BeanUtils.copyProperties(agvCallItem, agvCallItemDTO);

        List<AgvCallDTO> list = new ArrayList<>();
        AgvCallDTO agvCallDTO = new AgvCallDTO();
        agvCallDTO.setWarehouseId(WmsConstant.WAREHOUSE_ID);
        agvCallDTO.setLocationFrom(agvCallItemDTO.getLocationFrom());
        agvCallDTO.setLocationTo(agvCallItemDTO.getLocationTo());
        agvCallItemDTO.setWarehouseId(WmsConstant.WAREHOUSE_ID);
        agvCallItemDTO.setFlowConfigHeaderVO(flowConfigHeaderVO);
        agvCallDTO.getAgvCallItemDTOList().add(agvCallItemDTO);
        list.add(agvCallDTO);
        return this.agvCall(flowConfigHeaderVO, list);
    }

    @Transactional
    @Override
    public AjaxResult agvCall(FlowConfigHeaderVO flowConfigHeaderVO, AgvCallDTO agvCallDTO) {
        List<AgvCallDTO> agvCallDTOList = new ArrayList<>();
        List<AgvCallItemDTO> callItemDTOList = new ArrayList<>();
        AgvCallItemDTO callItemDTO = new AgvCallItemDTO();
        callItemDTO.setLocationFrom(agvCallDTO.getLocationFrom());
        callItemDTO.setLocationTo(agvCallDTO.getLocationTo());
        callItemDTO.setWarehouseId(agvCallDTO.getWarehouseId());
        callItemDTO.setLotattDTO(new LotattDTO());
        callItemDTO.setExtParam(agvCallDTO.getExtParam());
        callItemDTOList.add(callItemDTO);
        agvCallDTO.setAgvCallItemDTOList(callItemDTOList);
        agvCallDTOList.add(agvCallDTO);
        return businessService.agvCall(flowConfigHeaderVO, agvCallDTOList);
    }

    @Transactional
    @Override
    public AjaxResult agvCall(FlowConfigHeaderVO flowConfigHeaderVO, List<AgvCallDTO> agvCallDTOList) {
        //唯一操作标识，用于redis标记。报错时根据该id进行删除
        Long token = SnowflakeIdWorker.generateId();
        try {
            //查询全局配置策略
            AsnSoStrategy asnSoStrategy = asnSoStrategyMapper.selectAsnSoStrategy();

            for (AgvCallDTO agvCallDTO : agvCallDTOList) {
                //如果是入库把起始库位相同的数据整合到一起生成库存记录
                BaseLocationInfo locationFrom = null;
                BaseLocationInfo locationTo = null;
                List<WcsTask> wcsTaskList = new ArrayList<>();
                String paramLocationFrom = agvCallDTO.getLocationFrom();
                String paramLocationTo = agvCallDTO.getLocationTo();
                List<String> zoneIdList = new ArrayList<>();
                if (StringUtils.isEmpty(paramLocationFrom)) {
                    paramLocationFrom = flowConfigHeaderVO.getLocationFrom();
                }
                if (StringUtils.isEmpty(paramLocationTo)) {
                    paramLocationTo = flowConfigHeaderVO.getLocationTo();
                }
                if (!StringUtils.isEmpty(flowConfigHeaderVO.getLocationFrom())) {
                    zoneIdList = Arrays.stream(flowConfigHeaderVO.getLocationFrom().split(",")).collect(Collectors.toList());
                }

                if (flowConfigHeaderVO.getFlowType().equals("ASN")) {
                    AgvCallItemDTO agvCall = agvCallDTO.getAgvCallItemDTOList().get(0);
                    List<BaseLocationInfo> locationFromList = this.convertLocation(paramLocationFrom, agvCallDTO.getWarehouseId(), null);
                    List<BaseLocationInfo> locationToList = null;
                    //排序规则 普通入库回库先放在col_no小的位置 - 1，备货入库回库放在col_no大的位置 - 2
                    if (agvCallDTO.getOrderRules() == 1) {
                        locationToList = this.convertLocation(paramLocationTo, agvCallDTO.getWarehouseId(), "col_no + 0,shift_no + 0");
                    } else {
                        locationToList = this.convertLocation(paramLocationTo, agvCallDTO.getWarehouseId(), "col_no + 0 desc,shift_no + 0");
                    }
                    locationFrom = this.zoneLocationAllocation(locationFromList, "locationFrom", "ASN", asnSoStrategy, agvCall, token);
                    locationTo = this.zoneLocationAllocation(locationFrom, locationToList, "locationTo", "ASN", asnSoStrategy, agvCall, token);
                    //2.初始化库存
//                    for (AgvCallItemDTO call : agvCallDTO.getAgvCallItemDTOList()) {
//                        if (call.getLotattDTO() != null) {
//                            invLotLocIdService.deleteInvLotLocIdById(locationFrom.getId());
//                            invLotLocIdService.initInv(locationFrom.getId().toString(), call.getSku(), WmsConstant.CUSTOMER_ID, call.getQty(), call.getLotattDTO(), BigDecimal.ZERO);
//                        }
//                    }
                    wcsTaskList.addAll(this.genTask(locationFrom, locationTo, flowConfigHeaderVO, agvCallDTO, token));

                } else if (flowConfigHeaderVO.getFlowType().equals("SO")) {
                    AgvCallItemDTO agvCall = agvCallDTO.getAgvCallItemDTOList().get(0);
                    List<BaseLocationInfo> locationToList = this.convertLocation(paramLocationTo, agvCallDTO.getWarehouseId(), null);
                    List<BaseLocationInfo> locationFromList = this.convertLocation(paramLocationFrom, agvCallDTO.getWarehouseId(), null);
                    /*HashMap<String, String> hashMap = JSON.parseObject(JSON.toJSONString(agvCall.getLotattDTO()), HashMap.class);
                    List<BaseLocationInfo> locationFromList = baseLocationInfoMapper.selectSortedLocationLotattListByZoneIdListOrderBy(zoneIdList
                            , agvCall.getWarehouseId(), hashMap, agvCall.getSku(), "inv.create_time");*/
                    locationFrom = this.zoneLocationAllocation(locationFromList, "locationFrom", "SO", asnSoStrategy, agvCall, token);
                    locationTo = this.zoneLocationAllocation(locationToList, "locationTo", "SO", asnSoStrategy, agvCall, token);
                    wcsTaskList.addAll(this.genTask(locationFrom, locationTo, flowConfigHeaderVO, agvCallDTO, token));

                } else if (flowConfigHeaderVO.getFlowType().equals("MV")) {
                    AgvCallItemDTO agvCall = agvCallDTO.getAgvCallItemDTOList().get(0);
                    List<BaseLocationInfo> locationFromList = this.convertLocation(paramLocationFrom, agvCallDTO.getWarehouseId(), null);
                    List<BaseLocationInfo> locationToList = this.convertLocation(paramLocationTo, agvCallDTO.getWarehouseId(), null);
                    locationFrom = this.zoneLocationAllocation(locationFromList, "locationFrom", "MV", asnSoStrategy, agvCall, token);
                    locationTo = this.zoneLocationAllocation(locationToList, "locationTo", "MV", asnSoStrategy, agvCall, token);
                    //2.初始化库存
                    for (AgvCallItemDTO call : agvCallDTO.getAgvCallItemDTOList()) {
                        if (call.getLotattDTO() != null) {
                            invLotLocIdService.deleteInvLotLocIdById(locationFrom.getId());
                            invLotLocIdService.initInv(locationFrom.getId().toString(), call.getSku(), WmsConstant.CUSTOMER_ID, call.getQty(), call.getLotattDTO(), BigDecimal.ZERO);
                        }
                    }
                    wcsTaskList.addAll(this.genTask(locationFrom, locationTo, flowConfigHeaderVO, agvCallDTO, token));
                }
            }
            return AjaxResult.success("任务下发成功");
        } catch (Exception e) {
            redisCache.unlockCacheObject(token); // 异常捕获的话就不能释放锁
            throw new ServiceException("agvCall任务下发失败：" + e.getMessage(), token);
        }
    }

    @Override
    public BaseLocationInfo zoneLocationAllocation(List<BaseLocationInfo> locationInfoList, String locationType, String type, AsnSoStrategy asnSoStrategy, AgvCallItemDTO agvCallDTO, Long token) {
        return zoneLocationAllocation(null, locationInfoList, locationType, type, asnSoStrategy, agvCallDTO, token);
    }

    @Override
    public BaseLocationInfo zoneLocationAllocation(BaseLocationInfo locationFrom, List<BaseLocationInfo> locationInfoList, String locationType, String type, AsnSoStrategy asnSoStrategy, AgvCallItemDTO agvCallDTO, Long token) {
        BaseLocationInfo locationInfo = null;
        if (type.equals("ASN")) {
            //入库
            if (locationType.equals("locationFrom")) {
                for (BaseLocationInfo b : locationInfoList) {
                    if (!b.getStockStatus().equals("00")) {
                        continue;
                    }
                    if (!redisCache.lockCacheObject(RedisKey.LOCK_LOCATION + b.getId(), b.getId().toString(), token)) {
                        continue;
                    }
                    locationInfo = b;
                    break;
                }
                if (locationInfo == null) {
                    throw new ServiceException("入库起始库位没有可以分配的空库位", token);
                }
            } else {
                for (BaseLocationInfo b : locationInfoList) {
                    if (!b.getStockStatus().equals("00") || !b.getIsEmpty().equals("Y") || redisCache.checkIsLock(RedisKey.LOCK_LOCATION + b.getId())) {
                        continue;
                    }
                    // 根据起始库位判断目标是否可放
                    Boolean canPut = checkLocCanPut(locationFrom, b, agvCallDTO.isSuperHigh());
                    if (!canPut) {
                        continue;
                    }
                    // AGV均匀任务
                    int agvNo;
                    // 推荐几号车做
                    agvNo = recommendedWarehousingCarNumber();
                    // 校验当前库位绑定的车号
                    boolean iscan = checkCurrentLocationCarNumber(agvNo, b);
                    if (!iscan) {
                        continue;
                    }
                    if (!redisCache.lockCacheObject(RedisKey.LOCK_LOCATION + b.getId(), b.getId().toString(), token)) {
                        continue;
                    }

                    locationInfo = b;
                    break;
                }
                if (locationInfo == null) {
                    // 如果没有可用库位，去掉AGV均匀任务判断
                    for (BaseLocationInfo b : locationInfoList) {
                        if (!b.getStockStatus().equals("00") || !b.getIsEmpty().equals("Y") || redisCache.checkIsLock(RedisKey.LOCK_LOCATION + b.getId())) {
                            continue;
                        }
                        // 根据起始库位判断目标是否可放
                        Boolean canPut = checkLocCanPut(locationFrom, b, agvCallDTO.isSuperHigh());
                        if (!canPut) {
                            continue;
                        }
                        if (!redisCache.lockCacheObject(RedisKey.LOCK_LOCATION + b.getId(), b.getId().toString(), token)) {
                            continue;
                        }
                        locationInfo = b;
                        break;
                    }
                    if (locationInfo == null) {
                        throw new ServiceException("入库目标点没有可以分配的库位", token);
                    }
                }
            }
        } else if (type.equals("SO")) {
            //起始库位
            if (locationType.equals("locationFrom")) {
                for (BaseLocationInfo b : locationInfoList) {
                    if (!b.getStockStatus().equals("00") || !b.getIsEmpty().equals("N") || redisCache.checkIsLock(RedisKey.LOCK_LOCATION + b.getId())) {
                        continue;
                    }
                    if (!redisCache.lockCacheObject(RedisKey.LOCK_LOCATION + b.getId(), b.getId().toString(), token)) {
                        continue;
                    }
                    locationInfo = b;
                    break;
                }
                if (locationInfo == null) {
                    throw new ServiceException("出库起始点没有可以分配的库存！", token);
                }

            } else { //目标库位
                // 出库默认先不给分配目标库位 这里不能改 会破坏出库均匀任务
//                for (BaseLocationInfo b : locationInfoList) {
//                    if (!b.getStockStatus().equals("00") || !b.getIsEmpty().equals("Y") || redisCache.checkIsLock(RedisKey.LOCK_LOCATION + b.getId())) {
//                        continue;
//                    }
//                    if (!redisCache.lockCacheObject(RedisKey.LOCK_LOCATION + b.getId(), b.getId().toString(), token)) {
//                        continue;
//                    }
//                    locationInfo = b;
//                    break;
//                }
//                if (locationInfo == null) {
                // 出库没有可分配库位，不报错，返回空
//                    throw new ServiceException("出库目标点没有可以分配的库位", token);
//                }
            }
        } else { //移库
            if (locationType.equals("locationFrom")) {

                for (BaseLocationInfo b : locationInfoList) {
                    if (!b.getStockStatus().equals("00") || redisCache.checkIsLock(RedisKey.LOCK_LOCATION + b.getId())) {
                        continue;
                    }
                    if (!redisCache.lockCacheObject(RedisKey.LOCK_LOCATION + b.getId(), b.getId().toString(), token)) {
                        continue;
                    }
                    locationInfo = b;
                    break;
                }
                //分配时是否需要做库位占用判断
                FlowConfigHeaderVO flowConfigHeaderVO = agvCallDTO.getFlowConfigHeaderVO();
                if (!StringUtils.isEmpty(flowConfigHeaderVO.getLocationFromStrategyFlag()) && flowConfigHeaderVO.getLocationFromStrategyFlag().equals("Y")) {

                } else {
                    //如果未启用策略则进行判断
                    if (locationInfo == null) {
                        throw new ServiceException("移库没有可以分配的库位", token);
                    }
                }

            } else {
                for (BaseLocationInfo b : locationInfoList) {
                    if (!b.getStockStatus().equals("00") || !b.getIsEmpty().equals("Y") || redisCache.checkIsLock(RedisKey.LOCK_LOCATION + b.getId())) {
                        continue;
                    }
                    if (!redisCache.lockCacheObject(RedisKey.LOCK_LOCATION + b.getId(), b.getId().toString(), token)) {
                        continue;
                    }
                    locationInfo = b;
                    break;
                }
                //分配时是否需要做库位占用判断
                FlowConfigHeaderVO flowConfigHeaderVO = agvCallDTO.getFlowConfigHeaderVO();
                if (!StringUtils.isEmpty(flowConfigHeaderVO.getLocationFromStrategyFlag()) && flowConfigHeaderVO.getLocationFromStrategyFlag().equals("Y")) {

                } else {
                    //如果未启用策略则进行判断
                    if (locationInfo == null) {
                        throw new ServiceException("移库没有可以分配的库位", token);
                    }
                }
            }
        }
        return locationInfo;
    }


    @Transactional
    @Override
    public AjaxResult doPaAndTask(PaForm paForm, FlowConfigHeaderVO flowConfigHeaderVO, LineCallListFrom lform, LineCallForm lineCallForm
            , boolean superHighMark) {
        // 上架
        String asnNo = "";
        //排序规则 普通入库回库先放在col_no小的位置 - 1，备货入库回库放在col_no大的位置 - 2
        int orderRules = 1;
        AjaxResult ajaxResult = iWmsDocAsnHeaderService.doPa(paForm);
        if (!ajaxResult.isSuccess()) {
            return ajaxResult;
        }
        asnNo = (String) ajaxResult.get("data");
        orderRules = (int) ajaxResult.get("orderRules");
        return businessService.agvCall(flowConfigHeaderVO, lform, lineCallForm, asnNo, orderRules, superHighMark);
    }

    /**
     * 校验当前库位车号
     *
     * @param agvNo
     * @param b
     * @return
     */
    private boolean checkCurrentLocationCarNumber(int agvNo, BaseLocationInfo b) {
        if (agvNo == 1) {
            if (!b.getFoldedTag().equals("1")) {
                return false;
            }
        } else if (agvNo == 2) {
            if (!b.getFoldedTag().equals("2")) {
                return false;
            }
        }
        return true;
    }

    /**
     * 推荐入库车号
     *
     * @return
     */
    private int recommendedWarehousingCarNumber() {
        if (redisCache.getCacheObject(RedisKey.AGV_TASK_CAR_NO) != null) {
            int carNo = redisCache.getCacheObject(RedisKey.AGV_TASK_CAR_NO);
            return carNo == 1 ? 2 : 1;
        }
        return 0;
    }

    public Boolean checkLocCanPut(BaseLocationInfo locationFrom, BaseLocationInfo locationTo, boolean isSuperHigh) {
        boolean con = false;
        // 永湖仓储区一层高度为1600，二层有4个点为1600，其他为2100
        // 入库和回库的时候，入库位IN-02-01（200）和回库位RET-01-01（500）没超高入库到1600的库位，超高了入库到2100
        // 入库和回库的时候，入库位IN-01-01和回库位RET-02-01入库到2100，超高不可入库
        if ((locationFrom.getLocationNo().equals("IN-02-01") || locationFrom.getLocationNo().equals("RET-01-01"))
                && !isSuperHigh) {
            if (locationTo.getShiftNo().equals("1")
                    || (locationTo.getHeightLimit() != null && locationTo.getHeightLimit().compareTo(1600.0) == 0)) {
                con = true;
            }
        } else {
            if (!locationTo.getShiftNo().equals("1")
                    && (locationTo.getHeightLimit() == null || locationTo.getHeightLimit().compareTo(1600.0) != 0)) {
                con = true;
            }
        }
        return con;
    }


    @Override
    public List<BaseLocationInfo> convertLocation(String locationNoOrZoneId, Long warehouseId, String orderBy) {
        List<BaseLocationInfo> locationInfoList = new ArrayList<>();
        if (!StringUtils.isEmpty(locationNoOrZoneId)) {
            String[] arr = locationNoOrZoneId.split(",");
            for (String obj : arr) {
                boolean isLocation = baseLocationInfoService.checkIsLocation(obj, warehouseId);
                if (isLocation) {
                    BaseLocationInfo info = baseLocationInfoService.selectBaseLocationInfoByIdOrNo(obj, warehouseId);
                    locationInfoList.add(info);
                } else {
                    List<BaseLocationInfo> infoList = baseLocationInfoService.selectSortedLocatinListByZoneId(Long.parseLong(obj), warehouseId, orderBy);
                    locationInfoList.addAll(infoList);
                }
            }
        }
        return locationInfoList;
    }

    @Override
    public List<WcsTask> genTask(BaseLocationInfo locationFrom, BaseLocationInfo locationTo, FlowConfigHeaderVO flowConfigHeaderVO, AgvCallDTO agvCallDTO, Long token) {
        if (flowConfigHeaderVO.getLocationFromStrategyFlag().equals("N") && ObjectUtil.isNull(locationFrom)) {
            throw new ServiceException("起始库位不能为空", token);
        }
        if (flowConfigHeaderVO.getLocationToStrategyFlag().equals("N") && ObjectUtil.isNull(locationTo)) {
            throw new ServiceException("目标库位不能为空", token);
        }

        List<WcsTask> wcsTaskList = new ArrayList<>();
        if (StringUtils.isNotBlank(flowConfigHeaderVO.getRootFlow())) return wcsTaskList;
        String taskNo = IdWorker.getIdStr();
        WcsTask wcsTask = new WcsTask();
        wcsTask.setTaskNo(taskNo);
        if (locationFrom != null) {
            wcsTask.setAreaFrom(locationFrom.getZoneId().toString());
            wcsTask.setLocationFrom(locationFrom.getId().toString());
        }
        if (locationTo != null) {
            wcsTask.setAreaTo(locationTo.getZoneId() + "");
            wcsTask.setLocationTo(locationTo.getId().toString());
        }
        wcsTask.setState(Long.parseLong(WmsConstant.TASK_STS.TASK9.getValue().toString()));
        wcsTask.setPriority(1L);
        wcsTask.setShopId(WmsConstant.WAREHOUSE_ID.toString());
        wcsTask.setCreateDate(new Date());
        wcsTask.setBusinessType(AmsConstant.TASK_BUSINESS_TYPE.TASK_01.getValue());
        wcsTask.setTaskType(WmsConstant.TASK_TYPE.FORWARD.getValue());
        wcsTask.setExt8(token.toString());
        wcsTask.setExt7(flowConfigHeaderVO.getId().toString());
        wcsTask.setExt6(agvCallDTO.getOrderNo());
        wcsTask.setExt5(agvCallDTO.getPalletNo());
        wcsTask.setExt4(agvCallDTO.getTaskType());// 任务类型
        wcsTask.setExtParam(agvCallDTO.getExtParam());
        wcsTaskList.add(wcsTask);
        businessService.addTask(wcsTask);
        return wcsTaskList;
    }

    @Transactional
    @Override
    public AjaxResult addTask(WcsTask wcsTask) {
        //锁定库位
        if (!StringUtils.isEmpty(wcsTask.getLocationFrom())) {
            baseLocationInfoService.updateLocationStockStatus(Long.parseLong(wcsTask.getLocationFrom()), WmsConstant.STOCK_STATUS.STOCK10.getValue());
        }
        if (!StringUtils.isEmpty(wcsTask.getLocationTo()) && !wcsTask.getLocationTo().equals("待分配")) {
            baseLocationInfoService.updateLocationStockStatus(Long.parseLong(wcsTask.getLocationTo()), WmsConstant.STOCK_STATUS.STOCK10.getValue());
        }

        Integer priority = 1;
        if (wcsTask.getTaskType().equals("OB")) {
            if (wcsTask.getPriority() == 99) {
                int current = wcsTaskMapper.selectCurrentPriority();
                priority = current - 100;
            } else {
                int current = wcsTaskMapper.selectCurrentPriority();
                priority = current + 10;
            }
        } else {
            //倒库任务顺序由原任务中间插入不需要获取
            priority = wcsTask.getPriority().intValue();
        }
        wcsTask.setPriority((long) priority);
        int result = wcsTaskMapper.insertWcsTask(wcsTask);
        if (result > 0) {
            return AjaxResult.success("任务生成成功");
        } else {
            throw new ServiceException("任务生成失败");
        }
    }

    @Override
    public AjaxResult addTaskList(List<WcsTask> wcsTaskList) {
        for (WcsTask wcsTask : wcsTaskList) {
            //锁定库位
            if (!StringUtils.isEmpty(wcsTask.getLocationFrom())) {
                baseLocationInfoService.updateLocationStockStatus(Long.parseLong(wcsTask.getLocationFrom()), WmsConstant.STOCK_STATUS.STOCK10.getValue());
            }
            if (!StringUtils.isEmpty(wcsTask.getLocationTo())) {
                baseLocationInfoService.updateLocationStockStatus(Long.parseLong(wcsTask.getLocationTo()), WmsConstant.STOCK_STATUS.STOCK10.getValue());
            }

            Integer priority = 1;
            if (!wcsTask.getTaskType().equals("OB")) {
                if (wcsTask.getPriority() == 99) {
                    int current = wcsTaskMapper.selectCurrentPriority();
                    priority = current - 100;
                } else {
                    int current = wcsTaskMapper.selectCurrentPriority();
                    priority = current + 10;
                }
            } else {
                //倒库任务顺序由原任务中间插入不需要获取
                priority = wcsTask.getPriority().intValue();
            }
            wcsTask.setPriority((long) priority);
            int result = wcsTaskMapper.insertWcsTask(wcsTask);
            if (result > 0) {
                return AjaxResult.success("任务生成成功");
            } else {
                throw new ServiceException("任务生成失败");
            }
        }
        return AjaxResult.success("");
    }

    @Override
    public AjaxResult sendTask(WcsTask wcsTask) {
        BaseLocationInfo locFrom = baseLocationInfoService.selectBaseLocationInfoByIdOrNo(wcsTask.getLocationFrom(), WmsConstant.WAREHOUSE_ID);
        BaseLocationInfo locTo = baseLocationInfoService.selectBaseLocationInfoByIdOrNo(wcsTask.getLocationTo(), WmsConstant.WAREHOUSE_ID);
        AmsTask amsTask = new AmsTask();
        amsTask.setTaskNo(wcsTask.getTaskNo());
        if (wcsTask.getBusinessType() == null || wcsTask.getBusinessType().equals("")) {
            amsTask.setBusinessType(AmsConstant.TASK_BUSINESS_TYPE.TASK_01.getValue());
        } else {
            amsTask.setBusinessType(wcsTask.getBusinessType());
        }
        amsTask.setIsDelete(0);
        amsTask.setAciAccept(0);
        amsTask.setIkey((long) genIKey(amsTask.getTaskNo()));
        amsTask.setPriority(10);
        // 充电任务直接传参数
        if (wcsTask.getBusinessType().equals(AmsConstant.TASK_BUSINESS_TYPE.TASK_POWER.getValue())) {
            amsTask.setStFrom(Integer.parseInt(wcsTask.getLocationFrom()));
            amsTask.setStTo(Integer.parseInt(wcsTask.getLocationTo()));
        } else {
            amsTask.setStFrom(locFrom.getAgvStation().intValue());
            amsTask.setStTo(locTo.getAgvStation().intValue());
        }
        amsTask.setExt1(wcsTask.getExt1());
        amsTask.setExt2(wcsTask.getExt2());
        amsTask.setExt3(wcsTask.getExt3());
        int result = amsTaskService.insertAmsTask(amsTask);
        if (result > 0) {
            //更新
            return AjaxResult.success("下发成功");
        } else {
            return AjaxResult.error("下发失败");
        }
    }

    @Override
    public AjaxResult sendTaskList(List<WcsTask> wcsTaskList) {
        return null;
    }

    @Transactional
    @Override
    public void autoSend() {
        List<WcsTask> wcsTaskList = wcsTaskService.selectWcsUnallocated(WmsConstant.WAREHOUSE_ID);
        if (wcsTaskList != null && wcsTaskList.size() > 0) {
            for (WcsTask wcsTask : wcsTaskList) {
                //如果是充电任务直接下发
                if (wcsTask.getBusinessType().equals(AmsConstant.TASK_BUSINESS_TYPE.TASK_POWER.getValue()) ||
                        wcsTask.getBusinessType().equals(AmsConstant.TASK_BUSINESS_TYPE.TASK_m.getValue()) ||
                        wcsTask.getBusinessType().equals(AmsConstant.TASK_BUSINESS_TYPE.TASK_74.getValue())
                ) {
                    log.info("定时充电/盘点取消任务直接下发");
                    sendTask(wcsTask);
                    wcsTask.setState(2L);
                    wcsTaskService.updateWcsTask(wcsTask);
                    break;
                }
                // 出库任务分配目标库位
                if (StringUtils.isBlank(wcsTask.getLocationTo())) {
                    // 出库均匀任务判断
                    BaseLocationInfo baseLocationInfo = baseLocationInfoService.selectBaseLocationInfoByIdOrNo(wcsTask.getLocationFrom(), WmsConstant.WAREHOUSE_ID);
                    String agvNo = baseLocationInfo.getFoldedTag(); // 车号
                    boolean isCan = uniformOutboundTaskJudgment(agvNo);
                    if (!isCan) {
                        continue;
                    }
                    // 分配目标库位
                    AjaxResult ajaxResult = allocateTargetLocation(wcsTask);
                    if (!ajaxResult.isSuccess()) {
                        continue;
                    } else {
                        BaseLocationInfo locationInfo = ajaxResult.getDataParseObject(BaseLocationInfo.class);
                        wcsTask.setAreaTo(locationInfo.getZoneId().toString());
                        wcsTask.setLocationTo(locationInfo.getId().toString());
                        wcsTaskService.updateWcsTask(wcsTask);
                        // 修改出库位置是哪台车在做
                        BaseLocationInfo baseLocationInfoUpdate = new BaseLocationInfo();
                        baseLocationInfoUpdate.setId(locationInfo.getId());
                        baseLocationInfoUpdate.setFoldedTag(agvNo);
                        baseLocationInfoUpdate.setStockStatus(WmsConstant.STOCK_STATUS.STOCK10.getValue());
                        baseLocationInfoService.updateBaseLocationInfo(baseLocationInfoUpdate);

                    }
                }

                //转发任务
                if (StringUtils.isNotEmpty(wcsTask.getTaskType())
                        && wcsTask.getTaskType().equals(WmsConstant.TASK_TYPE.FORWARD.getValue())) {
                    sendTask(wcsTask);
                    wcsTask.setState(10L);
                    wcsTaskService.updateWcsTask(wcsTask);
                    break;
                }

                try {
                    //任务下发判断
                    businessService.taskDispatchStack(wcsTask);
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 出库均匀任务判断
     *
     * @return true 可以分配目标点 false 不可分配目标点
     */
    private boolean uniformOutboundTaskJudgment(String agvNo) {
        int lock = 0; // 占用
        int goods = 0; // 有货
        // 查出两个出库缓存位
        List<BaseLocationInfo> baseLocationInfos = baseLocationInfoService.selectLocatinListByZoneId(WmsConstant.ZONE_TYPE.ZONE_OUT.getValue());
        // 判断两个位置有几个任务占用
        List<BaseLocationInfo> baseLocationInfosLock
                = baseLocationInfos.stream()
                .filter(v -> v.getStockStatus().equals(WmsConstant.STOCK_STATUS.STOCK10.getValue()))
                .collect(Collectors.toList());
        lock = baseLocationInfosLock.size();
        // 如果两个都占用 返回false
        if (lock == 2) {
            return false;
        }
        // 判断两个位置有几个有货
        List<BaseLocationInfo> baseLocationInfosGoods
                = baseLocationInfos.stream()
                .filter(v -> v.getIsEmpty().equals(WmsConstant.IS_YES.N.name()))
                .collect(Collectors.toList());
        goods = baseLocationInfosGoods.size();
        // 如果两个都占用
        if (goods == 2) {
            return false;
        }
        // 如果没有占用
        if (lock == 0) {
            return true;
        }
        // 如果一个库位被占用
        BaseLocationInfo locationInfoLock = baseLocationInfosLock.get(0);
        String agvNoIng = locationInfoLock.getFoldedTag(); // 正在任务的车号
        return !agvNo.equals(agvNoIng);
    }

    /**
     * 分配出库目标库位
     * 目标库位为待分配
     *
     * @param wcsTask
     * @return
     */
    private AjaxResult allocateTargetLocation(WcsTask wcsTask) {
        List<BaseLocationInfo> locationToList = this.convertLocation(WmsConstant.ZONE_TYPE.ZONE_OUT.getValue().toString()
                , WmsConstant.WAREHOUSE_ID, null);
        BaseLocationInfo locationTo = this.zoneLocationAllocation(locationToList, Long.valueOf(wcsTask.getExt8()));
        if (locationTo == null) {
            return AjaxResult.error("");
        }
        return AjaxResult.success("", locationTo);
    }
    private BaseLocationInfo zoneLocationAllocation(List<BaseLocationInfo> locationInfoList, Long token) {
        BaseLocationInfo locationInfo = null;
        for (BaseLocationInfo b : locationInfoList) {
            if (!b.getStockStatus().equals("00") || !b.getIsEmpty().equals("Y") || redisCache.checkIsLock(RedisKey.LOCK_LOCATION + b.getId())) {
                continue;
            }
            if (!redisCache.lockCacheObject(RedisKey.LOCK_LOCATION + b.getId(), b.getId().toString(), token)) {
                continue;
            }
            locationInfo = b;
            break;
        }
        return locationInfo;
    }

    @Transactional
    @Override
    public boolean taskDispatchStack(WcsTask wcsTask) {
        /* boolean isSplit = taskService.taskSplit(wcsTask);
        //判断是否拆分如果拆分了直接跳过
        if(isSplit){
            return false;
        }*/

        //最后要执行的任务
        WcsTask currentTask = new WcsTask();
        //来源库位
        BaseLocationInfo basLocationInfoFrom = null;
        //目标区域
        BaseLocationZone basLocationZoneTo = null;

        //起始库位
        basLocationInfoFrom = baseLocationInfoService.selectBaseLocationInfoById(Long.parseLong(wcsTask.getLocationFrom()));
        //目标库位
        BaseLocationInfo locationInfoTo = baseLocationInfoService.selectBaseLocationInfoById(Long.parseLong(wcsTask.getLocationTo()));
        //TODO 前置任务未完成不进行下发
        if (businessService.taskDispatchCheck(wcsTask) == false) {
            return false;
        }

        if (basLocationInfoFrom != null) {

            if (basLocationInfoFrom.getIsEmpty().equals("Y")) {
                wcsTask.setRemark("起始库位为空无法进行任务");
                wcsTaskService.updateWcsTask(wcsTask);
                return false;
            }

            //起始库位巷道检测(起始库位检测是否同巷道)
            if (!StringUtils.isEmpty(basLocationInfoFrom.getColNo())) {
                List<BaseLocationInfo> locationInfoList = baseLocationInfoMapper.laneCheck(basLocationInfoFrom.getColNo(), "LANE_FROM", WmsConstant.WAREHOUSE_ID);
                if (locationInfoList != null && locationInfoList.size() > 0) {
                    wcsTask.setRemark("起始库位同列或同巷道有车辆在任务中，等待其他任务完成");
                    wcsTaskService.updateWcsTask(wcsTask);
                    return false;
                }
            }
        }

        //起始库位是地堆需要判断是否有阻挡
        if (basLocationInfoFrom.getLocationType().equals("2")) {
            //判断队列中是否有阻挡在当前任务之前
            List<WcsTaskLocationDTO> locationDTOS = wcsTaskService.selectTaskByColNo(basLocationInfoFrom.getColNo(), basLocationInfoFrom.getColIndex(), basLocationInfoFrom.getZoneId(), null);
            if (locationDTOS.size() > 0) {
                wcsTask.setRemark("队列中有其他任务阻挡，让其他任务先执行");
                wcsTaskService.updateWcsTask(wcsTask);
                return false;
            }

            //判断出库库位前是否有阻挡
            List<BaseLocationInfo> beforeLoc = baseLocationInfoService.selectBeforeLocationByColNo(basLocationInfoFrom.getColNo(), basLocationInfoFrom.getColIndex());
            if (beforeLoc != null) {
                for (BaseLocationInfo b : beforeLoc) {
                    //如果前面库位不为空，或者状态占用
                    //TODO 去除已经在任务中的
                    if (b.getIsEmpty().equals("N")) {
                        wcsTask.setRemark("有阻挡物，任务无法执行");
                        wcsTaskService.updateWcsTask(wcsTask);
                        return false;
                    }
                }
            }
        }

        currentTask = wcsTask;

        //目标库位如果是地堆需要判断是否有阻挡
        if (locationInfoTo != null && locationInfoTo.getLocationType().equals("2")) {
            List<BaseLocationInfo> beforeLoc = baseLocationInfoService.selectBeforeLocationByColNo(locationInfoTo.getColNo(), locationInfoTo.getColIndex());
            if (beforeLoc != null) {
                for (BaseLocationInfo b : beforeLoc) {
                    //跳过起始库位
                    if (b.getId().equals(locationInfoTo.getId())) {
                        continue;
                    }
                    //如果前面库位不为空，或者状态占用
                    //TODO 排除已经在任务中的
                    if (b.getIsEmpty().equals("N")) {
                        currentTask.setRemark("目标库位前方有阻挡1");
                        currentTask.setUpdateDate(new Date());
                        wcsTaskService.updateWcsTask(currentTask);
                        return false;
                    }
                }
            }

            List<WcsTaskLocationDTO> dtos = wcsTaskService.selectTaskByColNoAfter(locationInfoTo.getColNo(), locationInfoTo.getColIndex(), locationInfoTo.getZoneId(), null);
            if (dtos != null && dtos.size() > 0) {
                currentTask.setRemark("目标库位同列有未完成的任务");
                wcsTaskService.updateWcsTask(currentTask);
                return false;
            }

        }

        //查询是否有更里面的位置可以存放
        if (locationInfoTo != null) {
            if (locationInfoTo.getZoneId() != 10) {
                String locationtoTmp = "";
                List<BaseLocationInfoSameColDTO> b = baseLocationInfoService.selectSameColCanToLoc(locationInfoTo.getColNo(), locationInfoTo.getColIndex());
                for (BaseLocationInfoSameColDTO bt : b) {
                    if (bt.getIsOb() == false) {
                        locationtoTmp = bt.getId().toString();
                    } else {
                        break;
                    }
                }
                if (!StringUtils.isEmpty(locationtoTmp)) {
                    wcsTask.setLocationTo(locationtoTmp);
                    wcsTaskService.updateWcsTask(wcsTask);

                    //释放原库位
                    locationInfoTo.setStockStatus("00");
                    baseLocationInfoService.updateBaseLocationInfo(locationInfoTo);

                    //占用新库位
                    BaseLocationInfo newlocationInfoTo = baseLocationInfoService.selectBaseLocationInfoById(Long.parseLong(locationtoTmp));
                    newlocationInfoTo.setStockStatus("10");
                    baseLocationInfoService.updateBaseLocationInfo(newlocationInfoTo);
                }
            }
        }

        currentTask.setState(10L);
        currentTask.setRemark("");
        if (wcsTaskService.updateWcsTask(currentTask) > 0) {
            AjaxResult result = businessService.sendTask(currentTask);
            if ((int) result.get(AjaxResult.CODE_TAG) == 500) {
                throw new ServiceException("自动下发任务失败:" + result.get("msg"));
            }
            return true;
        } else {
            return false;
        }
    }

    @Override
    public boolean taskDispatchCheck(WcsTask wcsTask) {
        if (!StringUtils.isEmpty(wcsTask.getBeforeTask())) {
            List<WcsTask> taskFindBeforeRecord = wcsTaskMapper.selectBeforeTask(wcsTask.getBeforeTask());
            if (taskFindBeforeRecord != null && taskFindBeforeRecord.size() > 0) {
                //log.info("前置任务未完成主任务无法下发{}",wcsTask);
                wcsTask.setRemark("前置任务未完成主任务无法下发");
                wcsTaskService.updateWcsTask(wcsTask);
                return false;
            }
        }
        return true;
    }

    /**
     * 库存移动
     *
     * @param invLotLocIdMoveForm
     * @return
     */
    @Transactional
    @Override
    public AjaxResult move(InvLotLocIdMoveForm invLotLocIdMoveForm) {
        String locationFrom = invLotLocIdMoveForm.getLocationFrom();
        String locationTo = invLotLocIdMoveForm.getLocationTo();
        String reason = invLotLocIdMoveForm.getReason();
        String updateBy = invLotLocIdMoveForm.getUpdateBy();
        Long warehouseId = invLotLocIdMoveForm.getWarehouseId();
        BaseLocationInfo baseLocationFrom = null;
        BaseLocationInfo baseLocationTo = null;
        String palletNo;

        // 起始和目标库位
        baseLocationFrom = baseLocationInfoService.selectBaseLocationInfoByIdOrNo(locationFrom, warehouseId);
        if (baseLocationFrom.getZoneId().equals(WmsConstant.ZONE_TYPE.ZONE_VIRTUAL.getValue())) {
            return AjaxResult.error("起始库位虚拟库位不可移库！");
        }
        baseLocationTo = baseLocationInfoService.selectBaseLocationInfoByIdOrNo(locationTo, warehouseId);
        if (baseLocationTo.getZoneId().equals(WmsConstant.ZONE_TYPE.ZONE_VIRTUAL.getValue())) {
            // 如果起始库位是出库位 目标库位是线边 直接移动库存
            if (baseLocationFrom.getZoneId().equals(WmsConstant.ZONE_TYPE.ZONE_OUT.getValue())
                    && baseLocationTo.getId().compareTo(WmsConstant.LOC_SORTATION02_CACHE) == 0) {
                return moveDirect(invLotLocIdMoveForm);
            }
            return AjaxResult.error("目标库位虚拟库位不可移库！");
        }
        // 如果起始区域位出库位 目标位回库位 直接移动库存
        if (baseLocationFrom.getZoneId().equals(WmsConstant.ZONE_TYPE.ZONE_OUT.getValue())
                && baseLocationTo.getZoneId().equals(WmsConstant.ZONE_TYPE.ZONE_RE.getValue())) {
            return moveDirect(invLotLocIdMoveForm);
        }

        // 验证起始库位
        Boolean isIdleFrom = baseLocationInfoService.verifyLocationIsIdle(locationFrom, warehouseId);
        if (!isIdleFrom) {
            return AjaxResult.error("起始库位需要空闲状态！");
        }
        // 验证目标库位
        Boolean isIdle = baseLocationInfoService.verifyLocationIsIdle(locationTo, warehouseId);
        if (!isIdle) {
            return AjaxResult.error("目标库位需要空闲状态！");
        }
        Boolean isInStock = baseLocationInfoService.verifyLocationIsInStock(locationTo, warehouseId);
        if (isInStock) {
            return AjaxResult.error("目标库位有货！");
        }

        // 验证起始库位必须有货
        List<InvLotLocIdLotattVO> invLotLocIdLotattVOList = invLotLocIdService.selectInvLocIdLotattByLocationId(baseLocationFrom.getId());
        if (invLotLocIdLotattVOList.size() == 0) {
            return AjaxResult.error("起始库位需要有库存！");
        }
        palletNo = invLotLocIdLotattVOList.get(0).getLotatt07();

        // 根据起始库位判断目标库位是否可以放置
//        Boolean canPut = iBusinessService.checkLocCanPut(baseLocationFrom, baseLocationTo);
//        if (!canPut) {
//            return AjaxResult.error("所选的目标库位超高！");
//        }

        // 下发移库任务
        String taskNo = System.currentTimeMillis() + "";
        WcsTask wcsTask = new WcsTask();
        wcsTask.setTaskNo(taskNo);
        if (locationFrom != null) {
            wcsTask.setAreaFrom(baseLocationFrom.getZoneId().toString());
            wcsTask.setLocationFrom(baseLocationFrom.getId().toString());
        }
        if (locationTo != null) {
            wcsTask.setAreaTo(baseLocationTo.getZoneId() + "");
            wcsTask.setLocationTo(baseLocationTo.getId().toString());
        }
        wcsTask.setState(9L);
        wcsTask.setPriority(1L);
        wcsTask.setShopId(WmsConstant.WAREHOUSE_ID.toString());
        wcsTask.setCreateDate(new Date());
        wcsTask.setBusinessType("01");
        wcsTask.setTaskType(WmsConstant.TASK_TYPE.FORWARD.getValue());
        wcsTask.setExt8("");
        wcsTask.setExt7("10"); // 任务类型 10代表移库
        wcsTask.setExt5(palletNo); // 托盘号
        addTask(wcsTask);

        // 锁定起始和目标库位任务状态
        baseLocationInfoService.lockLocationStockStatus(baseLocationFrom.getId(), baseLocationTo.getId()
                , warehouseId, updateBy);

        // 更新托盘绑定库位关系
        wmsBoxInfoService.updateLocationBind(palletNo, baseLocationTo.getId(), null);
        return AjaxResult.success("执行成功");
    }


    @Transactional
    @Override
    public AjaxResult moveDirect(InvLotLocIdMoveForm invLotLocIdMoveForm) {
        String locationFrom = invLotLocIdMoveForm.getLocationFrom();
        String locationTo = invLotLocIdMoveForm.getLocationTo();
        String reason = invLotLocIdMoveForm.getReason();
        String updateBy = invLotLocIdMoveForm.getUpdateBy();
        Long warehouseId = invLotLocIdMoveForm.getWarehouseId();
        BaseLocationInfo baseLocationFrom = null;
        BaseLocationInfo baseLocationTo = null;
        String palletNo;

        // 起始和目标库位
        baseLocationFrom = baseLocationInfoService.selectBaseLocationInfoByIdOrNo(locationFrom, warehouseId);
        if (baseLocationFrom.getZoneId().equals(WmsConstant.ZONE_TYPE.ZONE_VIRTUAL.getValue())) {
            return AjaxResult.error("起始库位不可为虚拟库位！");
        }
        baseLocationTo = baseLocationInfoService.selectBaseLocationInfoByIdOrNo(locationTo, warehouseId);
        if (baseLocationTo.getZoneId().equals(WmsConstant.ZONE_TYPE.ZONE_VIRTUAL.getValue())) {
            // 起始库位库存需要为备货库存才可以转移到虚拟库位
            boolean con = false;
            List<InvLotLocIdLotattVO> invLotLocIdLotattVOList = invLotLocIdService.selectInvLocIdLotattByLocationId(baseLocationFrom.getId());
            for (InvLotLocIdLotattVO invLotLocIdLotattVO : invLotLocIdLotattVOList) {
                if (com.warewms.common.utils.string.StringUtils.isNotEmpty(invLotLocIdLotattVO.getLotatt14())) {
                    con = true;
                }
            }
            if (!con) {
                return AjaxResult.error("起始库位需要为备货库存才可以转移到虚拟区！");
            }
        }

        // 验证起始库位
        Boolean isIdleFrom = baseLocationInfoService.verifyLocationIsIdle(locationFrom, warehouseId);
        if (!isIdleFrom) {
            return AjaxResult.error("起始库位需要空闲状态！");
        }
        // 验证目标库位
        Boolean isIdle = baseLocationInfoService.verifyLocationIsIdle(locationTo, warehouseId);
        if (!isIdle) {
            return AjaxResult.error("目标库位需要空闲状态！");
        }
        Boolean isInStock = baseLocationInfoService.verifyLocationIsInStock(locationTo, warehouseId);
        if (isInStock
                && !baseLocationTo.getZoneId().equals(WmsConstant.ZONE_TYPE.ZONE_VIRTUAL.getValue())) {
            return AjaxResult.error("目标库位有货！");
        }

        // 验证起始库位必须有货
        List<InvLotLocIdLotattVO> invLotLocIdLotattVOList = invLotLocIdService.selectInvLocIdLotattByLocationId(baseLocationFrom.getId());
        if (invLotLocIdLotattVOList.size() == 0) {
            return AjaxResult.error("起始库位需要有库存！");
        }
        palletNo = invLotLocIdLotattVOList.get(0).getLotatt07();

        // 转移库存
        int stockTransfer = invLotLocIdService.stockTransfer(baseLocationFrom.getId(), null, baseLocationTo.getId());
        if (stockTransfer <= 0) {
            return AjaxResult.success("库存转移失败！");
        }
        // 更新起始库位空闲无货
        baseLocationInfoService.updateLocationIdleAndEmpty(baseLocationFrom.getId(), warehouseId, updateBy);
        // 更新目标库位空闲有货
        baseLocationInfoService.updateLocationIdleAndNoEmpty(baseLocationTo.getId(), warehouseId, updateBy);

        // 更新托盘绑定库位关系
        wmsBoxInfoService.updateLocationBind(palletNo, baseLocationTo.getId(), null);
        return AjaxResult.success("操作成功！");
    }

    @Override
    public AjaxResult movePalletTo(String palletNo, String locationTo, String isCallCar, String reason
            , Long warehouseId, String updateBy) {
        String locationFrom;
        boolean callCar = false; // 是否叫车（不传默认不叫车）
        if (com.warewms.common.utils.string.StringUtils.isEmpty(palletNo)) {
            AjaxResult.error("托盘号不能为空！");
        }
        WmsBoxInfo wmsBoxInfo = wmsBoxInfoService.selectWmsBoxInfoByBoxNo(palletNo);
        if (wmsBoxInfo == null) {
            return AjaxResult.error("不存在对应托盘信息！" + palletNo);
        }
        locationFrom = wmsBoxInfo.getLocationId().toString();
        if (com.warewms.common.utils.string.StringUtils.isNotEmpty(isCallCar)) {
            callCar = isCallCar.equals(WmsConstant.IS_YES.Y.getValue());
        }

        // 执行库存移动
        InvLotLocIdMoveForm moveForm = new InvLotLocIdMoveForm();
        moveForm.setLocationFrom(locationFrom);
        moveForm.setLocationTo(locationTo);
        moveForm.setReason(reason);
        moveForm.setWarehouseId(warehouseId);
        moveForm.setUpdateBy(updateBy);
        // 是否叫车
        if (callCar) {
            return this.move(moveForm);
        }
        return this.moveDirect(moveForm);
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public AjaxResult doCheckout(CheckOutInfoForm check) {
//        String orderNo = check.getOrderNo();
        String palletNo = check.getPalletNo();
        // 验证出库单号
//        WmsDocOrderHeader wmsDocOrderHeader = wmsDocOrderHeaderService.selectWmsDocOrderHeaderByErpNo(orderNo);
//        if (wmsDocOrderHeader == null) {
//            return AjaxResult.error("对应出库单号不存在！");
//        }
        //生成任务呼叫到接驳位
        BaseLocationInfo baseLocationInfo = baseLocationInfoService.selectBaseLocationInfoByIdOrNo(check.getLocationNo(), WmsConstant.WAREHOUSE_ID);
        FlowConfigHeaderVO flowConfigHeaderVO = flowConfigHeaderService.selectFlowConfigHeaderById((long) WmsConstant.FLOW_ID_SO);
        AgvCallDTO agvCallDTO = new AgvCallDTO();
        agvCallDTO.setId(flowConfigHeaderVO.getId());
        agvCallDTO.setLocationFrom(baseLocationInfo.getId().toString());
        agvCallDTO.setLocationTo(null);
        agvCallDTO.setPalletNo(palletNo);
        agvCallDTO.setWarehouseId(WmsConstant.WAREHOUSE_ID);
        // 参数内容过长无法添加
        agvCallDTO.setExtParam("");
        agvCallDTO.setOrderNo(com.warewms.common.utils.string.StringUtils.EMPTY);
        agvCallDTO.setTaskType(WmsConstant.FLOW_ID_SO + "");
        AjaxResult result = businessService.agvCall(flowConfigHeaderVO, agvCallDTO);
        if ((int) result.get(AjaxResult.CODE_TAG) == 500) {
            throw new ServiceException("任务生成失败：" + result.getMsg() + ",库位：" + baseLocationInfo.getLocationNo());
        }
        return AjaxResult.success("操作成功");
    }
}