WcsFramework/WCS.WorkEngineering/WebApi/Controllers/WcsController.cs

using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using ServiceCenter;
using ServiceCenter.Redis;
using ServiceCenter.SqlSugars;
using SqlSugar.Extensions;
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;

namespace WCS.WorkEngineering.WebApi.Controllers
{
    /// <summary>
    /// WCS相关接口控制器
    /// </summary>
    [ApiController]
    [Route("api/[controller]/[action]")]
    public class WcsController : ControllerBase, IDeviceWriter
    {
        /// <summary>
        ///  任务处理接口
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        [HttpPost]
        public HandleTaskResponse HandleTask([FromBody] HandleTaskRequest req)
        {
            var response = new HandleTaskResponse() { IsSuccess = false, Message = "失败" };

            //取消任务
            if (req.Type == HandleTaskTypeEnum.取消任务)
            {
                foreach (var item in req.TaskIds)
                {
                    SqlSugarHelper.Do(db =>
                    {
                        var task = db.Default.Queryable<WCS_TaskInfo>().Where(t => t.ID == item).First();
                        if (task != null)
                        {
                            //验证wms是否能取消
                            var res = WmsApi.HandleTaskVerify(new List<int>() { task.ID }, "106");
                            if (res.ResCode == Models.WMS.Response.ResponseStatusCodeEnum.Sucess)
                            {
                                //取消任务
                                var cancelRes = WmsApi.CarryTaskInfo(new List<int>() { task.ID }, "106");
                                if (cancelRes.ResCode == Models.WMS.Response.ResponseStatusCodeEnum.Sucess)
                                {
                                    //更新任务状态
                                    task.Status = Entity.TaskStatus.Cancel;
                                    task.EditTime = DateTime.Now;
                                    task.AddWCS_TASK_DTL(db, "未知", "任务取消");
                                    db.Default.Updateable(task).ExecuteCommand();
                                    response.IsSuccess = true;
                                    response.Message = "成功";
                                }
                                else
                                {
                                    response.IsSuccess = false;
                                    response.Message = $"取消任务失败，{cancelRes.ResMsg}";
                                }
                            }
                            else
                            {
                                response.IsSuccess = false;
                                response.Message = $"取消任务失败，{res.ResMsg}";
                            }
                        }
                        else
                        {
                            response.IsSuccess = false;
                            response.Message = $"未找到对应任务{item}";
                        }
                    });
                }
            }
            // 完成任务
            else if (req.Type == HandleTaskTypeEnum.完成任务)
            {
                foreach (var item in req.TaskIds)
                {
                }
            }

            return response;
        }

        /// <summary>
        ///  设备信息写入接口
        /// </summary>
        /// <param name="deviceType">需要写入信息的设备类型</param>
        /// <param name="devCode">设备编号</param>
        /// <param name="protocol">设备协议类名</param>
        /// <param name="propName">写入字段名</param>
        /// <param name="value">值</param>
        [HttpPost]
        public void Write(DeviceTypeEnum deviceType, string devCode, string protocol, string propName, string value)
        {
            World.GetSystemInstance<DeviceWriteSystem>().Invoke(new DeviceWriteInfo
            {
                DeviceType = deviceType,
                Code = devCode,
                Protocol = protocol,
                Property = propName,
                Value = value
            });
        }

        /// <summary>
        ///  设备信息写入接口
        /// </summary>
        /// <param name="deviceType">需要写入信息的设备类型</param>
        /// <param name="devCode">设备编号</param>
        /// <param name="protocol">设备协议类名</param>
        /// <param name="propName">写入字段名</param>
        /// <param name="value">值</param>
        [HttpPost]
        public void GetDevList()
        {
            var a = RedisHub.Monitor.LRange("Packs", 0, 80000);
            List<DeviceDataPack> packs = new List<DeviceDataPack>();
            foreach (var item in a)
            {
                packs.Add(JsonConvert.DeserializeObject<DeviceDataPack>(item));
            }

        }

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

        /// <summary>
        ///  获取设备信息
        /// </summary>
        /// <param name="name">设备名称</param>
        /// <returns></returns>
        [HttpGet]
        public object GetDeviceInfo(string name)
        {
            var obj = World.GetSystemInstance<GetDeviceSystem>().Invoke(name);

            return obj;
        }

        /// <summary>
        ///  堆垛机测试
        /// </summary>
        /// <param name="srmcod">堆垛机编号</param>
        /// <param name="typeEnum">任务类型</param>
        /// <param name="value1">起始行</param>
        /// <param name="value2">起始列</param>
        /// <param name="value3">起始层</param>
        /// <param name="value4">目标行</param>
        /// <param name="value5">目标列</param>
        /// <param name="value6">目标层</param>
        [HttpPost]
        public void SrmDeBug(string srmcod, SrmTaskTypeEnum typeEnum, short value1, short value2, short value3, short value4, short value5, short value6)
        {
            World.GetSystemInstance<SrmDebugSystem>().Invoke(new SrmDebugInfo
            {
                SrmCode = srmcod,
                srmTaskType = typeEnum,
                SLine = value1,
                SCol = value2,
                SLayer = value3,
                ELine = value4,
                ECol = value5,
                ELayer = value6
            });
        }

        #region 设备IP相关

        /// <summary>
        ///  获取设备Ip集合
        /// </summary>
        /// <returns>设备Ip集合</returns>
        [HttpGet]
        public List<string> GetDeviceIpList()
        {
            if (!ServiceHub.DeviceIPList.Any()) throw new Exception("未配置任何Ip");
            return ServiceHub.DeviceIPList;
        }

        /// <summary>
        ///  获取设备IP检测结果
        /// </summary>
        /// <returns>设备IP检测结果</returns>
        [HttpGet]
        public List<DeviceIpTestResults> DeviceIpTest()
        {
            if (!ServiceHub.DeviceIPList.Any()) throw new Exception("未配置任何Ip");
            List<DeviceIpTestResults> deviceIpTestResults = new List<DeviceIpTestResults>();
            ServiceHub.DeviceIPList.ForEach(ip =>
            {
                deviceIpTestResults.Add(new DeviceIpTestResults
                {
                    Ip = ip,
                    Result = PingIpOrDomainName(ip)
                });
            });

            return deviceIpTestResults;
        }

        /// <summary>
        /// 检查Ip是否正常联通
        /// </summary>
        /// <param name="strIpOrDName">输入参数,表示IP地址或域名</param>
        /// <returns></returns>
        public static bool PingIpOrDomainName(string strIpOrDName)
        {
            try

            {
                Ping objPingSender = new Ping();

                PingOptions objPinOptions = new PingOptions();

                objPinOptions.DontFragment = true;

                string data = "";

                byte[] buffer = Encoding.UTF8.GetBytes(data);

                int intTimeout = 120;

                PingReply objPinReply = objPingSender.Send(strIpOrDName, intTimeout, buffer, objPinOptions);

                string strInfo = objPinReply.Status.ToString();

                if (strInfo == "Success")

                {
                    return true;
                }
                else

                {
                    return false;
                }
            }
            catch (Exception)

            {
                return false;
            }
        }

        #endregion 设备IP相关
    }

    public interface IDeviceWriter
    {
        [HttpPost]
        void Write(DeviceTypeEnum deviceType, string devCode, string protocol, string propName, string value);
    }

    /// <summary>
    ///  设备Ip通讯检测结构
    /// </summary>
    public class DeviceIpTestResults
    {
        public string Ip { get; set; }

        public bool Result { get; set; }
    }
}