mapo-iob-man/IOB-MAN.Core/IobAdapt.cs

using IOB_MAN.Core.Data;
using IOB_MAN.Core.DTO;
using StackExchange.Redis;
using System.ComponentModel;

namespace IOB_MAN.Core
{
    public class IobAdapt : IDisposable
    {
        #region Public Constructors

        /// <summary>
        /// Costruttore con init redis
        /// </summary>
        /// <param name="connMult">Multplexer REDIS</param>
        /// <param name="codIob">Cod IOB univoco</param>
        /// <param name="pId">ID processo</param>
        /// <param name="exeName">Nome EXE effettivo</param>
        /// <param name="tgtName">Nome app gestita (es IOB-WIN-NEXT)</param>
        public IobAdapt(IConnectionMultiplexer connMult, string codIob, int pId, string exeName, string tgtName)
        {
            // initi valori base...
            DateTime adesso = DateTime.Now;
            CodIOB = codIob;
            pID = pId;
            ExeName = exeName;
            TgtName = tgtName;
            startTime = adesso;
            isRunning = true;
            // initi redis
            redisMan = new RedisIobCache(connMult, "", codIob, tgtName, 60);
        }

        #endregion Public Constructors

        #region Public Properties

        /// <summary>
        /// Counter del CNC
        /// </summary>
        [DisplayName("pz.CNC")]
        public float cncCounter 
        {
            get
            {
                return (int)currIobStatus.counterMAC;
            }
        }

        /// <summary>
        /// Codice univoco macchina
        /// </summary>
        [DisplayName("IOB")]
        public string CodIOB { get; set; } = "";

        /// <summary>
        /// Nome dell'EXE avviato
        /// </summary>
        [DisplayName("Exe")]
        public string ExeName { get; set; } = "";

        /// <summary>
        /// Counter dell'IOB
        /// </summary>
        [DisplayName("pz.IOB")]
        public float iobCounter 
        {
            get
            {
                return (int)currIobStatus.counterIOB;
            }
        }

        /// <summary>
        /// Stato online dell'IOB (rispetto server MP-IO)
        /// </summary>
        [DisplayName("Online")]
        public bool iobOnline 
        {
            get
            {
                return currIobStatus.online && isRunning;
            }
        }

        /// <summary>
        /// Tipo macchina/CNC/PLC
        /// </summary>
        [DisplayName("Tipo")]
        public string IobType 
        {
            get
            {
                return currIobStatus.IobType;
            }
        }

        /// <summary>
        /// Verifica se il processo sia in RUN
        /// </summary>
        [DisplayName("Run")]
        public bool isRunning { get; set; } = false;

        /// <summary>
        /// Ultima data-ora di comunicazione valida con PLC
        /// </summary>
        [DisplayName("Last PLC read")]
        public DateTime lastPlcRead 
        {
            get
            {
                return currIobStatus.lastDataIn;
            }
        }

        /// <summary>
        /// Identificativo univoco processo
        /// </summary>
        [DisplayName("pid")]
        public int pID { get; set; } = 0;

        /// <summary>
        /// Determina se sia OK la comunicazione con il PLC, cioè non sia FERMO nella comunicazione per > 5 minuti
        /// </summary>
        [DisplayName("PlcOk")]
        public bool plcOk 
        {
            get
            {
                DateTime adesso = DateTime.Now;
                bool plcOnline = Math.Abs(adesso.Subtract(currIobStatus.lastDataIn).TotalSeconds) < 300;
                return plcOnline && isRunning;
            }
        }

        /// <summary>
        /// Lunghezza coda EVENTI
        /// </summary>
        [DisplayName("EV")]
        public int queueElLen
        {
            get
            {
                return currIobStatus.queueEvLen;
            }
        }

        /// <summary>
        /// Lunghezza coda FLog
        /// </summary>
        [DisplayName("FL")]
        public int queueFlLen
        {
            get
            {
                return currIobStatus.queueFlLen;
            }
        }

        /// <summary>
        /// FL / ora inviati
        /// </summary>
        [DisplayName("Data IN")]
        public string readBandwith
        {
            get
            {
                return currIobStatus.readBandwidth;
            }
        }

        /// <summary>
        /// FL / ora inviati
        /// </summary>
        [DisplayName("Fl/h")]
        public string sentFlHour
        {
            get
            {
                return $"{currIobStatus.sentFlHour:N1}";
            }
        }

        /// <summary>
        /// DataOra avvio dell'IOB
        /// </summary>
        [DisplayName("Started")]
        public DateTime startTime { get; set; } = DateTime.Now;

        /// <summary>
        /// Nome del target obj avviato
        /// </summary>
        [DisplayName("Prog")]
        public string TgtName { get; set; } = "";

        /// <summary>
        /// Calcola uptime processo...
        /// </summary>
        [DisplayName("Uptime")]
        public string uptime
        {
            get
            {
                // in primis cerco SE sia running --> aggiorno lastSeen
                if (isRunning)
                {
                    lastSeen = DateTime.Now;
                }
                TimeSpan uptime = lastSeen.Subtract(startTime);
                return Utils.FormatTimeSpan(uptime);
            }
        }

        #endregion Public Properties

        #region Public Methods

        public void Dispose()
        {
            isRunning = false;
            redisMan = null;
            GC.Collect();
        }

        #endregion Public Methods

        #region Protected Fields

        protected int maxVeto = 3000;

        protected int minVeto = 1000;

        protected Random rnd = new Random();

        /// <summary>
        /// Scadenza status IOB
        /// </summary>
        protected DateTime scadIobStatus = DateTime.Now;

        #endregion Protected Fields

        #region Protected Properties

        /// <summary>
        /// Status iob corrente da RAM (se entro 1 sec) o da redis (se scaduto)
        /// </summary>
        protected IobWinStatusDTO currIobStatus
        {
            get
            {
                if (isRunning && redisMan != null)
                {
                    lastIobStatus = redisMan.CurrIobStatus;
                }
                return lastIobStatus;
            }
        }

        /// <summary>
        /// Ultimo status IOB letto
        /// </summary>
        protected IobWinStatusDTO lastIobStatus { get; set; } = new IobWinStatusDTO();

        protected DateTime lastSeen { get; set; } = DateTime.Now;

        #endregion Protected Properties

        #region Private Fields

        /// <summary>
        /// Gestore processi redis
        /// </summary>
        private RedisIobCache? redisMan;

        #endregion Private Fields
    }
}