SX-WCS/业务工程/时效库/WCS.WorkEngineering/WebApi/Controllers/WcsController.cs

using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using PlcSiemens.Core.Extension;
using ServiceCenter;
using ServiceCenter.Attributes;
using ServiceCenter.Extensions;
using ServiceCenter.Redis;
using ServiceCenter.SqlSugars;
using System.Net.NetworkInformation;
using System.Text;
using WCS.Core;
using WCS.Entity;
using WCS.Entity.Protocol.DataStructure;
using WCS.Entity.Protocol.SRM;
using WCS.WorkEngineering.Extensions;
using WCS.WorkEngineering.Systems;
using WCS.WorkEngineering.WebApi.Models.WCS.Request;
using WCS.WorkEngineering.WebApi.Models.WCS.Response;
using WCS.WorkEngineering.WebApi.Models.WMS.Response;

namespace WCS.WorkEngineering.WebApi.Controllers
{
 
 
    /// <summary>
    /// WCS相关接口控制器
    /// </summary>
    [ApiController]
    [Route("api/[controller]/[action]")]
    public class WcsController : ControllerBase
    {
    

        /// <summary>
        ///  获取设备配置信息接口
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public List<Device> GetDeviceList()
        {
            return Device.All.ToList();
        }

        /// <summary>
        ///  设备信息写入接口
        /// </summary>
        [HttpPost]
        public void GetDevList()
        {
            var a = RedisHub.Monitor.LRange("Packs", 0, 80000);
            var packs = a.Select(JsonConvert.DeserializeObject<DeviceDataPack>).ToList();
        }

