NuevaActualizacion.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Windows.Forms;
using System.IO;
using sage.ew.interficies;
using sage.ew.objetos.Widgets;
using sage.ew.functions;
using sage.ew.db;
using sage.ew.images.Clases;
using sage.ew.formul;
using System.Windows.Threading;
using sage.ew.usuario;
using sage.ew.global;
using System.Diagnostics;
using System.Web.Script.Serialization;
using sage.ew.ewbase;
using sage.ew.functions.Clases;
using Sage.ES.Onboarding.Clases;
using sage._50;
using System.Threading;

namespace sage.ew.objetos
{
    public partial class NuevaActualizacion : UserControlIWidgetTitulo, IDisposable, IElemento, IElementoContorno
    {
        #region Implementación de las propiedades de las interficies
        [
        Category("General"),
        DisplayName("Editando"),
        DefaultValue(false),
        DescriptionAttribute("Indica si el control está en modo de edición"),
        Browsable(false)
        ]
        public new bool _Editando
        {
            get { return _lEditando; }
            set
            {
                _lEditando = value;

                if (_lEditando && !Visible) // En modo de edición lo tenemos de hacer visible
                    Visible = true;
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [Browsable(false)]
        public new ControladorDesktop _ControladorDesktop
        {
            get { return _oControladorDesktop; }
            set { _oControladorDesktop = value; }
        }
        ControladorDesktop _oControladorDesktop = null;

        #endregion Implementación de las propiedades de las interficies

        #region Propiedades privadas
        private bool _lEditando = false;

        private bool _lVisible = false;

        private string _cRuta_Prgs_err = string.Empty;
        private string _cRuta_Temp_Prgs_err = string.Empty;
        private bool _llRenameOk = true;
        private bool _llCloseApplication = false;

        private bool _lActualizando = false;
        private bool _lUpdateVariables = false;

        private StateActualizacion _oStateActualizacion = StateActualizacion.SinEstado;

        private string _cMensaje_Error = string.Empty;
        private const string _cFileUpdateSage50 = "ActualizarSage50.exe";
        private string _cPathIniTerminal = string.Empty;
        private string _cPathIniServidor = string.Empty;
        private string _cText = "Nueva actualización de " + Convert.ToString(EW_GLOBAL._GetVariable("wc_nameproducto"));

        private string _cVersionSage50Webservice = string.Empty;

        private string _cFechaPublicaSage50Webservice = string.Empty;

        private string _cKeyCopy = string.Empty;

        private BusinessNuevaActualizacion _oBusinessNuevaActualizacion = null;

        private BackgroundWorker _oBackgroundWorker;

        private bool _lBackgroudWorkerIsRunning = false;

        private ewToolTip _oToolTip = null;

        private string _cToolTip = string.Empty;

        private string _cVersionTerminalDllSage50
        {
            get
            {
                if (string.IsNullOrWhiteSpace(_cVersionTerminalDll))
                    _cVersionTerminalDll = VersionNumber._Sage50Version;

                return _cVersionTerminalDll;
            }
        }
        private string _cVersionTerminalDll = string.Empty;

        private string _cVersionServidorDllSage50
        {
            get
            {
                if (string.IsNullOrWhiteSpace(_cVersionDllServidor))
                    _cVersionDllServidor = VersionNumber._Sage50VersionServidor();

                return _cVersionDllServidor;
            }
        }
        private string _cVersionDllServidor = string.Empty;

        private string _cNameProducto = Convert.ToString(EW_GLOBAL._GetVariable("wc_nameproducto"));

        private Dictionary<string, object> _dictVersionActualizacion = new Dictionary<string, object>();
        #endregion Propiedades privadas

        #region Propiedades públicas
        //
        public InfoNuevaActualizacion _InfoNuevaActualizacion
        {
            get
            {
                if (_oInfoNuevaActualizacion == null)
                    _oInfoNuevaActualizacion = new InfoNuevaActualizacion();

                return _oInfoNuevaActualizacion;
            }
        }

        private InfoNuevaActualizacion _oInfoNuevaActualizacion = null;
        #endregion Propiedades públicas

        #region Delegados y eventos
        public delegate void _Refresh_Actualizacion_Handler(bool tlVisible);

        public event _Refresh_Actualizacion_Handler _Refresh_Actualizacion;
        #endregion Delegados y eventos

        #region Enumeración StateActualizacion
        private enum StateActualizacion
        {
            SinEstado = 0,
            Consultar = 1,
            Actualizar = 2,
            PendienteCerrar = 3 // Pendiente de cerrar la aplicación
        }
        #endregion Enumeración StateActualizacion

        #region Enumeración ServidorTerminal
        public enum eServidorTerminalLib
        {
            Indefinido = 0,
            Servidor = 1,
            Terminal = 2
        }
        #endregion Enumeración StateActualizacion

        #region Constructor
        public NuevaActualizacion()
        {
            InitializeComponent();

            if (!DesignMode)
            {
                _oBusinessNuevaActualizacion = new BusinessNuevaActualizacion();

                _cPathIniTerminal = Convert.ToString(EW_GLOBAL._GetVariable("wc_pathinicio")).Trim();
                _cPathIniServidor = Convert.ToString(EW_GLOBAL._GetVariable("wc_iniservidor")).Trim();
                _cKeyCopy = Convert.ToString(EW_GLOBAL._GetVariable("wc_keycopy"));

                SubscripcionEventos();
            }
        }
        #endregion Constructor

        #region Implementación de los métodos de las interficies
        public bool _Deleting()
        {
            return true;
        }

        public bool _Filtrar(bool tlBefore = false)
        {
            return true;
        }

        public bool _OnRefresh()
        {
            _cVersionDllServidor = string.Empty; // Puede que tengamos en el servidor una versión nueva de dlls, en tal caso debe de avisar

            _GetData_Async();

            return true;
        }

        public bool _OnShow()
        {
            return _OnRefresh();
        }

        public Dictionary<string, string> _Saving()
        {
            Dictionary<string, string> ldReturn = new Dictionary<string, string>();
            return ldReturn;
        }

        public bool _Loading(Dictionary<string, string> tdictPersonalizado)
        {
            return true;
        }
        #endregion Implementación de los métodos de las interficies

        #region Métodos públicos

        public void _ActualizaSage50()
        {
            _Actualiza();
        }

        public bool _ExisteActualización()
        {
            _InfoNuevaActualizacion._ServidorTerminal = eServidorTerminalLib.Indefinido;

            // Mirar si hay una actualización disponible
            bool llUpdate = UpdateAvailable();
            if (!llUpdate)
                return false;

            // Cargar la información de la actualización, versiones y fechas
            _InfoNuevaActualizacion._VersionServidor = _cVersionServidorDllSage50;
            _InfoNuevaActualizacion._FechaServidor = VersionNumber._ObtenerFechaVersion(Convert.ToString(EW_GLOBAL._GetVariable("wc_IniServidor")).Trim());
            _InfoNuevaActualizacion._VersionTerminal = _cVersionTerminalDllSage50;
            _InfoNuevaActualizacion._FechaTerminal = VersionNumber._ObtenerFechaVersion(Convert.ToString(EW_GLOBAL._GetVariable("wc_pathinicio")).Trim());
            _InfoNuevaActualizacion._VersionActua = _cVersionSage50Webservice;
            _InfoNuevaActualizacion._FechaActua = _cFechaPublicaSage50Webservice;

            return true;
        }

        #endregion Métodos públicos

        #region Métodos protected
        protected internal void _Actualiza()
        {
            if (!Visible)
            {
                MessageBox.Show($"No es necesario realizar ninguna actualización.{Environment.NewLine}En estos momentos dispone de la última versión de {_cNameProducto}.", _cText, MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
                return;
            }

            NuevaActualizacion_Click(ewImagenInformacion, new EventArgs());
        }
        #endregion Métodos protected

        #region Métodos privados
        private string PathS50(bool tlServidor)
        {
            if (tlServidor)
                return Convert.ToString(EW_GLOBAL._GetVariable("wc_iniservidor"));
            else
                return _cPathIniTerminal;
        }

        private void SubscripcionEventos(bool tlUnSubscribe = false)
        {
            if (tlUnSubscribe)
            {
                ewImagenInformacion.Click -= NuevaActualizacion_Click;

                ewImagenInformacion.MouseEnter -= Imagen_MouseHover;
                ewImagenInformacion.MouseHover -= Imagen_MouseHover;
                ewImagenInformacion.MouseLeave -= Imagen_MouseLeave;

            }
            else
            {
                ewImagenInformacion.Click += NuevaActualizacion_Click;

                ewImagenInformacion.MouseEnter += Imagen_MouseHover;
                ewImagenInformacion.MouseHover += Imagen_MouseHover;
                ewImagenInformacion.MouseLeave += Imagen_MouseLeave;
            }
        }

        private void Imagen_MouseHover(object sender, EventArgs e)
        {
            if (Cursor != Cursors.Hand)
                Cursor = Cursors.Hand;
        }

        private void Imagen_MouseLeave(object sender, EventArgs e)
        {
            if (Cursor != Cursors.Default)
                Cursor = Cursors.Default;
        }

        private bool InternetConnection_Deprecated(bool tlMessage = false)
        {
            if (!System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable())
            {
                if (tlMessage)
                    MessageBox.Show($"Para poder ejecutar el proceso de actualización de {_cNameProducto} es necesario tener una conexión a internet.", _cText, MessageBoxButtons.OK, MessageBoxIcon.Stop);

                return false;
            }

            return true;
        }

        private void NuevaActualizacion_Click(object sender, EventArgs e)
        {
            bool llActualizar = false;

            if (!ValidateFilePath(_cPathIniTerminal, _cFileUpdateSage50)) // Validamos que tenemos el ejecutable
                return;

            if (_lBackgroudWorkerIsRunning && _oStateActualizacion == StateActualizacion.Actualizar)
            {
                DescripcionTooltTip();
                MessageBox.Show($"En estos momentos ya se está ejecutando la actualización de {_cNameProducto}.", _cText, MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            if ((_oStateActualizacion != StateActualizacion.SinEstado && _lBackgroudWorkerIsRunning) || _oStateActualizacion == StateActualizacion.PendienteCerrar)
                return;

            if (!PrevalidatePrgs_Err())
                return;

            _cVersionDllServidor = string.Empty; // Puede que haya acabado lo actualización y tengamos una nueva versión en el servidor
            _dictVersionActualizacion = LoadVersionVariable(); // Consultamos la información de la tabla variables

            DescripcionTooltTip(); // Revisamos el ToolTip

            if (NowUpdating(tlMessage: true)) // Prevalidamos si se está actualizando en otro terminal
                return;

            if (!PrevalidateListasPrevias())
                return;

            string lcPregunta = TextoActualizacion(ref llActualizar, true);

            if (llActualizar && !PuedoActualizar()) // Permitir actualizar desde dentro de la aplicación
            {
                MessageBox.Show($"Para poder actualizar {_cNameProducto} debe tener activado el acceso especial 'Permitir actualizar desde dentro de la aplicación'.", _cText, MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            if (MessageBox.Show(lcPregunta, _cText, MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2) == DialogResult.No)
                return;

            if (VersionDLLs()) // Si tenemos una versión diferente en el servidor cerramos la aplicación
            {
                CloseAplication();
                return;
            }

            _oStateActualizacion = StateActualizacion.Actualizar;

            // Nos desubscribimos para que no pueda pulsar dos veces
            ewImagenInformacion.Click -= NuevaActualizacion_Click;

            UpdateVersion();

            ewImagenInformacion.Click += NuevaActualizacion_Click;
        }

        private bool PuedoActualizar()
        {
            return ((Convert.ToString(EW_GLOBAL._GetVariable("wc_usuario")).Trim() == "SUPERVISOR") || Usuario._This._Opcesp("5005")); // Permitir actualizar desde dentro de la aplicación
        }

        private bool PrevalidatePrgs_Err()
        {
            _llRenameOk = true;

            _cRuta_Prgs_err = FUNCTIONS._AddBS(Path.Combine(_cPathIniServidor, "PRGS_ERR"));
            _cRuta_Temp_Prgs_err = FUNCTIONS._AddBS(Path.Combine(_cRuta_Prgs_err, "TEMP_ACTUALIZACIONSAGE50"));

            if (Directory.Exists(_cRuta_Prgs_err))
            {
                if (!CreateDirectoryTemp())
                {
                    MessageBox.Show("Para poder ejecutar el proceso de actualización es necesario tener permisos en la carpeta de PRGS_ERR del servidor.", _cText, MessageBoxButtons.OK, MessageBoxIcon.Stop);
                    return false;
                }

                string[] lcFiles = Directory.GetFiles(_cRuta_Prgs_err);

                lcFiles.AsEnumerable().ToList().ForEach(f => RenameFile(f));

                RemoveDirectoryTemp();
            }

            if (!_llRenameOk)
            {
                string lcError = $"Existen ficheros en uso en la carpeta {_cRuta_Prgs_err} del servidor que impiden ejecutar el proceso de actualización de {_cNameProducto}." + Environment.NewLine + Environment.NewLine +
                                 $"Ejecute el proceso '{_cFileUpdateSage50}' para realizar la actualización.";

                if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_prueva")) && !string.IsNullOrWhiteSpace(_cMensaje_Error))
                    lcError += Environment.NewLine + Environment.NewLine + _cMensaje_Error;

                 MessageBox.Show(lcError, _cText, MessageBoxButtons.OK, MessageBoxIcon.Stop);
            }

            return _llRenameOk;
        }

        private bool CreateDirectoryTemp()
        {
            bool llOk = true;

            try
            {
                llOk = Directory.Exists(_cRuta_Temp_Prgs_err);

                if (!llOk)
                {
                    Directory.CreateDirectory(_cRuta_Temp_Prgs_err);
                    llOk = Directory.Exists(_cRuta_Temp_Prgs_err);
                }
            }
            catch (Exception loEx)
            {
                _cMensaje_Error = "No se ha podido crear el directorio temporal para la copia de ficheros." + Environment.NewLine + loEx.Message;
            }

            return llOk;
        }

        private bool RemoveDirectoryTemp()
        {
            bool llOk = true;

            try
            {
                if (Directory.Exists(_cRuta_Temp_Prgs_err))
                {
                    Directory.Delete(_cRuta_Temp_Prgs_err);
                    llOk = !Directory.Exists(_cRuta_Temp_Prgs_err);
                }
            }
            catch (Exception loEx)
            {
                _cMensaje_Error = "No se ha podido eliminar el directorio temporal para la copia de ficheros." + Environment.NewLine + loEx.Message;
            }

            return llOk;
        }

        private void RenameFile(string tcFile)
        {
            if (!_llRenameOk)
                return;

            string lcFileName, lcNewFileName;

            lcFileName = Path.Combine(_cRuta_Prgs_err, tcFile);
            lcNewFileName = Path.Combine(_cRuta_Temp_Prgs_err, tcFile);

            try
            {
                File.Move(lcFileName, lcNewFileName);
            }
            catch (Exception loEx)
            {
                _llRenameOk = false;
                _cMensaje_Error = "No se ha podido renombrar el fichero " + Path.GetFileName(tcFile) + "." + Environment.NewLine + Environment.NewLine + loEx.Message;
            }

            if (_llRenameOk)
            {
                try
                {
                    // Restauramos el fichero
                    File.Move(lcNewFileName, lcFileName);
                }
                catch (Exception loEx)
                {
                    _cMensaje_Error = "No se ha podido restaurar el fichero " + Path.GetFileName(tcFile) + "." + Environment.NewLine + Environment.NewLine + loEx.Message;
                }
            }
        }

        private bool PreValidate()
        {
            if (_Editando)
            {
                MessageBox.Show("Para actualizar la aplicación es necesario guardar primero el diseño actual.", _cText, MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
                return false;
            }

            if (_lActualizando && ExistProcessActualizarSage50()) // Determina que se ha abierto la aplicación
            {
                MessageBox.Show("Se está ejecutando el proceso de actualización.", _cText, MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
                return false;
            }

            if (!PrevalidateListasPrevias())
                return false;

            return true;
        }

        private bool PrevalidateListasPrevias()
        {
            bool llOk = true;

            // TODO: Falta gestionar las listas previas de los diferentes terminales
            int openformsATenerEnCuenta = EW_GLOBAL._OpenForms.Count;
            for (int nInd = 0; nInd < EW_GLOBAL._OpenForms.Count ; nInd++)
            {
                if (EW_GLOBAL._OpenForms.ElementAt(nInd).GetType().Name == "frmAcercaDe" || EW_GLOBAL._OpenForms.ElementAt(nInd).GetType().Name == "frmPrincipal")
                {
                    openformsATenerEnCuenta --;
                }
            }

            if (openformsATenerEnCuenta > 1)
            {
                var loFormsListas = EW_GLOBAL._OpenForms.Where(f => f.Name.ToLower().Trim() == "frmlistasprevias" || f.Name.ToLower().Trim() == "formtabs");

                llOk = (loFormsListas != null && loFormsListas.Count() > 0);

                if (!llOk)
                    FUNCTIONS._MessageBox("El proceso de actualización no ha podido finalizar porque se ha detectado alguna de las listas previas que están en uso necesita ser actualizada." + Environment.NewLine+ Environment.NewLine +
                                          "Cierra todas las listas previas que tengas abiertas en cualquiera de los ordenadores donde se esté utilizando " + _cNameProducto + " y vuelve a lanzar el proceso de actualización.", _cText, MessageBoxButtons.OK, MessageBoxIcon.Stop);
            }

            if (llOk) // Buscaremos el widget de listas previas ...
            {
                ControladorDesktop loControlador = (ControladorDesktop)EW_GLOBAL._GetVariable("wo_ControladorDesktop");
                if (loControlador != null)
                {
                    List<Control> lstMenus = loControlador._GetWidgets().AsEnumerable().Where(c => c.GetType() == typeof(WidgetFormTabs)).ToList();

                    if (lstMenus.Count > 0 && (lstMenus[0] as WidgetFormTabs)._Listas > 0)
                    {
                        llOk = false;
                        FUNCTIONS._MessageBox("El proceso de actualización no ha podido finalizar porque se ha detectado el widget de listas previas incrustado en un escritorio en uso."+ Environment.NewLine + Environment.NewLine +
                                              "Cierra todas las listas previas que tengas abiertas en el diseño del escritorio en cualquiera de los ordenadores donde se esté utilizando " + _cNameProducto + "  o cambia a un escritorio donde no exista el widget de listas previas incrustado y vuelve a lanzar el proceso de actualización.", _cText, MessageBoxButtons.OK, MessageBoxIcon.Stop); // Bug 197016
                    }
                }
            }

            return llOk;
        }

        private bool ValidatePath(string tcPath)
        {
            if (string.IsNullOrWhiteSpace(tcPath) || !Directory.Exists(tcPath))
            {
                MessageBox.Show("No se ha definido la ruta del terminal.", _cText, MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
                return false;
            }

            return true;
        }

        private bool ValidateFilePath(string tcPath, string tcFile)
        {
            if (!ValidatePath(tcPath))
                return false;

            string lcFilePath = Path.Combine(tcPath, tcFile);

            if (!File.Exists(lcFilePath))
            {
                MessageBox.Show($"No se ha encontrado el ejecutable ActualizarSage50.exe en el terminal necesario para la actualización de {_cNameProducto}.", _cText, MessageBoxButtons.OK, MessageBoxIcon.Stop, MessageBoxDefaultButton.Button1);
                return false;
            }

            return true;
        }

        private bool UpdateAvailable()
        {
            bool llCont = false;

            if (!FUNCTIONS.InternetOk())
                return false;

            // Consultamos inicialmente la versión de la tabla variables para no realizar la petició si ya se ha consultado hoy
            _dictVersionActualizacion = LoadVersionVariable();

            if (ValidDate()) // Si tenemos un registro del día no es necesario realizar la peticion nuevamente al WebService
            {
                _cVersionSage50Webservice = _dictVersionActualizacion.ContainsKey("_Version") ? Convert.ToString(_dictVersionActualizacion["_Version"]) : "";
                _cFechaPublicaSage50Webservice = _dictVersionActualizacion.ContainsKey("_Publicacion") ? Convert.ToString(_dictVersionActualizacion["_Publicacion"]) : "";

                llCont = IsSuperiorVersionWebServiceServidor() || IsSuperiorVersionWebServiceTerminal();
            }
            else
            {
                // Ahora realizamos una petición web para ver si existe una actualización pendiente
                _VersionActualizarSage50WebService();

                llCont = !string.IsNullOrWhiteSpace(_cVersionSage50Webservice);

                if (llCont)
                {
                    llCont = UpdateVariables(false); // Tenemos de actualizar la versión para que no realice más peticiones

                    if (!IsSuperiorVersionWebServiceServidor())
                        llCont = false; // Devuelve una versión anterior a la que tenemos actualmente
                }
            }

            return llCont;
        }

        private bool IsSuperiorVersionWebServiceServidor()
        {
            bool llOk = (!string.IsNullOrWhiteSpace(_cVersionSage50Webservice) && _cVersionSage50Webservice != _cVersionServidorDllSage50);

            try
            {
                llOk = (ConvertToDecimal(_cVersionSage50Webservice) > ConvertToDecimal(_cVersionServidorDllSage50));
            }
            catch (Exception loEx)
            {
                _cMensaje_Error = "No se ha podido comparar la versión del servidor" + Environment.NewLine + loEx.Message;
            }

            _InfoNuevaActualizacion._ServidorTerminal = llOk ? eServidorTerminalLib.Servidor : _InfoNuevaActualizacion._ServidorTerminal;

            return llOk;
        }

        private bool IsSuperiorVersionServidorTerminal()
        {
            bool llOk = false;

            if (_cVersionTerminalDllSage50 != _cVersionServidorDllSage50)
            {
                try
                {
                    llOk = (ConvertToDecimal(_cVersionServidorDllSage50) > ConvertToDecimal(_cVersionTerminalDllSage50));
                }
                catch (Exception)
                {
                }
            }

            return llOk;
        }

        private bool IsSuperiorVersionWebServiceTerminal()
        {
            if (IsSuperiorVersionWebServiceServidor())
                return true;

            bool llOk = true;

            try
            {
                // Validamos primero que la versión del servidor difiera con la versión del webservice
                llOk = (!string.IsNullOrWhiteSpace(_cVersionSage50Webservice) && _cVersionSage50Webservice != _cVersionServidorDllSage50);

                // La versión del webservice puede ser anterior a la versión actual, al menos en entorno de QA
                llOk = llOk && (ConvertToDecimal(_cVersionSage50Webservice) >= ConvertToDecimal(_cVersionServidorDllSage50));

                // Adicionalmente la versión del servidor debe de ser superior a la del terminal para poder presentar la imagen
                // Se puede dar el caso que tengamos las dlls en el servidor pero no en el terminal
                llOk = llOk && (ConvertToDecimal(_cVersionServidorDllSage50) > ConvertToDecimal(_cVersionTerminalDllSage50));
            }
            catch (Exception loEx)
            {
                _cMensaje_Error = "No se ha podido comparar la versión del servidor" + Environment.NewLine + loEx.Message;
            }

            try
            {
                // Se puede dar el caso que tengamos las dlls en el servidor pero no en el terminal
                llOk = llOk || (ConvertToDecimal(_cVersionSage50Webservice) > ConvertToDecimal(_cVersionTerminalDllSage50));
            }
            catch (Exception loEx)
            {
                _cMensaje_Error = "No se ha podido comparar la versión del terminal" + Environment.NewLine + loEx.Message;
            }

            _InfoNuevaActualizacion._ServidorTerminal = llOk ? eServidorTerminalLib.Terminal : _InfoNuevaActualizacion._ServidorTerminal;

            return llOk;
        }

        private decimal ConvertToDecimal(string tcVersion)
        {
            decimal lnVersion = 0;

            try
            {
                lnVersion = Convert.ToDecimal(tcVersion.Replace(".", "").Replace(",", ""));
            }
            catch (Exception loEx)
            {
                _cMensaje_Error = "Se ha producido un error al convertir la versión" + Environment.NewLine + loEx.Message;
            }

            return lnVersion;
        }

        private string VersionVariables()
        {
            string lcVersion = "0";

            if (_dictVersionActualizacion.ContainsKey("_Version"))
                lcVersion = Convert.ToString(_dictVersionActualizacion["_Version"]);

            return lcVersion;
        }

        private bool VersionDLLs()
        {
            if (_oStateActualizacion == StateActualizacion.PendienteCerrar)
                return true;

            return IsSuperiorVersionServidorTerminal();
        }

        private bool ValidDate()
        {
            bool llOk = false;

            if (_dictVersionActualizacion.Count > 0 && _dictVersionActualizacion.ContainsKey("_Fecha"))
            {
                try
                {
                    //llOk = ((Convert.ToDateTime(_dictVersionActualizacion["_Fecha"]).Date) == DateTime.Now.Date);
                    //Task 182137 - Coger DateTime.UtcNow porque al deserializar coge la hora Utc
                    llOk = ((Convert.ToDateTime(_dictVersionActualizacion["_Fecha"])) > DateTime.UtcNow); 
                }
                catch (Exception loEx)
                {
                    _cMensaje_Error = "Fecha no válida." + Environment.NewLine + loEx.Message;
                }
            }

            return llOk;
        }

        private bool NowUpdating(bool tlUpdate = false, bool tlMessage = false, bool tlAferUpdate = false)
        {
            if (!FUNCTIONS.InternetOk())
                return false;

            bool llUpdating = false;

            if (_dictVersionActualizacion.Count > 0 && _dictVersionActualizacion.ContainsKey("_Actualizando"))
            {
                llUpdating = Convert.ToBoolean(_dictVersionActualizacion["_Actualizando"]);

                if (llUpdating && _dictVersionActualizacion.ContainsKey("_Fecha"))
                {
                    DateTime ldFecha = Convert.ToDateTime(_dictVersionActualizacion["_Fecha"]).Date;
                    llUpdating = (ldFecha > DateTime.Now.Date && !tlAferUpdate); // Si no es la fecha del día en devolveremos que no se está actualizando

                    // Podriamos gestionar el KeyCopy para saber si somos nosotros o otro terminal
                    // Despues de la actualziación ha de quedar a false si o si _Actualizando
                    if ((tlUpdate && !llUpdating) || tlAferUpdate)
                        UpdateVariables(false);
                }
            }

            if (llUpdating && tlMessage)
            {
                DescripcionTooltTip();
                MessageBox.Show($"En estos momentos se está actualizando la versión de {_cNameProducto}.", _cText, MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
            }

            return llUpdating;
        }

        private void DescripcionTooltTip()
        {
            if (_oToolTip == null)
                _oToolTip = new ewToolTip();

            bool llActualizar = false;
            string lcTexto = TextoActualizacion(tlActualizar: ref llActualizar);
            _oToolTip.SetToolTip(ewImagenInformacion, lcTexto);
        }

        private string TextoActualizacion(ref bool tlActualizar, bool tlQuestion = false)
        {
            string lcTexto = "";

            if (NowUpdating())
                lcTexto = $"En estos momentos se está ejecutando la actualización de {_cNameProducto}.";
            else
            {
                if (VersionDLLs())
                {
                    lcTexto = $"Existe la nueva versión {_cVersionServidorDllSage50} disponible en el servidor para actualizar {_cNameProducto}";

                    if (tlQuestion)
                        lcTexto += "." + Environment.NewLine + Environment.NewLine + "¿Desea cerrar la aplicación para actualizar a la nueva versión?";
                }
                else
                {
                    tlActualizar = true;
                    lcTexto = $"Existe una nueva versión disponible para descargar y actualizar {_cNameProducto}";

                    if (tlQuestion)
                        lcTexto += "." + Environment.NewLine + Environment.NewLine + "¿Desea actualizar a la nueva versión?";
                }
            }

            return lcTexto;
        }

        private string _VersionActualizarSage50WebService()
        {
            if (!FUNCTIONS.InternetOk())
                return "";

            _cVersionSage50Webservice = string.Empty;
            _cFechaPublicaSage50Webservice = string.Empty;

            Dictionary<string, object> loDic = new Dictionary<string, object>();
            loDic = FUNCTIONS._VersionActualizarSage50WebServiceInfo();

            if (loDic!= null)
            {
                if (loDic.ContainsKey("Version"))
                    _cVersionSage50Webservice = Convert.ToString(loDic["Version"]);
                if (loDic.ContainsKey("Publicacion"))
                    _cFechaPublicaSage50Webservice = Convert.ToString(loDic["Publicacion"]);

                // Pasar a formato XX/XX/XXXX
                _cFechaPublicaSage50Webservice = FormatFecha(_cFechaPublicaSage50Webservice);
            }

            return _cVersionSage50Webservice;
        }


        private Dictionary<string, object> LoadVersionVariable()
        {
            bool llOk = false;
            DataTable ldtVariable = new DataTable();
            Dictionary<string, object> loDictVersion = new Dictionary<string, object>();

            llOk = _oBusinessNuevaActualizacion._DatatableVersionVariable(ref ldtVariable);

            _lUpdateVariables = (ldtVariable != null && ldtVariable.Rows.Count > 0);

            if (llOk)
                loDictVersion = DeserializaInformationDataTable(ldtVariable);

            FUNCTIONS._DisposeDatatable(ldtVariable);

            return loDictVersion;
        }

        private Dictionary<string, object> DeserializaInformationDataTable(DataTable tdtVariable)
        {
            Dictionary<string, object> loDictInformacion = new Dictionary<string, object>();

            if (tdtVariable != null && tdtVariable.Rows.Count > 0)
            {
                string lcValor = Convert.ToString(tdtVariable.Rows[0]["valor"]).Trim();

                if (!string.IsNullOrWhiteSpace(lcValor))
                {
                    try
                    {
                        loDictInformacion = new JavaScriptSerializer().Deserialize<Dictionary<string, object>>(lcValor);
                    }
                    catch (Exception loEx)
                    {
                        _cMensaje_Error = "No se ha podido deserializar la información de la versión de la tabla variables." + Environment.NewLine + loEx.Message;
                    }
                }
            }

            return loDictInformacion;
        }

        private void RefreshDictValues(bool tlActualizando)
        {
            _dictVersionActualizacion["_Fecha"] = GetNewDate();
            _dictVersionActualizacion["_Version"] = _cVersionSage50Webservice;
            _dictVersionActualizacion["_Publicacion"] = _cFechaPublicaSage50Webservice;
            _dictVersionActualizacion["_Actualizando"] = tlActualizando;
            _dictVersionActualizacion["_Keycopy"] = (tlActualizando ? _cKeyCopy : ""); // Marcamos el usuario que está actualizando
        }

        private DateTime GetNewDate()
        {
            //Cogemos la fecha actual
            DateTime ldNewDate = DateTime.Now;

            // Añadimos los días a partir de un número aleatorio entre 1 y 7
            ldNewDate = ldNewDate.AddDays(GetRandom(1, 7));

            // Añadimos los minutos a partir de un número aleatorio entre 1 y 47
            ldNewDate = ldNewDate.AddMinutes(GetRandom(1, 47));

            // Si la hora es superior a las 20.00h, pondremos 08:00h 
            DateTime ldDateLimit = new DateTime(ldNewDate.Year, ldNewDate.Month, ldNewDate.Day, 20, 0, 0);
            if (DateTime.Compare(ldNewDate, ldDateLimit) > 0)
                ldNewDate = new DateTime(ldNewDate.Year, ldNewDate.Month, ldNewDate.Day, 8, 0, 0);

            // Devolver la nueva fecha
            return ldNewDate;
        }


        private string FormatFecha(string tcFecha)
        {
            string lcReturn = tcFecha;
            if (tcFecha.Length >= 10 && tcFecha.Substring(4,1) == "-" && tcFecha.Substring(7, 1) == "-")
            {
                try
                {
                    DateTime ldTime = Convert.ToDateTime(tcFecha);
                    lcReturn = ldTime.ToShortDateString();
                }
                catch
                {
                    lcReturn = tcFecha;
                }
            }
            return lcReturn;
        }

        private int GetRandom(int tnMin, int tnMax)
        {
            Random loRandom = new Random();
            return loRandom.Next(tnMin, tnMax);
        }

        private string Serialize(bool tlActualizando)
        {
            string lcStringSerialize = string.Empty;

            RefreshDictValues(tlActualizando);

            try
            {
                lcStringSerialize = new JavaScriptSerializer().Serialize(_dictVersionActualizacion);
            }
            catch (Exception loEx)
            {
                _cMensaje_Error = "No se ha podido serializar la información de la versión de la tabla variables." + Environment.NewLine + loEx.Message;
            }

            return lcStringSerialize;
        }

        private bool UpdateVersion()
        {
            bool llOk = false;
            Dictionary<string, object> dictVersionActualizacion = new Dictionary<string, object>();

            if (!PreValidate())
                return false;

            _dictVersionActualizacion = LoadVersionVariable(); // Consultamos la información de la tabla variables

            llOk = UpdateVariables(true);

            if (llOk)
                DoWork(); // Ejecutamos la actualización de Sage50

            return llOk;
        }

        private bool UpdateVariables(bool tlActualizando)
        {
            bool llOk = true;

            string lcValores = Serialize(tlActualizando);

            if (_lUpdateVariables)
                llOk = _oBusinessNuevaActualizacion._UpdateVariable(lcValores);
            else
            {
                llOk = _oBusinessNuevaActualizacion._InsertVariable(lcValores);
                _lUpdateVariables = llOk;
            }

            return llOk;
        }

        private bool ExistProcessActualizarSage50()
        {
            Process[] loProcessName = Process.GetProcessesByName("ActualizarSage50");

            bool llExist = loProcessName.Length > 0;

            if (_lActualizando && !llExist)
                _lActualizando = false;

            return llExist;
        }

        private void AfterUpdate()
        {
            // Puede que no hay finalizado
            _dictVersionActualizacion = LoadVersionVariable(); // Consultamos la información de la tabla variables

            if (!NowUpdating(tlAferUpdate: true))
            {
                _cVersionDllServidor = string.Empty;

                // Avisamos si la versión del servidor es superior
                if (IsSuperiorVersionServidorTerminal())
                {
                    if (MessageBox.Show($"El proceso de actualización de {_cNameProducto} ha finalizado." + Environment.NewLine + Environment.NewLine +
                                        $"¿Desea cerrar {_cNameProducto} para actualizar los cambios de la nueva versión?", _cText, MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button1) == DialogResult.Yes)
                    {
                        _llCloseApplication = true;
                    }
                    else
                    {
                        _cVersionDllServidor = string.Empty;
                        _oStateActualizacion = StateActualizacion.PendienteCerrar;
                    }
                }
            }
        }

        private void CloseAplication()
        {
            if (Application.OpenForms.Count > 0)
            {
                Form loForm = Application.OpenForms["frmPrincipal"];
                if (loForm != null)
                {
                    _50.Forms.frmPrincipal loPripal = (_50.Forms.frmPrincipal)loForm;
                    loPripal._Terminar_Ejecucion();
                }
            }
        }

        private void ChangeVisibility()
        {
            Visible = _lVisible;
            ewImagenInformacion.Visible = _lVisible;

            if (_Refresh_Actualizacion != null)
                _Refresh_Actualizacion(_lVisible);
        }

        private bool ExecuteUpdate()
        {
            if (!FUNCTIONS.InternetOk())
                return false;

            bool llOk = false;
            string lcError = string.Empty;

            if (!ValidateFilePath(_cPathIniTerminal, _cFileUpdateSage50))
                return false;

            try
            {
                _lActualizando = true;

                llOk = Execute(_cPathIniTerminal, _cFileUpdateSage50, ParamsExecuteUpdate(), ref lcError);

                if (llOk) 
                {
                    do
                    {
                        Thread.Sleep(5000); // Al estar dentro de la ejecución de un BackGrounWorker el usuario puede continuar trabajando igualmente
                    }
                    while (ExistProcessActualizarSage50());
                }

                AfterUpdate();

            }
            catch (Exception loEx)
            {
                lcError = loEx.Message;
            }

            if (!llOk)
                MessageBox.Show($"No se ha podido realizar la actualización de {_cNameProducto}." + Environment.NewLine + lcError, _cText, MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);

            _lActualizando = false;

            return llOk;
        }

        private string ParamsExecuteUpdate()
        {
            string lcParams = string.Empty;

            Dictionary<string, object> dictParams = new Dictionary<string, object>();
            dictParams.Add("Usuario", "SUPERVISOR");
            dictParams.Add("ModoAvanzado", false);

            try
            {
                lcParams = new JavaScriptSerializer().Serialize(dictParams);
                lcParams = lcParams.Replace("\"", "\\\"");
            }
            catch (Exception loEx)
            {
                _cMensaje_Error = $"No se ha podido serializar la información de la actualizacion de {_cNameProducto}." + Environment.NewLine + loEx.Message;
            }

            return lcParams;        
        }

        private bool Execute(string tcPath, string tcFile, string tcParams, ref string tcError)
        {
            bool llOk = true;
            tcError = string.Empty;

            Process loProcess = new Process();
            loProcess.EnableRaisingEvents = false;
            ProcessStartInfo loExe = new ProcessStartInfo(Path.Combine(tcPath, tcFile));
            loExe.WorkingDirectory = tcPath;
            loExe.Arguments = tcParams;
            loProcess.StartInfo = loExe;
            loProcess.StartInfo.CreateNoWindow = true;
            loProcess.EnableRaisingEvents = true;

            try
            {
                llOk = loProcess.Start();
                loProcess.WaitForExit();
            }
            catch (Exception loEx)
            {
                tcError = loEx.Message;
                llOk = false;
            }

            return llOk;
        }

        private void LoadImage()
        {
            if (_lVisible && ewImagenInformacion.Image == null)
                ewImagenInformacion.Image = images.Properties.Resources.icon_actualizacion32x24;
        }
        #endregion Métodos privados

        #region Métodos BackGroundWorker
        private void _GetData_Async()
        {
            DoWork();
        }

        private void DoWork()
        {
            if (!_lBackgroudWorkerIsRunning && _oStateActualizacion != StateActualizacion.PendienteCerrar)
            {
                _lBackgroudWorkerIsRunning = true;

                //Declaro un nuevo elemento
                _oBackgroundWorker = new BackgroundWorker();

                //Configuro
                _oBackgroundWorker.WorkerSupportsCancellation = true; // Permitimos realizar la cancelación
                _oBackgroundWorker.WorkerReportsProgress = false;

                //Declaro los procesos
                _oBackgroundWorker.DoWork += new DoWorkEventHandler(ExecuteRunWorker);
                _oBackgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(RunWorkerCompleted);

                //Inicio la tarea asíncrona
                _oBackgroundWorker.RunWorkerAsync();
            }
        }

        private void ExecuteRunWorker(object sender, DoWorkEventArgs e)
        {
            try
            {
                WidgetResultadoBackgroundWorker loResult = new WidgetResultadoBackgroundWorker();
                loResult._Resultado = new Dictionary<string, object>() { };

                if (_oStateActualizacion == StateActualizacion.Actualizar)
                    ExecuteUpdate();
                else
                {
                    bool llUpdate = UpdateAvailable();

                    loResult._Resultado.Add("ExisteActualizacion", llUpdate);
                }

                e.Result = loResult;
            }
            catch (Exception loEx)
            {
                DB.Escribir_En_Log_Error(DB.Modo_Registro.Registro_Error, loEx);
            }
        }

        private void RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (_llCloseApplication)
                CloseAplication();
            else
            {
                if (e.Cancelled == false && e.Error == null && e.Result != null && e.Result is WidgetResultadoBackgroundWorker) //Sino he sido cancelado ni he registrado excepción
                {
                    WidgetResultadoBackgroundWorker loWidgetResultadoBackgroundWorker = (WidgetResultadoBackgroundWorker)e.Result;

                    if (_oStateActualizacion == StateActualizacion.Actualizar)
                    {
                        if (!_lVisible)
                            ChangeVisibility(); // Puede que haya realizado la actualización pero no haya actualizado los cambios
                    }
                    else
                    {
                        if (loWidgetResultadoBackgroundWorker._Resultado.ContainsKey("ExisteActualizacion"))
                        {
                            _lVisible = Convert.ToBoolean(loWidgetResultadoBackgroundWorker._Resultado["ExisteActualizacion"]);

                            ChangeVisibility();

                            LoadImage();
                        }
                    }

                    if (_lVisible)
                        DescripcionTooltTip();
                }
            }

            _oStateActualizacion = StateActualizacion.SinEstado;

            _lBackgroudWorkerIsRunning = false;

        }
        #endregion Métodos BackGroundWorker

        #region IDisposable
        // Flag: Has Dispose already been called?
        bool disposed = false;

        public new void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected new virtual void Dispose(bool disposing)
        {
            if (disposed)
                return;

            if (disposing)
            {
                // Free any other managed objects here.
                SubscripcionEventos(true);

                if (_oToolTip != null)
                    _oToolTip.Dispose();
                
                 _oBusinessNuevaActualizacion = null;

                _oBackgroundWorker?.Dispose();
                _oBackgroundWorker = null;

                _dictVersionActualizacion?.Clear();
                _dictVersionActualizacion = null;

                if (components != null)
                    components.Dispose();
            }

            // Free any unmanaged objects here.
            disposed = true;
        }

        ~NuevaActualizacion()
        {
            Dispose(false);
        }
        #endregion IDisposable
    }

    #region clase BusinessNuevaActualizacion
    public class BusinessNuevaActualizacion
    {
        #region Propiedades privadas
        private string _cVariable = "ACTUA_S50";
        
        private string _cComunesPripal = "";
        #endregion Propiedades privadas

        #region Constrcutor
        public BusinessNuevaActualizacion()
        {
            _cComunesPripal = Convert.ToString(EW_GLOBAL._GetVariable("wc_ComunesPripal"));
            _cComunesPripal = string.IsNullOrWhiteSpace(_cComunesPripal) ? DB.DbComunes : _cComunesPripal;
        }
        #endregion Constrcutor

        #region Métodos públicos

        public bool _DatatableVersionVariable(ref DataTable tdtVariable)
        {
            bool llOk = (DB.SQLExec("SELECT VALOR FROM " + DB.SQLDatabaseReal(_cComunesPripal, "VARIABLE") + Environment.NewLine +
                           " WHERE VARIABLE = " + DB.SQLString(_cVariable), ref tdtVariable));

            return llOk;
        }

        public bool _InsertVariable(string tcValores)
        {
            string lcSql;
            bool llOk = false;

            lcSql = "INSERT INTO " + DB.SQLDatabaseReal(_cComunesPripal, "VARIABLE") + Environment.NewLine +
                    " (VARIABLE, VALOR, TIPO) " + Environment.NewLine +
                    " VALUES (" + DB.SQLString(_cVariable) + " , " + DB.SQLString(tcValores) + ", 'C')";

            llOk = DB.SQLExec(lcSql);

            return llOk;
        }

        public bool _UpdateVariable(string tcValores)
        {
            string lcSql;
            bool llOk = false;

            lcSql = "UPDATE " + DB.SQLDatabaseReal(_cComunesPripal, "VARIABLE") + Environment.NewLine +
                    " SET VALOR = " + DB.SQLString(tcValores) + Environment.NewLine +
                    " WHERE VARIABLE = " + DB.SQLString(_cVariable);

            llOk = DB.SQLExec(lcSql);

            return llOk;
        }


        #endregion Métodos públicos
    }

    #endregion clase BusinessNuevaActualizacion

    #region clase InfoNuevaActualizacion
    public class InfoNuevaActualizacion
    {
        #region Propiedades públicas
        public NuevaActualizacion.eServidorTerminalLib _ServidorTerminal { get; set; } = NuevaActualizacion.eServidorTerminalLib.Indefinido;

        public string _VersionServidor { get; set; } = "";
        public string _FechaServidor { get; set; } = "";

        public string _VersionTerminal { get; set; } = "";

        public string _FechaTerminal { get; set; } = "";

        public string _VersionActua { get; set; } = "";
        public string _FechaActua { get; set; } = "";

        #endregion Propiedades públicas

        #region Constrcutor
        public InfoNuevaActualizacion()
        {
        }
        #endregion Constrcutor

    }
    #endregion clase InfoNuevaActualizacion

}