mapo-iob-libs/EgwProxy.Icoel/Connector.cs

using EgwProxy.Icoel.Compac;
using EgwProxy.Icoel.SizerService;
using System;
using System.Collections.Generic;

namespace EgwProxy.Icoel
{
    /// <summary>
    /// Connettore proxy x servizi rest di Icoel
    /// </summary>
    public class Connector
    {
        #region Public Constructors

        /// <summary>
        /// Inizializazzione classe con salvataggio ip/porta del webservice del sizer
        /// </summary>
        /// <param name="ipAddress">Indirizzo IP del sizer</param>
        /// <param name="tcpPort">POrta del sizer (default 8001)</param>
        public Connector(string ipAddress, string tcpPort)
        {
            this.ipAddress = ipAddress;
            this.tcpPort = tcpPort;
        }

        #endregion Public Constructors

        #region Public Methods

        /// <summary>
        /// Verifica il fornitore e se non ci fosse crea
        /// </summary>
        /// <param name="GrowerData">Struttura GrowerInfo del fornitore</param>
        public void CheckGrower(GrowerInfo GrowerData)
        {
            using (var Client = new ComClient(ipAddress, tcpPort))
            {
                Client.CheckGrower(GrowerData.GrowerCode, GrowerData.GrowerName);
            }
        }
        /// <summary>
        /// Recupera array varie velocità rilevate
        /// </summary>
        /// <returns>Dictionary<string, double> delle velocità rilevate sul sizer</returns>
        public Dictionary<string, double> GetPerfMeters()
        {
            Dictionary<string, double> answ = new Dictionary<string, double>();
            using (var Client = new ComClient(ipAddress, tcpPort))
            {
                answ = Client.GetPerfMeters();
            }
            return answ;
        }


        /// <summary>
        /// Recupera array dei batch sulle 2 linee: ID batch + layout + varietà x ogni linea...
        /// </summary>
        /// <returns>Dictionary<string, string> dei dati correnti x linea (batch, layout, variety) rilevate sul sizer</returns>
        public Dictionary<string, string> GetCurrBatchData()
        {
            Dictionary<string, string> answ = new Dictionary<string, string>();
            var batchData = GetCurrentBatch();
            foreach (var item in batchData)
            {
                answ.Add($"L{item.Key}_Batch", $"{item.Value.Id} | {item.Value.Name} | {item.Value.StartTime}");
                answ.Add($"L{item.Key}_Grower", $"{item.Value.GrowerCode}");
                answ.Add($"L{item.Key}_Layout", $"{item.Value.LayoutId} | {item.Value.LayoutName}");
                answ.Add($"L{item.Key}_Variety", $"{item.Value.VarietyId} | {item.Value.VarietyName}");
            }
            return answ;
        }

        /// <summary>
        /// Invia un lotto in coda produzione sul sizer
        /// </summary>
        /// <param name="newBatch">Batch da accodare</param>
        public void EnqueueBatch(GrowerInfo GrowerData, Guid varGuid, Guid layGuid)
        {
            using (var Client = new ComClient(ipAddress, tcpPort))
            {
                // va bene anche se vuoto! come lo torna ora...
                string sizingProfile = Client.GetCurrentBatch().SizingProfileName;
                //var rawData = Client.GetCurrentBatchByLane(1);
                //var rawData2 = Client.GetCurrentBatchByLane(2);
                Batch newBatch = CreateBatch(GrowerData, varGuid, layGuid, sizingProfile);
                Client.MettiLottoInCoda(newBatch);
            }
        }

        /// <summary>
        /// Recupera elenco dei Batch correnti
        /// </summary>
        /// <returns>Dizionario dei batch sulle due linee (1=SX, 2=DX)</returns>
        public Dictionary<int, Batch> GetCurrentBatch()
        {
            Dictionary<int, Batch> outVal = new Dictionary<int, Batch>();
            using (var Client = new ComClient(ipAddress, tcpPort))
            {
                //Client.GetCurrentBatch();
                for (int i = 1; i <= 2; i++)
                {
                    var batch = Client.GetCurrentBatchByLane(i);
                    outVal.Add(i, batch);
                }
            }
            return outVal;
        }

