webdoorcreator/WebDoorCreator.SDK/WDC.cs

using Newtonsoft.Json;
using RestSharp;
using System.Collections.Generic;
using System.Net.NetworkInformation;

namespace WebDoorCreator.SDK
{
    public class WDC
    {
        #region Public Constructors

        /// <summary>
        /// Classe per effettuare comunicazioni con NKC
        /// </summary>
        /// <param name="baseIp">IP di base x ping</param>
        /// <param name="baseUrl">URL di base x chiamate REST</param>
        /// <param name="wksCode">Codice workstation di calcolo</param>
        public WDC(string baseIp, string baseUrl, string wksCode)
        {
            _baseIp = baseIp;
            apiUrl = baseUrl;
            _wksCode = wksCode;
        }

        #endregion Public Constructors

        #region Public Properties

        /// <summary>
        /// Numero di chiamate in coda da processare
        /// </summary>
        public int numTask2proc
        {
            get
            {
                int answ = 0;
                try
                {
                    var rawData = callUrlGet(urlActLenght);
                    if (rawData != "ERR")
                    {
                        var returnData = JsonConvert.DeserializeObject<Dictionary<string, long>>(rawData);
                        // rendo!
                        if (returnData.ContainsKey(pendQueue))
                        {
                            answ = (int)returnData[pendQueue];
                        }
                    }
                }
                catch { }
                return answ;
            }
        }

        /// <summary>
        /// Effettua test alive all'indirizzo del server
        /// </summary>
        public bool testAlive
        {
            get
            {
                bool answ = false;
                try
                {
                    var rawData = callUrlGet(urlAlive);
                    string returnData = JsonConvert.DeserializeObject<string>(rawData);
                    answ = returnData == "OK";
                }
                catch
                { }
                // rendo!
                return answ;
            }
        }

        /// <summary>
        /// Effettua test ping all'indirizzo del server
        /// </summary>
        public PingReply testPing
        {
            get
            {
                Ping myPing = new Ping();
                // timeout a 1 sec!
                PingReply answ = myPing.Send(_baseIp, 1000);
                // rendo!
                return answ;
            }
        }
        /// <summary>
        /// Effettua test ping all'indirizzo del server
        /// </summary>
        public bool testPingOk
        {
            get
            {
                bool answ = false;
                try
                {
                    Ping myPing = new Ping();
                    // timeout a 1 sec!
                    var testPing= myPing.Send(_baseIp, 1000);
                    answ = testPing.Status == IPStatus.Success;
                }
                catch
                { }
                // rendo!
                return answ;
            }
        }

        #endregion Public Properties

        #region Public Methods

        public static PingReply testPingDevice(string address)
        {
            Ping myPing = new Ping();
            // timeout a 1 sec!
            PingReply answ = myPing.Send(address, 2000);
            // rendo!
            return answ;
        }

        /// <summary>
        /// Elenco degli item da processare, nel formato DoorId, Vers
        /// </summary>
        public Dictionary<string, CalcReqtDTO> queueList(int maxNum)
        {
            Dictionary<string, CalcReqtDTO> returnData = new Dictionary<string, CalcReqtDTO>();
            Dictionary<string, string> parList = new Dictionary<string, string>()
                {
                    { "numItems", $"{maxNum}" }
                };
            var rawData = callUrlGet(urlTakeNextItems, parList);
            if (!string.IsNullOrEmpty(rawData) && rawData != "ERR")
            {
                returnData = JsonConvert.DeserializeObject<Dictionary<string, CalcReqtDTO>>(rawData);
            }
            return returnData;
        }

        /// <summary>
        /// Status delle code chiamate
        /// </summary>
        public Dictionary<string, long> queueStatus()
        {
            Dictionary<string, long> returnData = new Dictionary<string, long>();
            var rawData = callUrlGet(urlActLenght);
            if (rawData != "ERR")
            {
                returnData = JsonConvert.DeserializeObject<Dictionary<string, long>>(rawData);
            }
            return returnData;
        }

        /// <summary>
        /// Reset di tutte le code a REQUEST
        /// </summary>
        /// <returns></returns>
        public string ResetQueue()
        {
            Dictionary<string, string> parList = new Dictionary<string, string>
            {
                { "passPhrase", "bbbBirdIsTheWord" }
            };
            var rawData = callUrlPost(urlResetQueue, "", parList);
            return rawData;
        }
        /// <summary>
        /// Reset delle code di processing  a REQUEST
        /// </summary>
        /// <returns></returns>
        public string ResetQueueProcessing()
        {
            var rawData = callUrlPost(urlResetQueueProc, "");
            return rawData;
        }

        /// <summary>
        /// Restitusice l'elenco degli esiti di processing
        /// </summary>
        /// <param name="calcResults"></param>
        /// <returns></returns>
        public string SendProcResults(List<CalcResultDTO> calcResults)
        {
            string payload = JsonConvert.SerializeObject(calcResults);
            var rawData = callUrlPost(urlSaveProcRes, payload);
            return rawData;
        }

        #endregion Public Methods

        #region Protected Fields

