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

package com.ruoyi.ams.business;

import com.alibaba.fastjson.JSON;
import com.ruoyi.ams.agv.ndc.common.ByteUtil;
import com.ruoyi.ams.agv.ndc.common.CRC16Util;
import com.ruoyi.ams.agv.ndc.domain.AmsTask;
import com.ruoyi.ams.agv.ndc.service.IAmsTaskService;
import com.ruoyi.ams.box.service.IWmsBoxInfoService;
import com.ruoyi.ams.config.domain.AsnSoStrategy;
import com.ruoyi.ams.config.domain.dto.*;
import com.ruoyi.ams.config.domain.vo.FlowConfigHeaderVO;
import com.ruoyi.ams.config.mapper.AsnSoStrategyMapper;
import com.ruoyi.ams.config.service.IFlowConfigHeaderService;
import com.ruoyi.ams.config.service.LocationAllocationStrategy;
import com.ruoyi.ams.inv.mapper.InvLotLocIdMapper;
import com.ruoyi.ams.inv.service.IInvLotAttService;
import com.ruoyi.ams.inv.service.IInvLotLocIdService;
import com.ruoyi.ams.task.domain.WcsTask;
import com.ruoyi.ams.task.dto.WcsTaskLocationDTO;
import com.ruoyi.ams.task.mapper.WcsTaskMapper;
import com.ruoyi.ams.task.service.IWcsTaskService;
import com.ruoyi.base.constant.Constant;
import com.ruoyi.base.domain.BaseLocationInfo;
import com.ruoyi.base.domain.BaseLocationZone;
import com.ruoyi.base.domain.BaseSku;
import com.ruoyi.base.domain.dto.BaseLocationInfoSameColDTO;
import com.ruoyi.base.domain.vo.BaseLocationLotattVO;
import com.ruoyi.base.mapper.BaseLocationInfoMapper;
import com.ruoyi.base.service.IBaseLocationInfoService;
import com.ruoyi.base.service.IBaseSkuService;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.core.redis.RedisKey;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.uuid.SnowflakeIdWorker;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
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 LocationAllocationStrategy locationAllocationStrategy;
    @Autowired
    private InvLotLocIdMapper invLotLocIdMapper;
    @Autowired
    private IInvLotLocIdService invLotLocIdService;
    @Autowired
    private IInvLotAttService iInvLotAttService;
    @Autowired
    private WcsTaskMapper wcsTaskMapper;
    @Autowired
    private AsnSoStrategyMapper asnSoStrategyMapper;
    @Autowired
    private BaseLocationInfoMapper baseLocationInfoMapper;
    @Autowired
    private IBaseSkuService baseSkuService;
    @Autowired
    private RedisCache redisCache;
    @Autowired
    private IWmsBoxInfoService wmsBoxInfoService;
    @Autowired
    private IWcsTaskService wcsTaskService;
    @Autowired
    private IAmsTaskService amsTaskService;
    @Autowired
    private IFlowConfigHeaderService flowConfigHeaderService;

    public static int geniKey(String taskNo) {
        int res = CRC16Util.calcCrc16(ByteUtil.string2byteArray(taskNo));
        if (res == 0) {
            BigDecimal t = new BigDecimal(taskNo);
            t = t.add(BigDecimal.ONE);
            return geniKey(t.toString());
        } else {
            return res;
        }
    }

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

        List<AgvCallDTO> agvCallDTOList = new ArrayList<>();
        agvCallDTO.setWarehouseId(Constant.WAREHOUSE_ID);
        agvCallDTOList.add(agvCallDTO);
        return businessService.agvCall(flowConfigHeaderVO, agvCallDTOList);
    }

    @Override
    public AjaxResult agvCall(FlowConfigHeaderVO flowConfigHeaderVO, AgvCallDTO agvCallDTO) {
        List<AgvCallDTO> agvCallDTOList = new ArrayList<>();
        List<AgvCallItemDTO> callItemDTOList = new ArrayList<>();
        AgvCallItemDTO callItemDTO = new AgvCallItemDTO();
        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")) {
                    // 统计入库箱数
                    List<AgvCallItemDTO> agvCallItemDTOList = agvCallDTO.getAgvCallItemDTOList();
                    int boxNum = agvCallItemDTOList.size();
//                    int boxNum = agvCallItemDTOList.stream()
//                            .mapToInt(v -> v.getQty().intValue())
//                            .reduce(Integer::sum).getAsInt();
                    asnSoStrategy.setAsnHeightLimit(boxNum + "");
                    log.info("统计箱数量：" + boxNum);

                    List<BaseLocationInfo> locationFromList = this.convertLocation(paramLocationFrom, agvCallDTO.getWarehouseId(), null);
                    List<BaseLocationInfo> locationToList = this.convertLocation(paramLocationTo, agvCallDTO.getWarehouseId(), "shift_no+ 0,shift_index");
                    locationFrom = this.zoneLocationAllocation(locationFromList, "locationFrom", "ASN", asnSoStrategy, token);
                    locationTo = this.zoneLocationAllocation(locationToList, "locationTo", "ASN", asnSoStrategy, token);
                    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);
                    HashMap<String, String> hashMap = JSON.parseObject(JSON.toJSONString(agvCall.getLotattDTO()), HashMap.class);
                    List<BaseLocationInfo> locationFromList = baseLocationInfoMapper.selectSortedLocationLotattListByZoneIdListOrderBy(zoneIdList
                            , agvCallDTO.getWarehouseId(), hashMap, agvCall.getSku(), "inv.create_time");
                    locationFrom = this.zoneLocationAllocation(locationFromList, "locationFrom", "SO", asnSoStrategy, token);
                    locationTo = this.zoneLocationAllocation(locationToList, "locationTo", "SO", asnSoStrategy, token);
                    wcsTaskList.addAll(this.genTask(locationFrom, locationTo, flowConfigHeaderVO, agvCallDTO, token));

                } else if (flowConfigHeaderVO.getFlowType().equals("MV")) {
                    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, token);
                    locationTo = this.zoneLocationAllocation(locationToList, "locationTo", "MV", asnSoStrategy, token);
                    // 初始化库存
                    if (agvCallDTO.getAgvCallItemDTOList().size() > 0) {
                        iInvLotAttService.deleteInvLotAttBylocationId(locationFrom.getId());
                        invLotLocIdService.deleteInvLotLocIdById(locationFrom.getId());
                        invLotLocIdService.initInv(locationFrom.getId().toString(), agvCallDTO);
                    }
                    wcsTaskList.addAll(this.genTask(locationFrom, locationTo, flowConfigHeaderVO, agvCallDTO, token));
                }
            }
            return AjaxResult.success("任务下发成功");
        } catch (Exception e) {
            redisCache.unlockCacheObject(token); // 异常捕获的话就不能释放锁
            throw new ServiceException(e.getMessage(), token);
        }
    }

    @Transactional
    @Override
    public BaseLocationInfo inLocationAllocation(InWarehouseDTO inWarehouseDTO, Long token) {
        /**
         * 根据sku查询可以存放的zone
         * 根据每个zone的配置去分配可以存放的库位
         *
         * force
         * optimization
         * ignore
         */
        if (!StringUtils.isEmpty(inWarehouseDTO.getLocationTo())) { //指定库位则直接返回库位
            BaseLocationInfo baseLocationInfo = baseLocationInfoService.selectBaseLocationInfoByIdOrNo(inWarehouseDTO.getLocationTo(), inWarehouseDTO.getWarehouseId());
            return baseLocationInfo;
        } else {
            if (StringUtils.isEmpty(inWarehouseDTO.getLocationZoneTo()) && StringUtils.isEmpty(inWarehouseDTO.getLocationTo())) { //不指定目标库位和区域
                // 没有指定目标的根据sku进行匹配并进行分配
                // 如果可以混放的区域不匹配物料也可以选择，否则只选择可以存放的区域
                AsnSoStrategy asnSoStrategy = asnSoStrategyMapper.selectAsnSoStrategy();
                BaseSku baseSku = baseSkuService.selectBaseSkuByCustomerId(Constant.CUSTOMER_ID, inWarehouseDTO.getSku());
                //判断是否强制同物料靠近，
                LotattDTO lotattDTO = inWarehouseDTO.getLotattDTO();
                Map<String, String> lotattMap = new HashMap<>();
                if (asnSoStrategy.getAsnSameLotatt1Flag().equals("optimization")) {
                    lotattMap.put(asnSoStrategy.getAsnSameLotatt1Value(), lotattDTO.getAttr(asnSoStrategy.getAsnSameLotatt1Value()));
                }
                if (asnSoStrategy.getAsnSameLotatt2Flag().equals("optimization")) {
                    lotattMap.put(asnSoStrategy.getAsnSameLotatt2Value(), lotattDTO.getAttr(asnSoStrategy.getAsnSameLotatt2Value()));
                }
                List<BaseLocationInfo> locationInfoList = new ArrayList<>();
                if (asnSoStrategy.getAsnSameSku().equals("force")) {
                    List<String> colNo = baseLocationInfoMapper.selectSameSkuColNo(baseSku.getSku(), null, lotattMap);
                    for (String s : colNo) {
                        List<BaseLocationInfo> locs = baseLocationInfoService.selectNeighborLocation(s, null);
                        locationInfoList.addAll(locs);
                    }
                    if (colNo == null || colNo.size() == 0) {
                        colNo = baseLocationInfoMapper.selectSameSkuTypeColNo(baseSku.getSkuType(), null);
                        for (String s : colNo) {
                            List<BaseLocationInfo> locs = baseLocationInfoService.selectNeighborLocation(s, null);
                            locationInfoList.addAll(locs);
                        }
                    }
                    // List<BaseLocationInfo> locs = baseLocationInfoMapper.selectLocationByColNos(colNo);
                } else if (asnSoStrategy.getAsnSameSku().equals("optimization") || asnSoStrategy.getAsnSameSkuType().equals("optimization")) {
                    List<String> skuColNo = baseLocationInfoMapper.selectSameSkuColNo(baseSku.getSku(), null, lotattMap);
                    List<String> skuTypeColNo = baseLocationInfoMapper.selectSameSkuColNo(baseSku.getSkuType(), null, lotattMap);
                    List<String> cols = new ArrayList<>();
                    cols.addAll(skuColNo);
                    cols.addAll(skuTypeColNo);
                    List<BaseLocationInfo> locs = baseLocationInfoMapper.selectLocationByColNos(cols);
                    locationInfoList.addAll(locs);
                } else {
                    locationInfoList = baseLocationInfoMapper.selectLocationBindSku(baseSku.getSkuType());
                }
                return locationAllocationStrategy.filterLockLocation(locationInfoList, inWarehouseDTO, asnSoStrategy, token);
            } else {
                // 指定区域的
                List<BaseLocationInfo> locationInfoList = baseLocationInfoService.selectSortedLocatinListByZoneId(Long.parseLong(inWarehouseDTO.getLocationZoneTo()), inWarehouseDTO.getWarehouseId(), null);
                return locationAllocationStrategy.filterLockLocation(locationInfoList, token);
            }
        }
    }

    @Transactional
    @Override
    public BaseLocationInfo outInvAllocation(OutWarehouseDTO outWarehouseDTO, Long token) {
        /**
         * 指定位置出库
         */
        if (!StringUtils.isEmpty(outWarehouseDTO.getLocationFrom())) {
            BaseLocationInfo baseLocationInfo = baseLocationInfoService.selectBaseLocationInfoByIdOrNo(outWarehouseDTO.getLocationFrom(), outWarehouseDTO.getWarehouseId());
            return baseLocationInfo;
        } else {
            //未指定明确位置出库
            List<Long> zoneIdList = new ArrayList<>();
            if (!StringUtils.isEmpty(outWarehouseDTO.getLocationZoneFrom())) {
                zoneIdList.add(Long.parseLong(outWarehouseDTO.getLocationZoneFrom()));
            } else {
                List<BaseLocationLotattVO> zoneList = invLotLocIdMapper.selectInvZoneBySkuLotatt(outWarehouseDTO.getSku(), outWarehouseDTO.getSkuType(), outWarehouseDTO.getLotattDTO());
                for (BaseLocationLotattVO vo : zoneList) {
                    zoneIdList.add(vo.getZoneId());
                }
            }
            LotattDTO lotattDTO = outWarehouseDTO.getLotattDTO();
            List<BaseLocationLotattVO> locationInfoList = baseLocationInfoMapper.selectSortedLocationLotattListByZoneIdList(zoneIdList, outWarehouseDTO.getWarehouseId(), lotattDTO.getAttr());
            AsnSoStrategy asnSoStrategy = asnSoStrategyMapper.selectAsnSoStrategy();
            return locationAllocationStrategy.filterLockInv(locationInfoList, outWarehouseDTO, asnSoStrategy, token);
        }
    }

    @Override
    public BaseLocationInfo zoneLocationAllocation(List<BaseLocationInfo> locationInfoList, String locationType
            , String type, AsnSoStrategy asnSoStrategy, 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;
                    }
                    // 第六层不能放数量超过2的货
                    int boxNum = Integer.parseInt(asnSoStrategy.getAsnHeightLimit());
                    if (b.getShiftNo().equals("6")) {
                        if (boxNum > 2) continue;
                    } else {
                        // 其他层数放置箱子数量不能超过6
                        if (boxNum > 6) {
                            log.error("入库箱数量不能超过6！");
                            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;
                    }
                    // 判断起始库位上的库存质检状态是否可以出库
                    boolean con = invLotLocIdService.verifyInventoryCanOutbound(b.getId().toString());
                    if (!con) {
                        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;
                }

                //进行判断
                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);
                }
            }
        }
        return locationInfo;
    }

    @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")) {
            if (locationFrom == null) {
                throw new ServiceException("起始库位不能为空", token);
            }
        }
        if (flowConfigHeaderVO.getLocationToStrategyFlag().equals("N")) {
            if (locationTo == null) {
                throw new ServiceException("目标库位不能为空", token);
            }
        }

        List<WcsTask> wcsTaskList = new ArrayList<>();
        if (StringUtils.isEmpty(flowConfigHeaderVO.getRootFlow())) {
            String taskNo = System.currentTimeMillis() + "";
            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(9L);
            wcsTask.setPriority(1L);
            wcsTask.setShopId(Constant.WAREHOUSE_ID.toString());
            wcsTask.setCreateDate(new Date());
            wcsTask.setBusinessType("01");
            wcsTask.setTaskType(Constant.TASK_TYPE.FORWARD.getValue());
            wcsTask.setExt8(token.toString());
            wcsTask.setExt7(flowConfigHeaderVO.getId().toString());
            wcsTask.setExt6(StringUtils.isNotEmpty(agvCallDTO.getToArea()) ? agvCallDTO.getToArea() : "");
            // 三向车叉尺方向（货叉朝左1，朝右2，中位或其他0）
            // 如果起始点是仓储区，左1，右2，我们系统A是靠马路也就是叉尺的右边
            if (locationFrom.getZoneId() != null
                    && Objects.equals(locationFrom.getZoneId(), Constant.ZONE_TYPE.STORAGE.getValue())) {
                wcsTask.setExt4(locationFrom.getRowNo().equals("A") ? "2" : "1");
            }
            // 如果起始点是接驳位，默认给1
            if (locationFrom.getZoneId() != null
                    && Objects.equals(locationFrom.getZoneId(), Constant.ZONE_TYPE.TRANSIT.getValue())) {
                wcsTask.setExt4("1");
            }
            wcsTask.setExtParam(agvCallDTO.getExtParam());
            wcsTaskList.add(wcsTask);
            businessService.addTask(wcsTask);
        } else {
            /*//获取对应的流程
            List<FlowConfigHeader> headerVOList = flowConfigHeaderService.sortFlowConfigHeader(Long.parseLong(flowConfigHeaderVO.getRootFlow()));
            AsnSoStrategy asnSoStrategy = asnSoStrategyMapper.selectAsnSoStrategy();
            String taskNo = System.currentTimeMillis() + "";
            WcsTask wcsTask = new WcsTask();
            wcsTask.setTaskNo(taskNo);
            wcsTask.setAreaFrom(locationFrom.getZoneId().toString());
            wcsTask.setLocationFrom(locationFrom.getId().toString());
            wcsTask.setAreaTo(locationTo.getZoneId() + "");
            wcsTask.setLocationTo(locationTo.getId().toString());
            wcsTask.setState(9L);
            wcsTask.setPriority(1L);
            wcsTask.setCreateDate(new Date());
            wcsTask.setBusinessType("01");
            wcsTask.setTaskType("");
            wcsTaskList.add(wcsTask);
            String beforeTaskNo = taskNo;
            for (FlowConfigHeader flowConfigHeader : headerVOList) {
                if (StringUtils.isEmpty(flowConfigHeader.getRelFlow()) && flowConfigHeader.getRootFlow().equals(flowConfigHeader.getId().toString())) {
                    continue;
                }
                List<BaseLocationInfo> locationFromList = this.convertLocation(flowConfigHeader.getLocationFrom(), 1L);
                List<BaseLocationInfo> locationToList = this.convertLocation(flowConfigHeader.getLocationTo(), 1L);
                locationFrom = this.zoneLocationAllocation(locationFromList, "locationFrom", "MV", null, null);
                locationTo = this.zoneLocationAllocation(locationToList, "locationTo", "MV", null, null);
                String currentNo = SnowflakeIdWorker.generateId().toString();
                WcsTask child = new WcsTask();
                child.setTaskNo(currentNo);
                child.setParentTask(taskNo);
                child.setBeforeTask(beforeTaskNo);
                child.setAreaFrom(locationFrom.getZoneId().toString());
                child.setLocationFrom(locationFrom.getId().toString());
                child.setAreaTo(locationTo.getZoneId() + "");
                child.setLocationTo(locationTo.getId().toString());
                child.setState(9L);
                child.setPriority(1L);
                child.setCreateDate(new Date());
                child.setBusinessType("01");
                child.setTaskType("");
                wcsTaskList.add(child);
                beforeTaskNo = currentNo;
            }*/
        }
        return wcsTaskList;
    }

    @Transactional
    @Override
    public AjaxResult addTask(WcsTask wcsTask) {
        //锁定库位
        if (!StringUtils.isEmpty(wcsTask.getLocationFrom())) {
            baseLocationInfoService.updateLocationStockStatus(Long.parseLong(wcsTask.getLocationFrom()), Constant.STOCK_STATUS.STOCK10.getValue());
        }
        if (!StringUtils.isEmpty(wcsTask.getLocationTo())) {
            baseLocationInfoService.updateLocationStockStatus(Long.parseLong(wcsTask.getLocationTo()), Constant.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()), Constant.STOCK_STATUS.STOCK10.getValue());
            }
            if (!StringUtils.isEmpty(wcsTask.getLocationTo())) {
                baseLocationInfoService.updateLocationStockStatus(Long.parseLong(wcsTask.getLocationTo()), Constant.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(), Constant.WAREHOUSE_ID);
        BaseLocationInfo locTo = baseLocationInfoService.selectBaseLocationInfoByIdOrNo(wcsTask.getLocationTo(), Constant.WAREHOUSE_ID);
        AmsTask amsTask = new AmsTask();
        amsTask.setTaskNo(wcsTask.getTaskNo());
        if (wcsTask.getBusinessType() == null || wcsTask.getBusinessType().equals("")) {
            amsTask.setBusinessType(Constant.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(wcsTask.getPriority().intValue());
        // 充电任务直接传参数
        if (wcsTask.getBusinessType().equals(Constant.TASK_BUSINESS_TYPE.TASK_POWER.getValue())) {
            amsTask.setStFrom(Integer.parseInt(wcsTask.getLocationFrom()));
            amsTask.setStTo(Integer.parseInt(wcsTask.getLocationTo()));
            amsTask.setDeviceName(wcsTask.getDeviceName());
        } else {
            amsTask.setStFrom(locFrom.getAgvStation().intValue());
            amsTask.setStTo(locTo.getAgvStation().intValue());
        }
        amsTask.setExt1(wcsTask.getExt1());
        amsTask.setExt2(wcsTask.getExt2());
        amsTask.setExt3(wcsTask.getExt3());
        amsTask.setExt4(wcsTask.getExt4());
        if (wcsTask.getBusinessType().equals("m")) {
            //m类消息特殊处理
            wcsTask.setState(2L);
            int result = wcsTaskService.updateWcsTask(wcsTask);
            if (result > 0) {
                //更新
                return AjaxResult.success("下发成功");
            } else {
                return AjaxResult.error("下发失败");
            }
        } else {
            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(Constant.WAREHOUSE_ID);
        if (wcsTaskList != null && wcsTaskList.size() > 0) {
            for (WcsTask wcsTask : wcsTaskList) {
                //如果是充电任务直接下发
                if (wcsTask.getBusinessType().equals(Constant.TASK_BUSINESS_TYPE.TASK_POWER.getValue()) ||
                        wcsTask.getBusinessType().equals(Constant.TASK_BUSINESS_TYPE.TASK_m.getValue())) {
                    log.info("定时充电/盘点取消任务直接下发");
                    sendTask(wcsTask);
                    wcsTask.setState(2L);
                    wcsTaskService.updateWcsTask(wcsTask);
                    break;
                }

                //转发任务
                if (StringUtils.isNotEmpty(wcsTask.getTaskType())
                        && wcsTask.getTaskType().equals(Constant.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();
                }
            }
        }
    }

    @Transactional
    @Override
    public void autoSendTranSit() {
//        List<BaseLocationInfo> baseLocationInfos = baseLocationInfoService.selectSortedLocatinListByZoneId(Constant.ZONE_TYPE.TRANSIT.getValue()
//                , Constant.WAREHOUSE_ID, null);
//        for (BaseLocationInfo baseLocationInfo : baseLocationInfos) {
//            // 判断是否有货并且空闲
//            if (baseLocationInfo.getStockStatus().equals(Constant.STOCK_STATUS.STOCK00.getValue())
//                    && baseLocationInfo.getIsEmpty().equals(Constant.IS_YES.N.name())) {
//                if (baseLocationInfo.getUserdefine1().equals("ASN")) {
//                    AgvCallDTO agvCallDTO = new AgvCallDTO();
//                    agvCallDTO.setLocationFrom(baseLocationInfo.getLocationNo());
//                    businessService.agvCall(Constant.TRAN_STO_FLOW_ID, agvCallDTO);
//                } else if (baseLocationInfo.getUserdefine1().equals("SO_HG")) {
//                    AgvCallDTO agvCallDTO = new AgvCallDTO();
//                    agvCallDTO.setLocationFrom(baseLocationInfo.getLocationNo());
//                    businessService.agvCall(Constant.TRAN_OUT_FLOW_ID, agvCallDTO);
//                } else if (baseLocationInfo.getUserdefine1().equals("SO_BHG")) {
//                    AgvCallDTO agvCallDTO = new AgvCallDTO();
//                    agvCallDTO.setLocationFrom(baseLocationInfo.getLocationNo());
//                    businessService.agvCall(Constant.TRAN_OUT_BHG_FLOW_ID, agvCallDTO);
//                }
//            }
//        }
    }

    @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", Constant.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;
    }
}