wms / wms_tianjinggelinmei · Files

package com.huaheng.api.acs.service;


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.huaheng.common.utils.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.huaheng.api.acs.domain.AgvSendParam;
import com.huaheng.common.constant.QuantityConstant;
import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.common.utils.http.HttpUtils;
import com.huaheng.common.utils.security.ShiroUtils;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.framework.web.service.ConfigService;
import com.huaheng.pc.config.address.service.AddressService;
import com.huaheng.pc.config.container.domain.Container;
import com.huaheng.pc.config.container.service.ContainerService;
import com.huaheng.pc.config.pointPosition.domain.PointPosition;
import com.huaheng.pc.config.pointPosition.service.PointPositionService;
import com.huaheng.pc.inventory.inventoryHeader.service.InventoryHeaderService;
import com.huaheng.pc.task.agvTask.domain.AgvTask;
import com.huaheng.pc.task.agvTask.domain.Shelf;
import com.huaheng.pc.task.agvTask.service.IAgvTaskService;
import com.huaheng.pc.task.agvTask.service.ShelfService;
import com.huaheng.pc.task.taskHeader.domain.TaskHeader;
import com.huaheng.pc.task.taskHeader.mapper.TaskHeaderMapper;
import com.huaheng.pc.task.taskHeader.service.TaskHeaderService;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import javax.annotation.Resource;
import java.util.*;

/**
 * @ClassName AcsServiceImpl
 * @Description TODO
 * @Author Administrator
 * @Date 2019/12/2615:38
 */
@Service
public class AcsServiceImpl  implements AcsServices {