        /// <summary>
        /// Restituisce un dictionary di varietà e relativi layout
        /// </summary>
        /// <returns>Dizionario: key=Variety, value=Layout[] associati</returns>
        public Dictionary<Variety, Layout[]> GetLayoutAndVariety()
        {
            Dictionary<Variety, Layout[]> outVal = new Dictionary<Variety, Layout[]>();
            using (var Client = new ComClient(ipAddress, tcpPort))
            {
                Variety[] varietiesList = Client.GetActiveVarieties();
                foreach (var item in varietiesList)
                {
                    // recupero layout della varietà
                    var layoutList = Client.GetLayouts(item.Id);
                    outVal.Add(item, layoutList);
                }
            }
            // restituisco dati
            return outVal;
        }

        /// <summary>
        /// Restituisce un array di Layout validi data Guid della Variety
        /// </summary>
        /// <param name="varietiesList"></param>
        /// <returns>Array di Layout della varietà dato suo Guid</returns>
        public Layout[] GetLayoutForVariety(Guid varGuid)
        {
            Layout[] outVal = new Layout[1];
            using (var Client = new ComClient(ipAddress, tcpPort))
            {
                // recupero layout della varietà
                var layoutList = Client.GetLayouts(varGuid);
                outVal = layoutList;
            }
            // restituisco dati
            return outVal;
        }

        /// <summary>
        /// Restituisce un dictionary di layout validi x un array di varietà fornito
        /// </summary>
        /// <param name="varietiesList">Array varietà di cui ottenere i layout</param>
        /// <returns>Dizionario: key=Variety, value=Layout[] associati</returns>
        public Dictionary<Variety, Layout[]> GetLayoutForVarietyList(Variety[] varietiesList)
        {
            Dictionary<Variety, Layout[]> outVal = new Dictionary<Variety, Layout[]>();
            using (var Client = new ComClient(ipAddress, tcpPort))
            {
                foreach (var item in varietiesList)
                {
                    // recupero layout della varietà
                    var layoutList = Client.GetLayouts(item.Id);
                    outVal.Add(item, layoutList);
                }
            }
            // restituisco dati
            return outVal;
        }

        /// <summary>
        /// Restituisce elenco delle Variety
        /// </summary>
        /// <param name="onlyActive">Solo attive (true) o tutte (false)</param>
        /// <returns>Elenco delel Variety trovate</returns>
        public Variety[] GetVarietyList(bool onlyActive = true)
        {
            Variety[] varietiesList;
            using (var cClient = new ComClient(ipAddress, tcpPort))
            {
                if (onlyActive)
                {
                    varietiesList = cClient.GetActiveVarieties();
                }
                else
                {
                    varietiesList = cClient.GetAllVarieties();
                }
            }
            return varietiesList;
        }

        #endregion Public Methods

        #region Private Properties

        /// <summary>
        /// Inidirizzo IP
        /// </summary>
        private string ipAddress { get; set; } = "127.0.0.1";

        /// <summary>
        /// Porta del webservice (SOAP)
        /// </summary>
        private string tcpPort { get; set; } = "8001";

        #endregion Private Properties

        #region Private Methods

        /// <summary>
        /// Genera un obj batch dati i parametri necessari
        /// </summary>
        /// <param name="GrowerData"></param>
        /// <param name="VarietyId"></param>
        /// <param name="LayoutId"></param>
        /// <param name="SizingProfileName"></param>
        /// <returns>Oggetto Batch creato</returns>
        private Batch CreateBatch(GrowerInfo GrowerData, Guid VarietyId, Guid LayoutId, string SizingProfileName)
        {
            var batch = new Batch();

            batch.AvoidLayoutChange = true;
            batch.AvoidSavingOldLayouts = true;

            batch.GrowerCode = GrowerData.GrowerCode;
            batch.Comments = new string[GrowerData.Comments.Count];
            batch.Comments = GrowerData.Comments.ToArray();

            batch.VarietyId = VarietyId;
            batch.LayoutId = LayoutId;
            batch.SizingProfileName = SizingProfileName;

            return batch;
        }

        #endregion Private Methods
    }
}