        protected const string pendQueue = "pending";
        protected const string urlActLenght = "api/Queue/ActLenght";
        protected const string urlAlive = "/api/Alive";
        protected const string urlResetQueue = "api/Queue/ResetQueue";
        protected const string urlResetQueueProc = "api/Queue/ResetQueueProcessing";
        protected const string urlSaveProcRes = "api/Queue/SaveProcResult";
        protected const string urlStatusList = "api/Queue/StatusList";
        protected const string urlTakeNextItems = "api/Queue/TakeNextItems";

        #endregion Protected Fields

        #region Protected Properties

        /// <summary>
        /// DnsName/IP di base x chaimate
        /// </summary>
        protected string _baseIp { get; set; } = "seriate.steamware.net";

        /// <summary>
        /// Cod Workstation che effettua i calcoli
        /// </summary>
        protected string _wksCode { get; set; } = "";

        /// <summary>
        /// URL di base per la comunicazione
        ///
        /// PROD: https://iis01.egalware.com/WDC/SRV/
        /// DEV:  https://localhost:7043/
        /// </summary>
        protected string apiUrl { get; set; } = @"https://iis01.egalware.com/WDC/SRV/";

        #endregion Protected Properties

        #region Protected Methods

        /// <summary>
        /// Effettua chiamata URL GET e restituisce risultato
        /// </summary>
        /// <param name="URL"></param>
        /// <returns></returns>
        protected string callUrlGet(string URL)
        {
            string answ = "";
            // cerco online
            using (RestClient client = new RestClient(apiUrl))
            {
                var request = new RestRequest(URL);
                try
                {
                    var response = client.Get(request);
                    // controllo status code risposta
                    if (response.StatusCode == System.Net.HttpStatusCode.OK)
                    {
                        // deserializzo risposta
                        answ = response.Content;
                    }
                    else
                    {
                        answ = "KO";
                    }
                }
                catch
                {
                    answ = "ERR";
                }
            }
            // restituisco valore!
            return answ;
        }

        /// <summary>
        /// Effettua chiamata URL GET con parametri e restituisce risultato
        /// </summary>
        /// <param name="URL"></param>
        /// <param name="paramsList"></param>
        /// <returns></returns>
        protected string callUrlGet(string URL, Dictionary<string, string> paramsList)
        {
            string answ = "";
            // cerco online
            using (RestClient client = new RestClient(apiUrl))
            {
                // compongo
                string paramsQuery = "";
                foreach (var item in paramsList)
                {
                    paramsQuery += $"{item.Key}={item.Value}";
                }
                var request = new RestRequest($"{URL}?{paramsQuery}");
                try
                {
                    var response = client.Get(request);
                    // controllo status code risposta
                    if (response.StatusCode == System.Net.HttpStatusCode.OK)
                    {
                        // deserializzo risposta
                        answ = response.Content;
                    }
                    else
                    {
                        answ = "KO";
                    }
                }
                catch
                {
                    answ = "ERR";
                }
            }
            // restituisco valore!
            return answ;
        }

        /// <summary>
        /// Effettua chiamata URL GET con parametri e restituisce risultato
        /// </summary>
        /// <param name="URL"></param>
        /// <param name="payload"></param>
        /// <returns></returns>
        protected string callUrlPost(string URL, string payload)
        {
            string answ = "";
            // cerco online
            using (RestClient client = new RestClient(apiUrl))
            {
                var request = new RestRequest(URL);
                request.AddJsonBody(payload);
                try
                {
                    var response = client.Post(request);
                    // controllo status code risposta
                    if (response.StatusCode == System.Net.HttpStatusCode.OK)
                    {
                        // deserializzo risposta
                        answ = response.Content;
                    }
                    else
                    {
                        answ = "KO";
                    }
                }
                catch
                {
                    answ = "ERR";
                }
            }
            // restituisco valore!
            return answ;
        }

        /// <summary>
        /// Effettua chiamata URL POST con parametri (opzionali) e payload (opzionale) e restituisce risultato
        /// </summary>
        /// <param name="URL"></param>
        /// <param name="payload"></param>
        /// <param name="paramsList"></param>
        /// <returns></returns>
        protected string callUrlPost(string URL, string payload, Dictionary<string, string> paramsList)
        {
            string answ = "";
            // cerco online
            using (RestClient client = new RestClient(apiUrl))
            {
                var request = new RestRequest(URL);
                // compongo
                string paramsQuery = "";
                if (paramsList != null && paramsList.Count > 0)
                {
                    foreach (var item in paramsList)
                    {
                        paramsQuery += $"{item.Key}={item.Value}";
                    }
                    request = new RestRequest($"{URL}?{paramsQuery}");
                }
                if (!string.IsNullOrEmpty(payload))
                {
                    request.AddJsonBody(payload);
                }
                try
                {
                    var response = client.Post(request);
                    // controllo status code risposta
                    if (response.StatusCode == System.Net.HttpStatusCode.OK)
                    {
                        // deserializzo risposta
                        answ = response.Content;
                    }
                    else
                    {
                        answ = "KO";
                    }
                }
                catch
                {
                    answ = "ERR";
                }
            }
            // restituisco valore!
            return answ;
        }

        #endregion Protected Methods
    }
}