    @Resource
    private IAgvTaskService agvTaskService;
    @Resource
    private ConfigService configService;
    @Resource
    private AddressService addressService;
    @Resource
    private PointPositionService pointPositionService;
    @Resource
    private TaskHeaderService taskHeaderService;
    @Resource
    private ContainerService containerService;
    @Resource
    private InventoryHeaderService inventoryHeaderService;
    @Resource
    private TaskHeaderMapper taskHeaderMapper;
    @Resource
    private ShelfService shelfService;



    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult createAGVTask(AgvTask agvTask) {

        //校验请求参数，判断目标点位是否存在任务和是否锁定
        checkAgvTaskPosition(agvTask);
        //校验货架是否存在任务及是否锁定，校验起始点位是否锁定
        Shelf shelf = checkContainerAndPositionStatus(agvTask);
        agvTask.setFromPort(shelf.getPositionName());
        //校验自己生成的任务中源点位的托盘和实际托盘一不一致
        // checkContainerAndPositionLove(agvTask);
        agvTask.setStatus(QuantityConstant.TASK_STATUS_BUILD);
        agvTask.setCreatedBy(ShiroUtils.getLoginName());
        agvTask.setTaskType(QuantityConstant.STATUS_TASK_SHELF);
        agvTask.setCreatedTime(new Date());
        agvTask.setUpdated(new Date());
        agvTask.setShelfNo(shelf.getShelfNo());
        agvTask.setUpdatedBy(ShiroUtils.getLoginName());
        agvTask.setTaskNo(UUID.randomUUID().toString());
        shelf.setStatus("lock");

        if (agvTaskService.save(agvTask)) {
            pointPositionService.updateStatus(agvTask.getFromPort(), QuantityConstant.STATUS_POSITION_LOCK, agvTask.getWarehouseCode());
            pointPositionService.updateStatus(agvTask.getToPort(), QuantityConstant.STATUS_POSITION_LOCK, agvTask.getWarehouseCode());
            shelfService.updateById(shelf);
        } else {
            throw new ServiceException("AGV创建任务失败");
        }
        return AjaxResult.success("执行生成任务成功", agvTask);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult createAGVTask2(TaskHeader task) {
        try {
            if(task.getTaskType().equals(QuantityConstant.TASK_TYPE_WHOLESHIPMENT)){
                AgvTask agvTask=new AgvTask();
                agvTask.setTaskType(QuantityConstant.STATUS_TASK_SHELF);
                agvTask.setContainerCode(task.getContainerCode());
                // agvTask.setFromPort(task.get());
                agvTask.setToPort("");
                agvTask.setWarehouseCode(task.getWarehouseCode());
                agvTask.setStatus(QuantityConstant.TASK_STATUS_BUILD);
                agvTask.setCreatedBy(task.getCreatedBy());
                agvTask.setCreatedTime(new Date());
                if (agvTaskService.save(agvTask)) {
                    pointPositionService.updateStatus(agvTask.getFromPort(), QuantityConstant.STATUS_POSITION_LOCK, agvTask.getWarehouseCode());
                    containerService.updateStatus(agvTask.getContainerCode(), QuantityConstant.STATUS_CONTAINER_LOCK,QuantityConstant.ryTask_warehouse_code);
                }
            }
        }catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            task.setUserDef3("新增AGV任务失败了");
            taskHeaderService.updateById(task);
        }
        return null;
    }


    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult sendTaskToAGV(Integer[] agvTaskIds) {
        AjaxResult result = null;
        boolean finished = false;
        AgvTask agvTask = null;
        for (Integer taskId : agvTaskIds) {
            agvTask = agvTaskService.getById(taskId);

            if (agvTask.getStatus() >= QuantityConstant.TASK_STATUS_RELEASE) {
                result = AjaxResult.error("任务" + taskId + "已经下发，请不要重复下发，操作中止");
                finished = true;
                break;
            }
            if (StringUtils.isEmpty(agvTask.getToPort())) {
                result = AjaxResult.error("任务没有目标点位，不允许下发");
                finished = true;
                break;
            }
            LambdaQueryWrapper<AgvTask> lambdaQueryWrapper=Wrappers.lambdaQuery();
            lambdaQueryWrapper.eq(AgvTask::getStatus,QuantityConstant.TASK_STATUS_RUNNING);
            lambdaQueryWrapper.eq(AgvTask::getToPort,agvTask.getToPort());
            List<AgvTask> list = agvTaskService.list(lambdaQueryWrapper);
            if (list != null && list.size() > 0) {
                result = AjaxResult.error("目标点位存在任务，请更换目标点位");
                finished = true;
                break;
            }
            // 给AGV传递任务
            AjaxResult ajaxResult = agvTaskAssign(agvTask);
            if (ajaxResult != null && ajaxResult.hasErr()) {
                result = AjaxResult.error(ajaxResult.getMsg());
                finished = true;
                break;
            }
            //修改任务头表
            agvTask.setId(taskId);
            agvTask.setStatus(QuantityConstant.TASK_STATUS_RELEASE);
            agvTask.setUpdated(new Date());
            agvTask.setUpdatedBy(ShiroUtils.getLoginName());
            agvTaskService.updateById(agvTask);
        }
        if (!finished) {
            result = AjaxResult.success("执行下发任务成功", agvTask);
        }
        return result;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult agvTaskAssign(AgvTask agvTask) {
        //1、判断agvHeader是否为空
        if (agvTask == null) {
            return AjaxResult.error("Agv任务为空");
        }
        //2、判断必填字段是否满足
        if (agvTask.getId() == null) {
            return AjaxResult.error("Agv任务号Id为空");
        }
        if (agvTask.getTaskType() == null) {
            return AjaxResult.error("Agv任务类型为空");
        }
        String shelfNo = agvTask.getShelfNo();
        if (StringUtils.isEmpty(shelfNo)) {
            return AjaxResult.error("Agv任务中货架为空");
        }
        //3、转换实体，初始化Agv任务实体
        //4、发送数据
        AgvSendParam agvSendParam=new AgvSendParam();
        agvSendParam.setFromPort(agvTask.getFromPort());
        agvSendParam.setToPort(agvTask.getToPort());
        if(agvTask.getOrientation().equals("A")){
            agvSendParam.setOrientation(1);
        }else {
            agvSendParam.setOrientation(2);
        }
        agvSendParam.setTaskNo(agvTask.getTaskNo());
        agvSendParam.setTaskType(agvTask.getTaskType().toString());
        return  sendDataToAgv(agvSendParam,1);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult cancelAGVTask(Integer[] agvTaskIds) {
        for (int taskId : agvTaskIds) {
            AgvTask agvTask = agvTaskService.getById(taskId);
            if (agvTask == null) {
                return AjaxResult.error("任务" + taskId + "未找到，操作中止");
            }
            if (agvTask.getStatus() > QuantityConstant.TASK_STATUS_RELEASE) {
                return AjaxResult.error("存在任务" + agvTask.getId() + "已下发或执行，操作中止");
            }
            int preTaskNo = taskId;
            AgvTask  agvTask2=null;
            LambdaQueryWrapper<AgvTask> lambdaQueryWrapper=Wrappers.lambdaQuery();
            lambdaQueryWrapper.eq(AgvTask::getPreTaskNo,String.valueOf(preTaskNo));

            List<AgvTask> list = agvTaskService.list(lambdaQueryWrapper);
            if(CollectionUtils.isNotEmpty(list)){
                agvTask2 = list.get(0);
            }
            if (agvTask2 != null) {
                return AjaxResult.error("取消任务失败， 有前置任务" + agvTask.getId());
            }
            //查出任务明细
            //删除子任务
            //删除主任务
            agvTaskService.removeById(taskId);
            //盘点取消任务，恢复明细状态为1
            String taskType = agvTask.getTaskType();
            switch (taskType) {
                case QuantityConstant.STATUS_TASK_SHELF:
                    break;
                default:
                    break;
            }
            //更新点位信息
            cancelPositionStatus(agvTask);
            //更新货架信息
            cancelShelfStatus(agvTask);
        }
        return AjaxResult.success("取消任务成功！");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult cancelTask(String id, String warehouseCode) {
        //1、判断参数是否为空
        if(id == null) {
            throw new ServiceException("任务号为空");
        }
        List<String> list=new ArrayList<>();
        list.add(id);
        //2、发送数据
        return sendDataToAgv(list,2);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult updateAGVTask(String agvTaskId, Integer priority) {
        if(StringUtils.isEmpty(agvTaskId)) {
            throw new ServiceException("任务号为空");
        }
        AgvTask agvTask = agvTaskService.getById(Integer.parseInt(agvTaskId));
        agvTask.setPriority(priority);
        agvTask.setUpdated(new Date());
        agvTask.setUpdatedBy(ShiroUtils.getLoginName());
        if(!agvTaskService.updateById(agvTask)) {
            throw new ServiceException("更新优先级失败");
        }
        return AjaxResult.success();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult updateTask(Integer id, String warehouseCode, Integer priority) {
        if(id == null) {
            throw new ServiceException("任务号为空");
        }

        AgvTask agvTask=new AgvTask();
        agvTask.setTaskNo(String.valueOf(id));
        agvTask.setPriority(priority);
        return sendDataToAgv(agvTask,3);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult notifyAGVPort(Map map) {
        AgvTask agvTask=new AgvTask();
        if(map.isEmpty()) {
            return AjaxResult.error("请求数据为空");
        }
        Object o1=map.get("taskNo");
        Object o2=map.get("carNo");
        Object o3=map.get("oldPort");
        Object o4=map.get("newPort");
        if(StringUtils.isNull(o1)) {
            return AjaxResult.error("任务号为空");
        }
        if(StringUtils.isNull(o2)) {
            return AjaxResult.error("小车编号为空");
        }
        if(StringUtils.isNull(o3)) {
            return AjaxResult.error("起点为空");
        }
        if(StringUtils.isNull(o4)) {
            return AjaxResult.error("终点为空");
        }
        Integer taskNo=Integer.valueOf(o1.toString());
        String carNo=o2.toString();
        String fromPort=o3.toString();
        String toPort=o4.toString();
        agvTask.setId(taskNo);
        agvTask.setCarNo(carNo);
        agvTask.setFromPort(fromPort);
        agvTask.setToPort(toPort);
        AjaxResult ajaxResult = checkPointPositionExist(agvTask);
        if(ajaxResult.hasErr()) {
            return ajaxResult;
        }
        if(!agvTaskService.updateById(agvTask)){ throw new ServiceException("更新失败"); };
        return ajaxResult;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult notifyAGVTask(Map map) {

        if(map.isEmpty()) {
            return AjaxResult.error("请求数据为空");
        }
        Object o1=map.get("taskNo");
        Object o2=map.get("carNo");
        Object o3=map.get("status");
        if(StringUtils.isNull(o1)) {
            return AjaxResult.error("任务号为空");
        }
        if(StringUtils.isNull(o2)) {
            return AjaxResult.error("小车编号为空");
        }
        if(StringUtils.isNull(o3)) {
            return AjaxResult.error("任务状态为空");
        }
        String taskNo=o1.toString();
        String carNo=o2.toString();
        String status=o3.toString();

        LambdaQueryWrapper<AgvTask> lambdaQueryWrapper=Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(AgvTask::getTaskNo,taskNo);
        List<AgvTask> list=agvTaskService.list(lambdaQueryWrapper);
        AgvTask agvTask2=null;
        if(list!=null&&list.size()>0){
            agvTask2 =list.get(0);
        }else{
            return AjaxResult.error(taskNo+"任务没找到AgvTask");
        }
        agvTask2.setCarNo(carNo);
        agvTaskStatusNowStart(status,agvTask2);
        return AjaxResult.success("任务状态更新成功");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult completeTaskByWMS(String taskId) {
        if(StringUtils.isEmpty(taskId)){
            return AjaxResult.error("任务id为空");
        }
        AgvTask agvTask = agvTaskService.getById(Integer.valueOf(taskId));
        if (agvTask.getStatus() == QuantityConstant.TASK_STATUS_BUILD ) {
            return AjaxResult.error("任务" + taskId + "未下发，请不要直接完成");
        }
        if (agvTask.getStatus() == QuantityConstant.TASK_STATUS_RELEASE ) {
            return AjaxResult.error("任务" + taskId + "下达，请不要直接完成");
        }
        //更新点位和托盘信息
        if(StringUtils.isNotEmpty(agvTask.getFromPort())){
            PointPosition sourcePosition = pointPositionService.getPositionByCode(agvTask.getFromPort(), agvTask.getWarehouseCode());
            if(StringUtils.isNull(sourcePosition)){
                return AjaxResult.error("源点位未找到");
            }
            pointPositionService.updateStatus(agvTask.getFromPort(), QuantityConstant.STATUS_POSITION_EMPTY,agvTask.getWarehouseCode());
            pointPositionService.setContainerCode(agvTask.getFromPort(),null,agvTask.getWarehouseCode());
        }
        if(StringUtils.isNotEmpty(agvTask.getToPort())){
            PointPosition desPosition = pointPositionService.getPositionByCode(agvTask.getToPort(), agvTask.getWarehouseCode());
            if(StringUtils.isNull(desPosition)){
                return AjaxResult.error("目标点位未找到");
            }
            pointPositionService.updateStatus(agvTask.getToPort(), QuantityConstant.STATUS_POSITION_SOME,agvTask.getWarehouseCode());
            pointPositionService.setContainerCode(agvTask.getToPort(),agvTask.getContainerCode(),agvTask.getWarehouseCode());
            containerService.updateLocationCodeAndStatus(agvTask.getContainerCode(),agvTask.getToPort(), QuantityConstant.STATUS_CONTAINER_EMPTY);
        }
        //更新agv任务状态
        agvTask.setStatus(QuantityConstant.TASK_STATUS_COMPLETED);
        agvTask.setUpdated(new Date());
        agvTask.setUpdatedBy(ShiroUtils.getLoginName());
        if(!agvTaskService.updateById(agvTask)) {
            throw new ServiceException("完成任务失败");
        }
        return AjaxResult.success();
    }

    /**
     * 将参数传输给AGV
     * @param object
     * @return
     */
    private AjaxResult sendDataToAgv( Object object,Integer i){
        String value = configService.getKey(QuantityConstant.RULE_CONNECT_AGV);
        int connectAGV = Integer.parseInt(value);
        if (connectAGV == QuantityConstant.RULE_AGV_CONNECT) {
            String url=null;
            if(i==1){
                url = addressService.selectAddress("AGV", QuantityConstant.ryTask_warehouse_code, null);
                url=url+"/createAGVTask";
            }else if(i==2){
                url = addressService.selectAddress("AGV", QuantityConstant.ryTask_warehouse_code, null);
            }
            String JsonParam = JSON.toJSONString(object);
            //System.out.println(JsonParam);
            String result = HttpUtils.bodypost(url, JsonParam,QuantityConstant.ryTask_warehouse_code);
            AjaxResult ajaxResult= JSONObject.parseObject(result, AjaxResult.class);
            if(StringUtils.isEmpty(result)){
                throw new ServiceException("AGV接口地址错误或服务器连接不到或返回为空");
            }
            if(ajaxResult.getCode()!=200){
                throw new ServiceException("AGV: " + ajaxResult.getMsg());
            }
        }
        return AjaxResult.success("下发成功");
    }

    /**
     * 检查托盘和点位是否存在未完成的任务
     * @param agvTask
     */
    private Shelf checkContainerAndPositionStatus(AgvTask agvTask){
        Container container = containerService.getContainerByCode(agvTask.getContainerCode());
        if(StringUtils.isNull(container)){
            throw  new ServiceException("托盘"+agvTask.getContainerCode()+"不存在");
        }
        //拿到货架编号g
        String shelfNo = container.getShelfNo();
        if(StringUtils.isEmpty(shelfNo)){
            throw new ServiceException(agvTask.getContainerCode()+"容器没有找到货架");
        }
        AgvTask agvTask1=new AgvTask();
        agvTask1.setStatus(110);
        agvTask1.setShelfNo(shelfNo);

        LambdaQueryWrapper<AgvTask> lambdaQueryWrapper=Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(AgvTask::getStatus,110);
        lambdaQueryWrapper.eq(AgvTask::getShelfNo,shelfNo);
        List<AgvTask> list = agvTaskService.list(lambdaQueryWrapper);
        //判断此货架是否有任务存在
        if (StringUtils.isNull(list)) {
            throw  new ServiceException("货架"+shelfNo+"存在未完成的任务");
        }
        //判断货架是否锁定
        Shelf shelf=new Shelf();
        shelf.setShelfNo(shelfNo);
        List<Shelf> shelfList = shelfService.list(shelf);
        if(shelfList==null||shelfList.size()<=0){
            throw new ServiceException(shelfNo+"货架不存在");
        }
        if(StringUtils.isNotEmpty(shelfList)&&shelfList.get(0).getStatus().equals("lock")){
            throw new ServiceException("货架"+shelfNo+"已锁定");
        }
        //判断起始点位是否锁定
        LambdaQueryWrapper<PointPosition> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(PointPosition::getPositionName,shelfList.get(0).getPositionName());
        queryWrapper.eq(PointPosition::getStatus,"lock");
        List<PointPosition> pointPositions = pointPositionService.list(queryWrapper);
        if(CollectionUtils.isNotEmpty(pointPositions)){
            throw new ServiceException("起始点位"+shelf.getPositionName()+"已锁定");
        }
        return shelfList.get(0);
    }

    //根据任务类型检验参数
    @SuppressWarnings({"AlibabaRemoveCommentedCode", "AlibabaCommentsMustBeJavadocFormat"})
    private void checkAgvTaskPosition(AgvTask agvTask){
        //校验托盘
        if (StringUtils.isNull(agvTask)) {
            throw new ServiceException("任务数据为空，请重新下发");
        }
        if (StringUtils.isEmpty(agvTask.getContainerCode())) {
            throw new ServiceException("托盘为空");
        }
        //校验目标点位
        if (StringUtils.isEmpty(agvTask.getToPort())) {
            throw  new ServiceException("目标点位为空");
        }
        PointPosition desPosition = pointPositionService.getPositionByCode(agvTask.getToPort(), agvTask.getWarehouseCode());
        if (StringUtils.isNull(desPosition)) {
            throw new ServiceException("目标点位：" + agvTask.getToPort() + "未找到");
        }
        LambdaQueryWrapper<AgvTask> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(AgvTask::getToPort,desPosition.getPositionName());
        queryWrapper.eq(AgvTask::getStatus,110);
        List<AgvTask> agvTasks = agvTaskService.list(queryWrapper);
        if(agvTasks!=null&&agvTasks.size()>0){
            throw new ServiceException("目标点位：" + desPosition + "存在任务");
        }
        if(desPosition.getStatus().equals(QuantityConstant.STATUS_POSITION_LOCK)){
            throw new ServiceException("目标点位：" + desPosition + "禁用");
        }
        if(StringUtils.isNotEmpty(desPosition.getShelfNo())){
            throw new ServiceException("目标点位：" + desPosition + "存在货架:"+desPosition.getShelfNo());
        }
    }

    //更新点位状态
    @SuppressWarnings("AlibabaCommentsMustBeJavadocFormat")
    private void cancelPositionStatus(AgvTask agvTask) {
        if (agvTask.getFromPort() != null) {
            //更新点位状态
            LambdaQueryWrapper<PointPosition> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper.eq(PointPosition::getPositionName,agvTask.getFromPort());
            List<PointPosition> list = pointPositionService.list(queryWrapper);
            PointPosition pointPosition=null;
            if(CollectionUtils.isNotEmpty(list)){
                pointPosition=list.get(0);
            }

            if(pointPosition!=null&& StringUtils.isNotEmpty(pointPosition.getShelfNo())){
                pointPositionService.updateStatus(agvTask.getFromPort(), QuantityConstant.STATUS_POSITION_SOME,agvTask.getWarehouseCode());
            } else {
                pointPositionService.updateStatus(agvTask.getFromPort(), QuantityConstant.STATUS_POSITION_EMPTY,agvTask.getWarehouseCode());
            }
        }
        if (agvTask.getToPort() != null) {
            //更新点位状态
            LambdaQueryWrapper<PointPosition> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper.eq(PointPosition::getPositionName,agvTask.getToPort());
            List<PointPosition> list = pointPositionService.list(queryWrapper);
            PointPosition pointPosition=null;
            if(CollectionUtils.isNotEmpty(list)){
                pointPosition=list.get(0);
            }
            if(pointPosition!=null&& StringUtils.isNotEmpty(pointPosition.getShelfNo())){
                pointPositionService.updateStatus(agvTask.getToPort(), QuantityConstant.STATUS_POSITION_SOME,agvTask.getWarehouseCode());
            } else {
                pointPositionService.updateStatus(agvTask.getToPort(), QuantityConstant.STATUS_POSITION_EMPTY,agvTask.getWarehouseCode());

            }
        }

    }
    //更新货架状态
    @SuppressWarnings("AlibabaCommentsMustBeJavadocFormat")
    private void cancelShelfStatus(AgvTask agvTask){

        Shelf shelf=new Shelf();
        shelf.setShelfNo(agvTask.getShelfNo());
        Shelf shelf1 = shelfService.list(shelf).get(0);
        shelf1.setStatus("relax");
        shelfService.updateById(shelf1);


    }


    //检查点位是否存在
    @SuppressWarnings("AlibabaCommentsMustBeJavadocFormat")
    private AjaxResult checkPointPositionExist(AgvTask agvTask){
        PointPosition sourcePosition = pointPositionService.getPositionByCode(agvTask.getFromPort(), "CS0001");
        PointPosition desPosition = pointPositionService.getPositionByCode(agvTask.getToPort(), "CS0001");
        if (StringUtils.isNull(sourcePosition)) {
            return AjaxResult.error("源点位：" + sourcePosition + "未找到");
        }
        if (StringUtils.isNull(desPosition)) {
            return AjaxResult.error("目标点位：" + desPosition + "未找到");
        }
        return AjaxResult.success();
    }
    //校验自己生成的任务中源点位的托盘和实际托盘一不一致
    @SuppressWarnings("AlibabaCommentsMustBeJavadocFormat")
    private void  checkContainerAndPositionLove(AgvTask agvTask){
        LambdaQueryWrapper<PointPosition> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(PointPosition::getPositionName,agvTask.getFromPort());
        List<PointPosition> list = pointPositionService.list(queryWrapper);
        PointPosition pointPosition=null;
        if(CollectionUtils.isNotEmpty(list)){
            pointPosition = list.get(0);
        }
        if(pointPosition!=null&& StringUtils.isNotEmpty(pointPosition.getContainerCode())){
            if(!agvTask.getContainerCode().equals(pointPosition.getContainerCode())){
                throw  new ServiceException("源点位上托盘数据和分配的托盘不一致，请核对");
            }
        }
    }
    //根据agv的任务状态来判断
    private AjaxResult agvTaskStatusNowStart(String o3, AgvTask agvTask){
        LambdaQueryWrapper<AgvTask> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(AgvTask::getTaskNo,agvTask.getTaskNo());
        List<AgvTask> list = agvTaskService.list(queryWrapper);
        AgvTask task =null;
        if(list!=null&&list.size()>0){
            task=list.get(0);
        }else{
            return   AjaxResult.error("任务号"+agvTask.getId()+"不存在");
        }
        if(task.getStatus().equals(QuantityConstant.TASK_STATUS_COMPLETED)) {
            return AjaxResult.error("任务"+agvTask.getId()+"已经完成");
        }
        task.setStatus(Integer.valueOf(o3));
        if(o3.equals("100")){
            //货架写入点位数据，状态为relax
            Shelf shelf=new Shelf();
            shelf.setPositionName(agvTask.getShelfNo());
            Shelf shelf1 = shelfService.list(shelf).get(0);
            shelf1.setStatus("relax");
            shelf1.setPositionName(agvTask.getToPort());
            shelfService.updateById(shelf1);
            //源点位货架数据清空，状态empty

            LambdaQueryWrapper<PointPosition> queryWrapper1 = Wrappers.lambdaQuery();
            queryWrapper1.eq(PointPosition::getPositionName,agvTask.getFromPort());
            int positionId1 = pointPositionService.list(queryWrapper1).get(0).getId();
            pointPositionService.removeById(positionId1);
            //目标点位货架写入，状态some
            PointPosition pointPosition2=new PointPosition();
            pointPosition2.setPositionName(agvTask.getToPort());
            pointPosition2.setShelfNo(agvTask.getShelfNo());
            LambdaQueryWrapper<PointPosition> queryWrapper2 = Wrappers.lambdaQuery();
            queryWrapper2.eq(PointPosition::getPositionName,agvTask.getToPort());
            pointPositionService.update(pointPosition2,queryWrapper2);
        }
        //agv任务完成
        return AjaxResult.toAjax(agvTaskService.updateById(task));
    }

    @Override
    public AjaxResult createAGVTask3(AgvTask agvtask) {
        //校验请求参数，托盘是否存在，货架是否有未完成的任务，货架是否锁定
        Shelf shelf = checkAgvTaskContainer(agvtask);
        agvtask.setFromPort(shelf.getPositionName());
       /* PointPosition pointPosition=new PointPosition();
        List<PointPosition> pointPositions = pointPositionMapper.emptyPositionList();
        PointPosition position = pointPositions.get((int) (Math.random() * pointPositions.size()));*/


        //
        agvtask.setStatus(QuantityConstant.TASK_STATUS_BUILD);
        agvtask.setCreatedBy(ShiroUtils.getLoginName());
        agvtask.setTaskType(QuantityConstant.STATUS_TASK_SHELF);
        agvtask.setCreatedTime(new Date());
        agvtask.setUpdated(new Date());
        agvtask.setShelfNo(shelf.getShelfNo());
        agvtask.setOrientation("A");
        agvtask.setUpdatedBy(ShiroUtils.getLoginName());
        agvtask.setTaskNo(UUID.randomUUID().toString());
        Container container1 = containerService.getContainerByCode(agvtask.getContainerCode());
        if(null==container1){
            throw new ServiceException(agvtask.getContainerCode()+"容器不存在");
        }
        if(StringUtils.isEmpty(container1.getShelfNo())){
            throw new ServiceException(agvtask.getContainerCode()+"容器不存在货架");
        }
        shelf.setStatus("lock");


        LambdaQueryWrapper<AgvTask> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(AgvTask::getShelfNo,container1.getShelfNo());
        queryWrapper.eq(AgvTask::getStatus,100);
        List<AgvTask> list=agvTaskService.list(queryWrapper);
        if(list==null||list.size()<=0){
            throw new ServiceException(container1.getShelfNo()+"货架未找到状态为100的AGV任务");
        }
        String toPort = list.get(0).getFromPort();

        AgvTask agvTask=new AgvTask();
        agvTask.setShelfNo(container1.getShelfNo());
        agvTask.setStatus(100);
        agvtask.setToPort(toPort);
        if (agvTaskService.save(agvtask)) {
            pointPositionService.updateStatus(agvtask.getFromPort(), QuantityConstant.STATUS_POSITION_LOCK, agvtask.getWarehouseCode());
            pointPositionService.updateStatus(agvtask.getToPort(), QuantityConstant.STATUS_POSITION_LOCK, agvtask.getWarehouseCode());
            shelfService.updateById(shelf);
        } else {
            throw new ServiceException("AGV创建任务失败");
        }
        return AjaxResult.success("执行生成任务成功", agvtask);
    }

    private Shelf checkAgvTaskContainer(AgvTask agvtask) {
        if(StringUtils.isEmpty(agvtask.getContainerCode())){
            throw new ServiceException("请输入托盘");
        }
        Container entity = containerService.getContainerByCode(agvtask.getContainerCode());
        String shelfNo = entity.getShelfNo();
        if(StringUtils.isEmpty(shelfNo)){
            throw new ServiceException(agvtask.getContainerCode()+"容器没有找到货架");
        }
        LambdaQueryWrapper<AgvTask> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(AgvTask::getShelfNo,shelfNo);
        queryWrapper.eq(AgvTask::getStatus,110);
        List<AgvTask> list = agvTaskService.list(queryWrapper);
        if(list!=null&&list.size()>0){
            throw new ServiceException("货架："+shelfNo+"存在未完成的任务");
        }
        Shelf shelf=new Shelf();
        shelf.setShelfNo(shelfNo);
        List<Shelf> shelfList = shelfService.list(shelf);
        if(CollectionUtils.isNotEmpty(shelfList)&&shelfList.get(0).getStatus().equals("lock")){
            throw new ServiceException("货架："+shelfNo+"已锁定");
        }
        return shelfList.get(0);
    }
    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult edit(AgvTask agvTask){
        AgvTask agvTaskResult = agvTaskService.getById(agvTask.getId());
        if(agvTaskResult.getStatus()>= QuantityConstant.TASK_STATUS_RELEASE){
            return AjaxResult.error("任务已经下发了，不允许修改");
        }
        agvTask.setUpdated(new Date());
        PointPosition pointPosition=null;
        LambdaQueryWrapper<PointPosition> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(PointPosition::getPositionName,agvTask.getToPort());
        List<PointPosition> list = pointPositionService.list(queryWrapper);
        if(CollectionUtils.isNotEmpty(list)){
            pointPosition = list.get(0);
        }
        if(pointPosition==null&&StringUtils.isNotEmpty(pointPosition.getPositionName())){
            return AjaxResult.error("目标点位不存在");
        }
        if(pointPosition!=null&& StringUtils.isNotEmpty(pointPosition.getContainerCode())){
            return AjaxResult.error("目标点位有托盘，请选择其他点位");
        }
        if(pointPosition!=null&& pointPosition.getStatus().equals(QuantityConstant.STATUS_POSITION_LOCK)){
            if(!agvTask.getToPort().equals(agvTaskResult.getToPort())){
                return AjaxResult.error("目标点位锁住，请选择其他点位");
            }
        }
        AgvTask agvTask2=null;
        LambdaQueryWrapper<AgvTask> lambdaQueryWrapper=Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(AgvTask::getStatus,110);
        lambdaQueryWrapper.eq(AgvTask::getToPort,agvTask.getToPort());
        List<AgvTask> list1 = agvTaskService.list(lambdaQueryWrapper);
        if(CollectionUtils.isNotEmpty(list1)){
            agvTask2 = list1.get(0);
        }
        if(agvTask2!=null){
            return AjaxResult.error("目标点位存在未完成的任务");
        }
        pointPositionService.updateStatus(agvTaskResult.getToPort(),QuantityConstant.STATUS_POSITION_EMPTY,"CS0001");
        pointPositionService.updateStatus(agvTask.getToPort(),QuantityConstant.STATUS_POSITION_LOCK,"CS0001");
        if(!agvTaskService.updateById(agvTask)){
            throw new ServiceException("修改AGV任务失败");
        }
        return AjaxResult.success();
    }
}