        /// <summary>
        ///  任务处理接口
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        [HttpPost, Log("任务处理接口")]
        public SRes<HandleTaskResponse> HandleTask([FromBody] HandleTaskRequest req)
        {
            var response = new SRes<HandleTaskResponse>() { ResCode = ResponseStatusCodeEnum.Sucess, ResDataList = new List<HandleTaskResponse>() };

            switch (req.Type)
            {
                //取消任务
                case HandleTaskTypeEnum.取消任务:
                    SqlSugarHelper.Do(db =>
                    {
                        foreach (var item in req.TaskIds)
                        {
                            var task = db.Default.Queryable<WCS_TaskInfo>().Where(t => t.ID == item).First();
                            if (task != null)
                            {
                                //验证wms是否能取消
                                var res = WmsApi.HandleTaskVerify(response, item, 106);
                                if (res == null) continue;

                                switch (task.Type)
                                {
                                    //case TaskType.SetPlate:
                                        //if (task.Status != Entity.TaskStatus.WaitingToExecute)
                                        //{
                                        //    response.ResDataList.Add(new HandleTaskResponse()
                                        //    {
                                        //        IsSuccess = false,
                                        //        TaskNo = item,
                                        //        Message = $"只能取消待执行状态组盘任务",
                                        //    });
                                        //    continue;
                                        //}
                                        //break;

                                    //case TaskType.EnterDepot:
                                        //if (task.Status >   Entity.TaskStatus.NewBuild)
                                        //{
                                        //    response.ResDataList.Add(new HandleTaskResponse()
                                        //    {
                                        //        IsSuccess = false,
                                        //        TaskNo = item,
                                        //        Message = $"只能取消待执行状态入库任务",
                                        //    });
                                        //    continue;
                                        //}
                                        //break;

                                    case TaskType.OutDepot:
                                        if (task.Status > Entity.TaskStatus.WaitingToExecute)
                                        {
                                            response.ResDataList.Add(new HandleTaskResponse()
                                            {
                                                IsSuccess = false,
                                                TaskNo = item,
                                                Message = $"只能取消待执行状态出库任务",
                                            });
                                            continue;
                                        }

                                        break;

                                    case TaskType.TransferDepot:
                                        if (task.Status > Entity.TaskStatus.WaitingToExecute)
                                        {
                                            response.ResDataList.Add(new HandleTaskResponse()
                                            {
                                                IsSuccess = false,
                                                TaskNo = item,
                                                Message = $"无法取消{task.Status.GetDescription()}的移库任务,只能取消新建/待执行的移库任务",
                                            });
                                            continue;
                                        }
                                        break;

                                    case TaskType.Delivery:

                                        break;

                                    case TaskType.EmptyInit:
                                        if (task.Status != Entity.TaskStatus.WaitingToExecute)
                                        {
                                            response.ResDataList.Add(new HandleTaskResponse()
                                            {
                                                IsSuccess = false,
                                                TaskNo = item,
                                                Message = $"只能取消待执行状态空轮初始化任务",
                                            });
                                            continue;
                                        }
                                        break;

                                    default:
                                        throw new ArgumentOutOfRangeException();
                                }

                                var cancelRes = WmsApi.CarryTaskInfo(response, item, 106);
                                if (cancelRes == null) continue;

                                //找到对应的AGV任务
                                var agv = db.Default.Queryable<WCS_AgvTaskInfo>().Where(v => v.ID == task.AgvTaskID && v.AgvStatus < AGVTaskStatus.MissionCompleted).SplitTable(v => v.Take(2)).First();
                                if (agv != null)
                                {
                                    if (!agv.AgvID.IsNullOrEmpty())
                                    {
                                        var cancelTaskUpdateRes = AgvApi.CancelAgvTask(response, item, agv.AgvID);
                                        //if (cancelTaskUpdateRes == null) continue;
                                    }
                                    agv.Status = AGVTaskStatus.Cancel;
                                    agv.AgvStatus = AGVTaskStatus.Cancel;
                                    db.Default.Updateable(agv).SplitTable(x=>x.Take(2)).ExecuteCommand();
                                }
                                //更新任务状态
                                task.Status = Entity.TaskStatus.Cancel;
                                task.EedTime = DateTime.Now;
                                task.EditWho = req.User;
                                task.ManualRemarks = req.ManualRemarks;
                                db.Default.Updateable(task).ExecuteCommand();
                                task.AddWCS_TASK_DTL(db.Default, "未知", "任务取消");
                            }
                            else
                            {
                                response.ResDataList.Add(new HandleTaskResponse()
                                {
                                    IsSuccess = false,
                                    TaskNo = item,
                                    Message = $"未找到对应任务{item}"
                                });
                            }
                        }
                    });
                    break;
                // 完成任务
                case HandleTaskTypeEnum.完成任务:
                    SqlSugarHelper.Do(db =>
                    {
                        foreach (var item in req.TaskIds)
                        {
                            var task = db.Default.Queryable<WCS_TaskInfo>().Where(t => t.ID == item).First();
                            if (task == null) continue;
                            switch (task.Type)
                            {
                                case TaskType.OutDepot:
                                    {
                                        var res = WmsApi.HandleTaskVerify(response, item, 99);
                                        if (res == null) continue;
                                        if (task.BusType == "装箱码垛" || task.BusType == "扭转检测")
                                        {
                                            response.ResDataList.Add(new HandleTaskResponse()
                                            {
                                                IsSuccess = false,
                                                TaskNo = item,
                                                Message = $"当前任务不能手工完成",
                                            });
                                            continue;
                                        }
                                        if (task.Status >= Entity.TaskStatus.Finish)
                                        {
                                            response.ResDataList.Add(new HandleTaskResponse()
                                            {
                                                IsSuccess = false,
                                                TaskNo = item,
                                                Message = $"只能完成未完成状态的任务",
                                            });
                                            continue;
                                        }
                                        var cancelRes = WmsApi.CarryTaskInfo(response, item, 99);
                                        if (cancelRes == null) continue;

                                        //找到对应的AGV任务
                                        var agv = db.Default.Queryable<WCS_AgvTaskInfo>().Where(v => v.ID == task.AgvTaskID && v.AgvStatus < AGVTaskStatus.MissionCompleted).SplitTable(v => v.Take(2)).First();
                                        if (agv != null)
                                        {
                                            //if (!agv.AgvID.IsNullOrEmpty())
                                            //{
                                            //    var cancelTaskUpdateRes = CancelAgvTask(response, item, agv.AgvID);
                                            //    if (cancelTaskUpdateRes == null) continue;
                                            //}
                                            agv.Status = AGVTaskStatus.MissionCompleted;
                                            agv.AgvStatus = AGVTaskStatus.MissionCompleted;
                                            db.Default.Updateable(agv).SplitTable(x=>x.Take(2)).ExecuteCommand();
                                        }
                                        //更新任务状态
                                        task.Status = Entity.TaskStatus.Finish;
                                        task.EedTime = DateTime.Now;
                                        task.EditWho = req.User;
                                        task.ManualRemarks = req.ManualRemarks;
                                        db.Default.Updateable(task).ExecuteCommand();
                                        task.AddWCS_TASK_DTL(db.Default, "未知", "任务完成");
                                        break;
                                    }
                                case TaskType.EnterDepot:
                                    {
                                        var res = WmsApi.HandleTaskVerify(response, item, 99);
                                        if (res == null) continue;

                                        switch (task.Type)
                                        {
                                            case TaskType.EnterDepot:
                                                if (task.Status >= Entity.TaskStatus.Finish)
                                                {
                                                    response.ResDataList.Add(new HandleTaskResponse()
                                                    {
                                                        IsSuccess = false,
                                                        TaskNo = item,
                                                        Message = $"只能完成未完成状态的任务",
                                                    });
                                                    continue;
                                                }
                                                if (task.AddrTo.Length < 6)
                                                {
                                                    response.ResDataList.Add(new HandleTaskResponse()
                                                    {
                                                        IsSuccess = false,
                                                        TaskNo = item,
                                                        Message = $"只能完成已分配货位的任务",
                                                    });
                                                    continue;
                                                }
                                                break;

                                            case TaskType.SetPlate:
                                            case TaskType.OutDepot:
                                            case TaskType.TransferDepot:
                                            case TaskType.Delivery:
                                            case TaskType.EmptyInit:
                                                break;
                                            default:
                                                throw new ArgumentOutOfRangeException();
                                        }

                                        var cancelRes = WmsApi.CarryTaskInfo(response, item, 99);
                                        if (cancelRes == null) continue;

                                        //找到对应的AGV任务
                                        var agv = db.Default.Queryable<WCS_AgvTaskInfo>().Where(v => v.ID == task.AgvTaskID && v.AgvStatus < AGVTaskStatus.MissionCompleted).SplitTable(v => v.Take(2)).First();
                                        if (agv != null)
                                        {
                                            //if (!agv.AgvID.IsNullOrEmpty())
                                            //{
                                            //    var cancelTaskUpdateRes = CancelAgvTask(response, item, agv.AgvID);
                                            //    if (cancelTaskUpdateRes == null) continue;
                                            //}
                                            agv.Status = AGVTaskStatus.MissionCompleted;
                                            agv.AgvStatus = AGVTaskStatus.MissionCompleted;
                                            db.Default.Updateable(agv).SplitTable(x=>x.Take(2)).ExecuteCommand();
                                        }
                                        //更新任务状态
                                        task.Status = Entity.TaskStatus.Finish;
                                        task.EedTime = DateTime.Now;
                                        task.EditWho = req.User;
                                        task.ManualRemarks = req.ManualRemarks;

                                        db.Default.Updateable(task).ExecuteCommand();
                                        task.AddWCS_TASK_DTL(db.Default, "未知", "任务完成");
                                        break;
                                    }
                                case TaskType.SetPlate:
                                case TaskType.TransferDepot:
                                case TaskType.Delivery:
                                case TaskType.EmptyInit:
                                default:
                                    response.ResDataList.Add(new HandleTaskResponse()
                                    {
                                        IsSuccess = false,
                                        TaskNo = item,
                                        Message = $"未找到对应任务{item}"
                                    });
                                    break;
                            }
                        }
                    });
                    break;

                
                default:
                    throw new ArgumentOutOfRangeException();
            }
            return response;
        }

   
    }
}