最新

zhangchengsong

12 小时以前 f59f3b24814387573b5bca9a9b6c832a3720ee7e

 ÏîÄ¿´úÂë/WIDESEAWCS_Server/WIDESEAWCS_TaskInfoService/TaskService.cs

@@ -16,6 +16,7 @@
#endregion << ç‰ˆ æœ¬ æ³¨ é‡Š >>

using AutoMapper;
using HslCommunication;
using Microsoft.AspNetCore.Mvc.RazorPages;
using NetTaste;
using Newtonsoft.Json;
@@ -38,6 +39,7 @@
using System.Threading.Tasks;
using WIDESEA_Comm.Http;
using WIDESEA_Common.Log;
using WIDESEA_Core.Enums;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.BaseRepository;
@@ -46,10 +48,15 @@
using WIDESEAWCS_Core.Utilities;
using WIDESEAWCS_DTO.Enum;
using WIDESEAWCS_DTO.TaskInfo;
using WIDESEAWCS_ISystemRepository;
using WIDESEAWCS_ISystemServices;
using WIDESEAWCS_ITaskInfoRepository;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model;
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_Model.Models.System;
using WIDESEAWCS_QuartzJob;
using WIDESEAWCS_QuartzJob.DTO;
using WIDESEAWCS_QuartzJob.Models;
using WIDESEAWCS_QuartzJob.Service;
using WIDESEAWCS_TaskInfoRepository;
@@ -67,6 +74,7 @@
        private readonly IMapper _mapper;
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        private readonly IDt_roadwayinfoService _Dt_roadwayinfoService;
        private readonly IDt_PlatformStationRepository _dt_PlatformStation;

        private Dictionary<string, OrderByType> _taskOrderBy = new()
            {
@@ -80,7 +88,7 @@
        public string urlWMSdeverror = WIDESEAWCS_Core.Helper.AppSettings.Configuration["urlWMSdeverror"];
        public string urlWMSliftinposition = WIDESEAWCS_Core.Helper.AppSettings.Configuration["urlWMSliftinposition"];

        public TaskService(ITaskRepository BaseDal, IRouterService routerService, ITaskExecuteDetailService taskExecuteDetailService, ITaskExecuteDetailRepository taskExecuteDetailRepository, IMapper mapper, ITask_HtyService task_HtyService, ITask_HtyRepository task_HtyRepository, IUnitOfWorkManage unitOfWork, IDt_roadwayinfoService dt_RoadwayinfoService) : base(BaseDal)
        public TaskService(ITaskRepository BaseDal, IDt_PlatformStationRepository dt_PlatformStation, IRouterService routerService, ITaskExecuteDetailService taskExecuteDetailService, ITaskExecuteDetailRepository taskExecuteDetailRepository, IMapper mapper, ITask_HtyService task_HtyService, ITask_HtyRepository task_HtyRepository, IUnitOfWorkManage unitOfWork, IDt_roadwayinfoService dt_RoadwayinfoService) : base(BaseDal)
        {
            _routerService = routerService;
            _taskExecuteDetailService = taskExecuteDetailService;
@@ -90,6 +98,7 @@
            _mapper = mapper;
            _unitOfWorkManage = unitOfWork;
            _Dt_roadwayinfoService = dt_RoadwayinfoService;
            _dt_PlatformStation = dt_PlatformStation;
        }

        //根据任务号，查询任务
@@ -103,7 +112,7 @@
        /// </summary>
        /// <param name="taskNum">任务号</param>
        /// <returns></returns>
        public WebResponseContent StackCraneTaskCompleted(int taskNum)
        public WebResponseContent StackCraneTaskCompleted(int taskNum,string PalletCode)
        {
            WebResponseContent content = new WebResponseContent();
            try
@@ -115,12 +124,14 @@
                {
                    task.TaskState = (int)TaskOutStatusEnum.OutFinish;
                    BaseDal.UpdateData(task);

                    string Result = WMSTaskStatusEnum.outsuccess.GetDescription();
                    //同步给上游反馈任务完成
                    CommandResult command = taskreturn(int.Parse(task.WMStaskid), Result, "invmd", "");
                    if (command.status != "success") return content.Error($"调取上游返回失败，完成堆垛机任务失败，条码：{task.PalletCode},任务号：{task.TaskNum}");

                    if (task.Creater.Equals("WMS"))
                    {
                        //同步给上游反馈任务完成
                        Dt_roadwayinfo roadwayinfo = _Dt_roadwayinfoService.GetRoadwayinfo(task.Roadway);
                        CommandResult command = taskreturn(int.Parse(task.WMStaskid), Result, roadwayinfo.WarehouseInvType, "");
                        if (command.status != "success")return content.Error($"调取上游返回失败，完成堆垛机任务失败，条码：{task.PalletCode},任务号：{task.TaskNum}");
                    }
                    task.ModifyDate = DateTime.Now;
                    BaseDal.DeleteData(task);
                    _task_HtyService.AddTaskHty(task);
@@ -130,11 +141,14 @@
                else if (task.TaskType == (int)TaskTypeEnum.Inbound && task.TaskState == (int)TaskInStatusEnum.SC_InExecuting)
                {
                    task.TaskState = (int)TaskInStatusEnum.InFinish;
                    BaseDal.UpdateData(task);
                    string Result = WMSTaskStatusEnum.insuccess.GetDescription();
                    CommandResult command = taskreturn(int.Parse(task.WMStaskid), Result, "invmd", "");

                    if (command.status != "success") return content.Error($"调取上游返回失败，完成堆垛机任务失败，条码：{task.PalletCode},任务号：{task.TaskNum}");

                    if (task.Creater.Equals("WMS"))
                    {
                        Dt_roadwayinfo roadwayinfo = _Dt_roadwayinfoService.GetRoadwayinfo(task.Roadway);
                        CommandResult command = taskreturn(int.Parse(task.WMStaskid), Result, roadwayinfo.WarehouseInvType, "");
                        if (command.status != "success") return content.Error($"调取上游返回失败，完成堆垛机任务失败，条码：{task.PalletCode},任务号：{task.TaskNum}");
                    }
                    task.ModifyDate = DateTime.Now;
                    task.Modifier = "System";
                    BaseDal.DeleteData(task);
@@ -144,16 +158,19 @@
                else if (task.TaskType == (int)TaskTypeEnum.Inventorybound && task.TaskState == (int)TaskinventoryStatusEnum.SC_inventoryExecuting)
                {
                    task.TaskState = (int)TaskinventoryStatusEnum.inventoryFinish;
                    BaseDal.UpdateData(task);
                    string Result = WMSTaskStatusEnum.insuccess.GetDescription();
                    CommandResult command = taskreturn(int.Parse(task.WMStaskid), Result, "invmd", "");

                    if (command.status != "success") return content.Error($"调取上游返回失败，完成堆垛机任务失败，条码：{task.PalletCode},任务号：{task.TaskNum}");

                    if (task.Creater.Equals("WMS"))
                    {
                        Dt_roadwayinfo roadwayinfo = _Dt_roadwayinfoService.GetRoadwayinfo(task.Roadway);
                        CommandResult command = taskreturn(int.Parse(task.WMStaskid), Result, roadwayinfo.WarehouseInvType, "");
                        if (command.status != "success")return content.Error($"调取上游返回失败，完成堆垛机任务失败，条码：{task.PalletCode},任务号：{task.TaskNum}");
                    }
                    task.ModifyDate = DateTime.Now;
                    task.Modifier = "System";
                    BaseDal.DeleteData(task);
                    _task_HtyService.AddTaskHty(task);
                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"入库完成");
                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"盘点完成");
                }
                else
                {
@@ -241,10 +258,10 @@
                task.ModifyDate = DateTime.Now;
                task.Modifier = "System";
                BaseDal.UpdateData(task);

                Dt_roadwayinfo roadwayinfo = _Dt_roadwayinfoService.GetRoadwayinfo(task.Roadway);
                //反馈至上游
                CommandResult command = taskreturn(int.Parse(task.WMStaskid), Result, "invmd", "");

                CommandResult command = taskreturn(int.Parse(task.WMStaskid), Result, roadwayinfo.WarehouseInvType, "");
                Console.WriteLine(command.ToJsonString());
                _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, App.User.UserId > 0 ? $"人工手动将任务状态从【{oldState}】跳转到【{task.TaskState}】" : $"系统自动流程，任务状态从【{oldState}】转到【{task.TaskState}】");

                content = WebResponseContent.Instance.OK();
@@ -454,14 +471,377 @@
        /// <returns>返回任务实体对象，可能为null</returns>
        public List<Dt_Task> QueryStackerCraneTask(string deviceNo, string currentAddress = "")
        {
            return BaseDal.QueryData(x => x.Roadway == deviceNo && (x.TaskState == (int)TaskInStatusEnum.InNew || x.TaskState == (int)TaskOutStatusEnum.OutNew), TaskOrderBy);
            return BaseDal.QueryData(x => x.Roadway == deviceNo && (x.TaskState == (int)TaskInStatusEnum.InNew || x.TaskState == (int)TaskOutStatusEnum.OutNew || x.TaskState == (int)TaskinventoryStatusEnum.inventoryNew), TaskOrderBy);
        }

        public Dt_Task CutStackerCraneTask(string deviceNo)
        {
            Dt_Task dt_Task = BaseDal.QueryFirst(x => x.Roadway == deviceNo && (x.TaskState == (int)TaskOutStatusEnum.SC_OutExecuting  || x.TaskState == (int)TaskInStatusEnum.SC_InExecuting));
            Dt_Task dt_Task = BaseDal.QueryFirst(x => x.Roadway == deviceNo && (x.TaskState == (int)TaskOutStatusEnum.SC_OutExecuting  || x.TaskState == (int)TaskInStatusEnum.SC_InExecuting || x.TaskState == (int)TaskinventoryStatusEnum.SC_inventoryExecuting));
            return dt_Task;
        }
        /// <summary>
        /// æ‰‹åŠ¨å–消任务
        /// </summary>
        /// <param name="taskNum"></param>
        /// <returns></returns>
        public WebResponseContent TaskCancel(int taskNum)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task == null) return WebResponseContent.Instance.Error($"未找到该任务信息,任务号:【{taskNum}】");
                string Result = task.TaskType == 200 || task.TaskType == 300 ? WMSTaskStatusEnum.inerror.GetDescription(): WMSTaskStatusEnum.outerror.GetDescription();
                if (task.Creater.Equals("WMS"))
                {
                     Dt_roadwayinfo roadwayinfo = _Dt_roadwayinfoService.GetRoadwayinfo(task.Roadway);
                     CommandResult command = taskreturn(int.Parse(task.WMStaskid), Result, roadwayinfo.WarehouseInvType, "");
                     if (command.status != "success") return content.Error($"调取上游返回失败，任务取消失败，条码：{task.PalletCode},任务号：{task.TaskNum}");
                }
                BaseDal.DeleteData(task);
                task.ModifyDate = DateTime.Now;
                task.Modifier = App.User?.UserName;
                task.Remark = "人工手动取消";
                BaseDal.DeleteData(task);
                _task_HtyService.AddTaskHty(task);
                content.Status = true;
                return content;
            }
            catch (Exception e)
            {
                return WebResponseContent.Instance.Error();
            }
        }
        /// <summary>
        ///手动完成任务
        /// </summary>
        /// <param name="taskNum"></param>
        /// <returns></returns>
        public WebResponseContent TaskHandCompleted(int taskNum)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task == null) return WebResponseContent.Instance.Error($"未找到该任务信息,任务号:【{taskNum}】");

                if (task.TaskType == (int)TaskTypeEnum.Outbound)
                {
                    string Result = WMSTaskStatusEnum.outsuccess.GetDescription();
                    if (task.Creater.Equals("WMS"))
                    {
                        Dt_roadwayinfo roadwayinfo = _Dt_roadwayinfoService.GetRoadwayinfo(task.Roadway);
                        CommandResult command = taskreturn(int.Parse(task.WMStaskid), Result, roadwayinfo.WarehouseInvType, "");
                        if (command.status != "success") return content.Error($"调取上游返回失败，完成堆垛机任务失败，条码：{task.PalletCode},任务号：{task.TaskNum}");
                    }
                    task.ModifyDate = DateTime.Now;
                    task.Modifier = App.User?.UserName;
                    task.Remark = "人工手动完成";
                    BaseDal.DeleteData(task);
                    _task_HtyService.AddTaskHty(task);
                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"手动出库完成");
                }
                else if (task.TaskType == (int)TaskTypeEnum.Inbound)
                {
                    string Result = WMSTaskStatusEnum.insuccess.GetDescription();
                    if (task.Creater.Equals("WMS"))
                    {
                        Dt_roadwayinfo roadwayinfo = _Dt_roadwayinfoService.GetRoadwayinfo(task.Roadway);
                        CommandResult command = taskreturn(int.Parse(task.WMStaskid), Result, roadwayinfo.WarehouseInvType, "");
                        if (command.status != "success") return content.Error($"调取上游返回失败，完成堆垛机任务失败，条码：{task.PalletCode},任务号：{task.TaskNum}");
                    }
                    
                    task.ModifyDate = DateTime.Now;
                    task.Modifier = App.User?.UserName;
                    task.Remark = "人工手动完成";
                    BaseDal.DeleteData(task);
                    _task_HtyService.AddTaskHty(task);
                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"手动入库完成");
                }
                else if (task.TaskType == (int)TaskTypeEnum.Inventorybound)
                {
                    string Result = WMSTaskStatusEnum.insuccess.GetDescription();
                    if (task.Creater.Equals("WMS"))
                    {
                        Dt_roadwayinfo roadwayinfo = _Dt_roadwayinfoService.GetRoadwayinfo(task.Roadway);
                        CommandResult command = taskreturn(int.Parse(task.WMStaskid), Result, roadwayinfo.WarehouseInvType, "");
                        if (command.status != "success") return content.Error($"调取上游返回失败，完成堆垛机任务失败，条码：{task.PalletCode},任务号：{task.TaskNum}");

                    }
                    task.ModifyDate = DateTime.Now;
                    task.Modifier = App.User?.UserName;
                    task.Remark = "人工手动完成";
                    BaseDal.DeleteData(task);
                    _task_HtyService.AddTaskHty(task);
                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"手动盘点完成");
                }
                else
                {
                    throw new Exception($"任务类型错误,未找到该任务类型,任务号:【{taskNum}】,任务类型:【{task.TaskType}】");
                }
                content.OK();
            }
            catch (Exception ex)
            {
                content.Error($"任务完成异常,任务号:【{taskNum}】，原因：{ex.Message}");
            }
            return content;
        }

        /// <summary>
        /// æ‰‹åŠ¨åˆ›å»ºä»»åŠ¡
        /// </summary>
        /// <param name="transfer"></param>
        /// <returns></returns>
        public WebResponseContent CreateManualTask(Dt_Task transfer)
        {


            WebResponseContent content = new WebResponseContent();
            try
            {
                IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceName.Contains("堆垛机"));
                // åˆ¤æ–­è®¾å¤‡æ˜¯å¦å­˜åœ¨
                if (device == null)
                {
                    content.Error("手动创建任务失败，原因：未找到堆垛机设备");
                    WriteLog.Write_Log("手动任务创建失败", "创建失败", $"原因：未找到堆垛机设备,托盘编号：{transfer.PalletCode}，任务类型：{transfer.TaskType},起始地址：{transfer.SourceAddress}，目标地址：{transfer.TargetAddress}");
                    return content;
                }

                // åˆ¤æ–­åœ°å€æ˜¯å¦å±žäºŽå½“前设备库
                if ((transfer.TaskType == 300 || transfer.SourceAddress.Contains(device.DeviceCode) ) && transfer.TargetAddress.Contains(device.DeviceCode))
                {
                      
                    // å…¥åº“
                    if (transfer.TaskType == 200)
                    {
                        Dt_PlatformStation _PlatformStation = _dt_PlatformStation.QueryFirst(x => x.Station_code == transfer.SourceAddress);
                        if (_PlatformStation == null)
                        {
                            content.Error($"手动创建任务失败,原因:{device.DeviceCode}库不存在这个库口：{transfer.SourceAddress}");
                            WriteLog.Write_Log("手动任务创建失败", "创建失败", $"托盘编号：{transfer.PalletCode}，任务类型：{transfer.TaskType},起始地址：{transfer.SourceAddress}，目标地址：{transfer.TargetAddress}");

                        }
                        else
                        {
                            // æ­£å¸¸åˆ›å»ºä»»åŠ¡
                            transfer.TaskNum = BaseDal.GetTaskNum(nameof(SequenceEnum.SeqTaskNum));
                            transfer.TaskState = 200;
                            transfer.CurrentAddress = transfer.SourceAddress;
                            transfer.NextAddress = transfer.TargetAddress;
                            transfer.Roadway = device.DeviceCode;
                            transfer.Creater = "WCS";
                            transfer.Grade = 1;
                            transfer.CreateDate = DateTime.Now;
                            _unitOfWorkManage.BeginTran();
                            BaseDal.AddData(transfer);
                            _unitOfWorkManage.CommitTran();
                            content.OK("手动入库任务创建成功！");
                            WriteLog.Write_Log("手动任务创建成功", "创建成功", $"，任务类型：【入库】，任务号：【{transfer.TaskNum}】托盘编号：【{transfer.PalletCode}】,起始地址：【{transfer.SourceAddress}】，目标地址：【{transfer.TargetAddress}】");
                        }
                        return content;

                    }
                    // å‡ºåº“
                    else if (transfer.TaskType == 100)
                    {
                        Dt_PlatformStation _PlatformStation = _dt_PlatformStation.QueryFirst(x => x.Station_code == transfer.TargetAddress);
                        if (_PlatformStation == null)
                        {
                            content.Error($"手动创建任务失败,原因:{device.DeviceCode}库不存在这个库口：{transfer.TargetAddress}");
                        }
                        else
                        {
                            // æ­£å¸¸åˆ›å»ºä»»åŠ¡
                            transfer.TaskNum = BaseDal.GetTaskNum(nameof(SequenceEnum.SeqTaskNum));
                            transfer.TaskState = 100;
                            transfer.CurrentAddress = transfer.SourceAddress;
                            transfer.NextAddress = transfer.TargetAddress;
                            transfer.Roadway = device.DeviceCode;
                            transfer.Creater = "WCS";
                            transfer.Grade = 1;
                            transfer.CreateDate = DateTime.Now;
                            _unitOfWorkManage.BeginTran();
                            BaseDal.AddData(transfer);
                            _unitOfWorkManage.CommitTran();
                            content.OK("手动出库任务创建成功！");
                            WriteLog.Write_Log("手动任务创建成功", "创建成功", $"任务类型：【出库】,任务号：【{transfer.TaskNum}】托盘编号：【{transfer.PalletCode}】，,起始地址：【{transfer.SourceAddress}】，目标地址：【{transfer.TargetAddress}】");
                        }
                        return content;
                    } 
                    else if (transfer.TaskType == 300)
                    {
                            // æ­£å¸¸åˆ›å»ºä»»åŠ¡
                            transfer.TaskNum = BaseDal.GetTaskNum(nameof(SequenceEnum.SeqTaskNum));
                            transfer.TaskState = 300;
                            transfer.CurrentAddress = transfer.SourceAddress;
                            transfer.NextAddress = transfer.TargetAddress;
                            transfer.Roadway = device.DeviceCode;
                            transfer.Creater = "WCS";
                            transfer.Grade = 1;
                            transfer.CreateDate = DateTime.Now;
                            _unitOfWorkManage.BeginTran();
                            BaseDal.AddData(transfer);
                            _unitOfWorkManage.CommitTran();
                            content.OK("手动盘点任务创建成功！");
                        WriteLog.Write_Log("手动任务创建成功", "创建成功", $"，任务类型：【盘点】，任务号：【{transfer.TaskNum}】，托盘编号：【{transfer.PalletCode}】，目标地址：【{transfer.TargetAddress}】");

                        return content;
                    }
                }
                else
                {
                    content.Error($"手动创建任务失败,原因:{device.DeviceCode}库地址不匹配,起始地址：{transfer.SourceAddress}，目标地址：{transfer.TargetAddress}");
                    WriteLog.Write_Log("手动任务创建失败", "创建失败",$"任务号：【{transfer.TaskNum}】，托盘编号：【{transfer.PalletCode}】，目标地址：【{transfer.TargetAddress}】");
                }
            }
            catch (Exception ex)
            {
                content.Error($"手动创建任务失败，系统异常：{ex.Message}");
                WriteLog.Write_Log("手动任务异常", "异常", ex.ToString());
            }
            return content;
        }
        /// <summary>
        /// æ‰‹åŠ¨åˆ é™¤ä»»åŠ¡
        /// </summary>
        /// <param name="taskNum"></param>
        /// <returns></returns>

        public WebResponseContent CreateDelete(int taskNum)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task == null)
                    return WebResponseContent.Instance.Error($"未找到该任务信息,任务号:【{taskNum}】");
                task.ModifyDate = DateTime.Now;
                task.Modifier = App.User?.UserName;
                task.Remark = "人工手动删除";
                content.Status =  BaseDal.DeleteData(task);
                _task_HtyService.AddTaskHty(task);
                _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"手动删除任务");
            }
            catch(Exception e)
            {
                WebResponseContent.Instance.Error(e.Message);
            }
            return content;
        }
        /// <summary>
        /// ç¼–辑
        /// </summary>
        /// <param name="saveModel"></param>
        /// <returns></returns>
        public override WebResponseContent UpdateData(SaveModel saveModel)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                string json = JsonConvert.SerializeObject(saveModel.MainData);
                Dt_Task task = JsonConvert.DeserializeObject<Dt_Task>(json);
                content.Status = BaseDal.UpdateData(task);
            }catch(Exception e)
            {
                WebResponseContent.Instance.Error(e.Message);
            }
            return content;
        }
        ///

        //agv进出状态反馈
        public WebResponseContent getManuaAGVStatus(AgvUpdateRequest agvUpdateRequest)
        {
            //获取WMS调取的参数
            WriteLog.Write_Log("手动agv进出状态反馈接口", "手动agv进出状态信息", $"库口名称：【{agvUpdateRequest.warehousenumber}】，申请状态：【{agvUpdateRequest.agvstatus}】");

            WebResponseContent content = new WebResponseContent();
            try
            {
                string DeciceCodes = "1003";
                if (agvUpdateRequest.warehousenumber.StartsWith("C")) DeciceCodes = "1004";

                IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == DeciceCodes);
                if (device == null) return content.Error("WCS未能获取到库口实例");
                CommonConveyorLine conveyorLine = (CommonConveyorLine)device;

                //是否可进出
                DeviceProDTO? HandShake = conveyorLine.DeviceProDTOs.FirstOrDefault(x => x.DeviceChildCode == agvUpdateRequest.warehousenumber && x.DeviceProParamName == "HandShake");
                if (HandShake == null) return content.Error($"WCS未找到库口：{agvUpdateRequest.warehousenumber},对应的协议");
                DeviceProDTO? Request = conveyorLine.DeviceProDTOs.FirstOrDefault(x => x.DeviceChildCode == agvUpdateRequest.warehousenumber && x.DeviceProParamName == "Request");

                if (agvUpdateRequest.agvstatus == 1)
                {
                    bool HandShakebool = conveyorLine.Communicator.Write<short>(HandShake.DeviceProAddress, 1);
                    if (HandShakebool)
                    {
                        if (Request != null)
                        {
                            conveyorLine.Communicator.Write<short>(Request.DeviceProAddress, 1);
                        }
                        //是否可进出    1允许取  2允许放
                        DeviceProDTO? deviceProDTO = conveyorLine.DeviceProDTOs.FirstOrDefault(x => x.DeviceChildCode == agvUpdateRequest.warehousenumber && x.DeviceProParamName == "PermitHandShake");
                        //是否有货
                        DeviceProDTO? StationNumProDTO = conveyorLine.DeviceProDTOs.FirstOrDefault(x => x.DeviceChildCode == agvUpdateRequest.warehousenumber && x.DeviceProParamName == "StationNum");
                        if (deviceProDTO == null || StationNumProDTO == null) return content.Error($"WCS未找到库口：{agvUpdateRequest.warehousenumber},对应的协议");
                        int statusValue = 0;
                        int portStatus = conveyorLine.Communicator.Read<ushort>(deviceProDTO.DeviceProAddress);
                        int StationStatus = conveyorLine.Communicator.Read<ushort>(StationNumProDTO.DeviceProAddress);

                        //有货，可进信号
                        statusValue = ((portStatus == 1 && StationStatus == 1) || (portStatus == 2 && StationStatus == 0)) ? 1 : (portStatus == 0) ? 0 : 0;
                        if (agvUpdateRequest.warehousenumber == "G01" || agvUpdateRequest.warehousenumber == "G06" || agvUpdateRequest.warehousenumber == "G07")
                        {
                            if (statusValue == 1)
                            {
                                return content.OK("申请进入成功");

                            }
                            else
                            {
                                conveyorLine.Communicator.Write<short>(Request.DeviceProAddress, 0);
                                return content.Error("读取plc不可进入信息");
                            }
                        }
                        else
                        {
                            return content.OK("申请进入成功");
                        }
                    }
                    else
                    {
                        return content.Error("写入plc进入信号失败");
                    }
                }
                else if (agvUpdateRequest.agvstatus == 2)
                {
                    //写入输送线信号
                    bool portStatus = conveyorLine.Communicator.Write<short>(HandShake.DeviceProAddress, 0);
                    if (portStatus)
                    {
                        if (Request != null)
                        {
                            conveyorLine.Communicator.Write<short>(Request.DeviceProAddress, 0);
                        }
                        return content.OK("申请退出成功");
                    }
                    else
                    {
                        return content.Error("写入plc清除信号失败");
                    }
                }
                else
                {
                    return content.Error($"agv对应的申请错误，字段：agvstatus，申请的值：{agvUpdateRequest.agvstatus}");
                }

            }
            catch (Exception ex)
            {
                return content.Error($"WCS任务添加错误，原因：{ex.Message}");
            }
        }
    }
}