ConnectedController.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;

using System.Timers;
using Newtonsoft.Json;
using sage.ew.db;
using sage.ew.global;

namespace sage.ew.ewbase
{
    public class ConnectedController: IDisposable
    {
        #region PROPIEADES PRIVADAS

        private int _nIntervalo = 5; // minutos      
        private DateTime? _dUltEjecucion = null;
        private string _cMensajeError = string.Empty;
        ConnectedControllerMaster _oMaster = new ConnectedControllerMaster();
        Timer _aTimer;
        private BackgroundWorker _oBackgroundWorker;
        private string _cTerminal = Convert.ToString(EW_GLOBAL._GetVariable("wc_terminal")).Trim();

        #endregion

        #region PROPIEDADES PUBLICAS

        public int _Intervalo
        {
            get => _nIntervalo;
            set => _nIntervalo = value;
        }

        public bool _Master
        {
            get => ValidacionMaster();                            
        }

        public DateTime? _UltEjecucion
        {
            get => _dUltEjecucion;
        }

        public string _MensajeError
        {
            get => _cMensajeError;
        }

        #endregion

        #region CONSTRUCTOR

        public ConnectedController()
        {          
            if (_oBackgroundWorker != null && _oBackgroundWorker.IsBusy)
                return;

            // Declaro un nuevo elemento
            _oBackgroundWorker = new BackgroundWorker
            {
                WorkerSupportsCancellation = false,
                WorkerReportsProgress = false
            };

            // Declaro los procesos
            _oBackgroundWorker.DoWork += _oBackgroundWorker_DoWork;
           
            // Ejecución asíncrona
            _oBackgroundWorker.RunWorkerAsync();
        }

        #endregion

        #region METODOS PUBLICOS

        public delegate void _ConnectedEvent_Handler(ref bool tlOk);

        public event _ConnectedEvent_Handler _ConnectedEvent;

        public void _Delete()
        {
            if (_Master)
            {
                try
                {
                    DB.SQLBegin();
                    EW_GLOBAL._DeleteDbVariable("Master");
                    DB.SQLCommit();
                }
                catch (Exception loEx)
                {
                    DB.SQLRollback();
                    _cMensajeError = loEx.Message;
                }
            }
        }

        #endregion

        #region METODOS PRIVADOS

        private bool ValidacionMaster()
        {
            _cMensajeError = string.Empty;
            string lcMaster = string.Empty;

            bool llOk = EW_GLOBAL._GetDbVariableString("Master", ref lcMaster);
            bool llActualizaMaster = (!llOk || string.IsNullOrWhiteSpace(lcMaster));  //No existe, soy yo el Master

            if (!llActualizaMaster)
            {
                try
                {
                    _oMaster = JsonConvert.DeserializeObject<ConnectedControllerMaster>(lcMaster);
                }
                catch (Exception loEx)
                {
                    _cMensajeError = loEx.Message;
                }

                if (_oMaster != null)
                {
                    ConfigurarTimer(); //actualizamos timer con el valor de la propiedad _Frecuencia 
                    llActualizaMaster = (_oMaster._Terminal == _cTerminal);
                    if (!llActualizaMaster) //comparo el terminal por si me han quitado el master
                    {
                        TimeSpan loTimeSpan = DateTime.Now - _oMaster._Fecha;   //validamos fecha 
                        llActualizaMaster = (loTimeSpan.TotalMinutes > (2 * _Intervalo));   //Caducado, soy yo el Master                        
                    }
                }
            }

            if (llActualizaMaster)            
                return ActualizarMaster();            
            else
                return false;
        }

        private bool ActualizarMaster()
        {            
            _oMaster._Get(); //nos devuelve la instancia con los datos actualizados            
        
            try
            { 
                DB.SQLBegin();
                EW_GLOBAL._SaveDbVariable("Master", JsonConvert.SerializeObject(_oMaster));
                DB.SQLCommit();
            }
            catch (Exception loEx)
            {
                DB.SQLRollback();
                _cMensajeError = loEx.Message;
            }

            return true;
        }

        private bool ActivarInvoke()
        {           
            return _Master && _oMaster?._Frecuencia != 0; //Al comprobar si es _Master hace el load del objeto _oMaster y así tenemos el valor de la tabla variable si se ha modificado
        }

        private void ConfigurarTimer()
        {
            if (_oMaster == null)
                return;

            if(_oMaster._Terminal == _cTerminal && _oMaster._Frecuencia != 0 &&  _oMaster._Frecuencia != _Intervalo )
            {                
                int lnInterval = 1000 * 60 * _oMaster._Frecuencia;
                _aTimer.Stop();
                _aTimer.Interval = lnInterval;
                _aTimer.Start();             
            }            
        }

        private void _oBackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            SetTimer();
        }

        private void SetTimer()
        {
            _aTimer = new Timer(1000 * 60 * _Intervalo);                                  
            _aTimer.Elapsed += _aTimer_Elapsed;
            _aTimer.Enabled = true;
        }

        private void _aTimer_Elapsed(object sender, ElapsedEventArgs e)
        {           
            if(ActivarInvoke())
            {
                try
                {
                    bool llOk = false;
                    _ConnectedEvent?.Invoke(ref llOk);                    
                }
                catch (Exception loEx)
                {
                    _cMensajeError = "Se ha producido un error en la invocación de los eventos suscritos a ConnectedController: " + loEx.Message;                    
                    DB.Escribir_En_Log_Error(DB.Modo_Registro.Registro_Error, loEx, _cMensajeError);
                }
            }            
        }

        private void CloseTimer()
        {
            if(_aTimer!=null)
                _aTimer.Enabled = false;
        }

        #endregion

        #region DISPOSE

        public void Dispose()
        {
            _oMaster = null;
            CloseTimer();
            _aTimer = null;
        }

        #endregion Dispose
    }
}