main_s50.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Data;
using sage.ew.functions;
using System.Xml;
using sage.ew.db;
using System.Diagnostics;
using sage.ew.global;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using sage.ew.ewbase;
using sage.ew.ewbase.Forms;
using sage.ew.reports;
using System.Threading.Tasks;
using System.Reflection;
using sage.ew.empresa;
using System.Globalization;
using sage.ew.formul.Classes;
using sage.ew.functions.Clases.DiccionariosLoader;
using sage.ew.functions.Clases;
using Sage.ES.S50.Addons;
using sage.ew.global.DependencyInjection;
using sage._50.Clases;

namespace sage._50
{
    public static class main_s50
    {
        // Variables privadas
        private static string _cRutaServ = "";
        private static string _cComunes = "";
        private static string _cOdbc = "";
        private static string _cIp = "";
        private static string _cUser = "";
        private static string _cPassword = "";
        private static string lcNameProd = Convert.ToString(EW_GLOBAL._GetVariable("wc_nameproducto"));
        private static bool _lExternal_Entry = false;  //PE-105614
        private static bool _lSemaforoConfigBak = false;

        public delegate void _OnReportProgressHandLer(InfoProgresBar e);

        public static event _OnReportProgressHandLer _OnReportProgress;

        public static bool _lEjecucionDesdeProyecto = false;

        public static bool _lEsEjecutable = false;

        public static Dictionary<string, RegCfgCliSrv> _oCfgCliSrv = new Dictionary<string, RegCfgCliSrv>();

        public static string _cPathInicio = "";

        public static Forms.frmSplash _frmSplash;

        public static string _ErrorString = "";

        public static bool _External_Entry
        {
            get { return _lExternal_Entry; }
        }

        private const int CACHE_EXPIRATION = 2;

        private static readonly string SQL_MINIMUM_VERSION = "12";  

        public static bool _main_Sage_50()
        {
            bool lbValidar = true;
            string lcMensajeErrorSO = "";

            EW_GLOBAL.ValorEnClave_VarGlob("wl_sage50", true);  // Bug 125014 // PE-97745
           
            //Activo una cache de 2 minutos
            DB._SetTimeCacheTo(CACHE_EXPIRATION);

            //PE-105131 Validaciones de versión de sistema operativo
            LoadingLog(5, tcText:"Requisitos de sistema operativo");
            if (!FUNCTIONS._RequisitosVersionSO(out lcMensajeErrorSO))
            {
                ew.functions.AutoClosingMessageBox._Show(lcMensajeErrorSO, "Requisitos de sistema operativo", 120000);
            }

            //PE-105131
            LoadingLog(10, tcText: "Validaciones de entorno"); 
            //Bug 140957 Validaciones de entorno (formato fechas)
            if (!validacionesEntornoCorrectas(out string lcMensajeError))
            {
                DB.Registrar_Traza("main_s50.cs,_Validacion_Entorno_Fallida"); // PE-104002
                _ErrorString = lcMensajeError;
                return false; //Fuerzo el retorno para que no siga con la carga
            }

            LoadingLog(20, "_Validar_ConfigINI", "Validando config.ini");
            lbValidar = _Validar_ConfigINI(Program._cGrupoParametro); //Task 195376: Añadimos la opción de especificar un grupo de arranque. por defecto vacío para que utilice el del config.ini

            if (lbValidar)
            {
                LoadingLog(30, "_Validar_CfgCliSrv", "Validando cfgclisrv.xml");
                lbValidar = _Validar_CfgCliSrv();
            }

            if (lbValidar && !_lEjecucionDesdeProyecto)
            {
                LoadingLog(30, "_Validar_Eurowin", "Validando EW");
                lbValidar = _Validar_Eurowin();
            }

            // Task 143679
            if (lbValidar)
            {
                LoadingLog(40, "_Cargar_Licencia", "Comprobando licencia");
                lbValidar = _Cargar_Licencia();
            }

            if (lbValidar)
            {
                LoadingLog(50, "_Registrar_Dependencias_Injector", "Registrando dependencias");
            
                Stopwatch sw = Stopwatch.StartNew();
                //Registramos las dependencias
                RegisterTypesDependencyInjector();
                //DependencyInjector.Instance.RegisterTypes(RegisterType.Addons, true);
                Trace.WriteLine($"Tiempo para carga de dependencias de addons; {sw.ElapsedMilliseconds}");

                LoadingLog(50, "_Cargar_Globales", "Cargando diccionarios");
                lbValidar = _Cargar_Globales();
            }

            //Carga dinamica de librerias para reports (Sage.ES.S50c.Reports)
            if (lbValidar)
            {
                LoadingLog(60, "_Cargar_LibreriasReports", "Cargando librerias SageReports");
                _Cargar_LibreriasReports();

                //PE-103639
                LoadingLog(70, "_RegistrerSageReport", "Registrando SageReports");
                _RegistrerSageReport();

                //PE-103966 - Registar notificaciones
                LoadingLog(80, "_RegistrerSageReport", "Registrando notificationes"); 
                _RegisterNotifications();


                LoadingLog(90, tcText:"Evaluar y registrar versión de motor Sql");
                //Task 144713 => Evaluar y registrar versión de motor Sql
                FUNCTIONS.EvaluarRequisitosMotorBaseDeDatos(SQL_MINIMUM_VERSION, tnDiasEntreNotificaciones: 7, tlGuardarRegistroNotificacion: true);

                //Bug 156806 - Revisar Live Update
                LoadingLog(100, "_LiveUpdate", "Revisando Live Update");
                RevisarLiveUpdate();

                // Definimos objeto para capturar mensajes de Windows
                DB.Registrar_Traza("main_s50,ew_MessageFilters"); // PE-104002
                ew_MessageFilters lst = new ew_MessageFilters();
                Application.AddMessageFilter(lst);

                LoadingLog(100, tcTextCentral: "Cargando entorno ... ");
            }
            
            return lbValidar;
        }

        private static void LoadingLog(int tnProcess, string tcName = "", string tcText = "", string tcTextCentral = "")
        {
            if (!string.IsNullOrEmpty(tcText) || !string.IsNullOrEmpty(tcTextCentral))  _OnReportProgress?.Invoke(new InfoProgresBar(tnProcess, 100, tcText, tcTextCentral));
            if (!string.IsNullOrEmpty(tcName)) DB.Registrar_Traza($"main_s50,{tcName}");
        }

        private static bool validacionesEntornoCorrectas(out string lcMensajeError)
        {
            lcMensajeError = "";
            bool entornoCorrecto = true;

            //Validamos formato de fechas 
            if (!FormatoFechasValido())
            {
                entornoCorrecto = false;
                lcMensajeError = lcMensajeError += "Para poder trabajar con "+ lcNameProd+" debe tener configurado el formato de fecha de la forma día/mes/año" + Environment.NewLine;
            }

            return entornoCorrecto;
        }

        private static bool FormatoFechasValido()
        {
            bool formatoCorrecto = false;
            //string formato = CultureInfo.CurrentUICulture.DateTimeFormat.ShortDatePattern.ToUpper();
            string formato = CultureInfo.CurrentCulture.DateTimeFormat.ShortDatePattern.ToUpper(); //Bug 142594 => En Windows ingleses la cultura de UI no cumple

            //Se hacen varias pruebas y el único formato que hace fallar la aplicación (que sepamos) incumple empezar por el día. 
            if (formato.StartsWith("D") && formato.EndsWith("Y"))
            {
                formatoCorrecto = true;
            }
            return formatoCorrecto;
        }

        public static bool _main_Sage_50_External_Entry(string tcRutaPathInicio, string tcComunes = "", string tcEmpresa = "")
        {
#if DEBUG
            sage.ew.db.DB.Escribir_En_Log_Error(sage.ew.db.DB.Modo_Registro.Registro_Consulta, null, "Entrando en _main_Sage_50_External_Entry. Ruta path inicio -> " + tcRutaPathInicio);
#endif
            bool lbValidar = true;
            EW_GLOBAL.ValorEnClave_VarGlob("wl_sage50", true);  // Bug 125014 // PE-97745

            _lExternal_Entry = true;  //PE-105614
            Sage.ES.S50.UnitTest.Tools.UnitTestDectector._codeInitilizedFromOutsideS50 = true;

            if (string.IsNullOrWhiteSpace(tcRutaPathInicio))
                return false;

            if (!Directory.Exists(tcRutaPathInicio))
                return false;

            string lcEmpAnt = Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa"));
            string lcComunesAnt = DB.DbComunes;

            _cPathInicio = tcRutaPathInicio;
            lbValidar = _Validar_ConfigINI(tcComunes);  //PE-104599

            lbValidar = lbValidar && _Validar_CfgCliSrv(tcComunes);

            if (lbValidar)
                _frmSplash = new Forms.frmSplash();

            //Registramos las dependencias
            RegisterTypesDependencyInjector();

            lbValidar = lbValidar && _Cargar_Globales(tcEmpresa);  //PE-104599
            bool cargaraddonsuccess = AddonsController.Instance.AddonsManager._CargarAddons_WaitAll();

            // CCR 209318 - Si se cambia de grupo o de empresa, tenemos que actualizar la empresa
            // CCR 164862 - Cuando se cargaba un documento de venta por reflection en el método Iva_Portes() de docsven, 
            //              se producía un error porque EW_GLOBAL._Empresa era nulo
            if (lbValidar && (EW_GLOBAL._Empresa == null || lcComunesAnt != DB.DbComunes || lcEmpAnt != Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa"))))
                EW_GLOBAL._Empresa = new Empresa(Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa")));

            return lbValidar;
        }

        private static void _RegistrerSageReport()
        {
            //T113157
            String lcFile = Path.Combine(_cPathInicio, "config.ini");
            String lcPathSageReports = FUNCTIONS.LeerConfigIni("[SAGEREPORTS]", _cPathInicio);

            Task.Factory.StartNew(() => Report._RegisterReportsDataSourceIni(lcPathSageReports));
        }


        public static bool _Validar_ConfigINI(string tcComunes="")
        {
            bool lbValidar = true;
            string lcFile, lcFileBak;

            LoadingLog(21, tcTextCentral: "Validando config.ini ... ");
      
            lcFile = Path.Combine(_cPathInicio, "config.ini");
            lcFileBak = Path.Combine(_cPathInicio, "config.bak");

            _cPathInicio = FUNCTIONS._AddBS(_cPathInicio);
            
            // Comprovar que exista el fichero
            if (!File.Exists(lcFile))
            {
                _ErrorString = "No se ha encontrado el fichero de configuración en el directorio actual.";
                lbValidar = false;
            }

            // Comprovar si existeix la mínima configuració dins del config.INI
            if (lbValidar)
                lbValidar = _Validar_ConfigINI_Configuracion_Minima(tcComunes, lcFile);

            // Si el fichero config.ini no existe o no es correcto, intentamos utilizar el fichero de copia config.BAK
            if (!lbValidar && File.Exists(lcFileBak) && !_lSemaforoConfigBak)
            {
                // Recuperar fichero config.BAK como config.INI
                bool llOk = _Validar_ConfigINI_Gestion_BAK(lcFile, lcFileBak);

                // Realizar la validación del nuevo fichero config.INI
                if (llOk)
                {
                    _lSemaforoConfigBak = true;
                    llOk = _Validar_ConfigINI(tcComunes);
                    _lSemaforoConfigBak = false;
                    if (llOk) _ErrorString = "";
                    return llOk;
                }
            }

            LoadingLog(25, tcTextCentral: $"{(lbValidar ? "Ok" : "Fail")}{Environment.NewLine}");
           
            return lbValidar;
        }

        private static bool _Validar_ConfigINI_Gestion_BAK(string lcFile, string lcFileBak)
        {
            bool llOk = false;

            // Fichero donde haremos una copia del actual fichero config.ini
            string lcFileBak2 = Path.Combine(_cPathInicio, ("config_" + Path.GetRandomFileName() + ".bak"));

            try
            {
                // Si tenemos un fichero config.ini actualmente que no es bueno, por si a caso hacemos una copia
                if (File.Exists(lcFile))
                    File.Copy(lcFile, lcFileBak2, true);

                // CCR 185039 -  Se valida la fecha de modificación del fichero sea <= a 2 días 
                if ((DateTime.Now - File.GetLastWriteTime(lcFileBak)).TotalDays <= 2)
                {
                    // Ahora copiamos el fichero config.bak que tenemos como config.ini
                    File.Copy(lcFileBak, lcFile, true);
                    llOk = true;
                }
            }
            catch (Exception) { llOk = false; }

            return llOk;
        }

        private static bool _Validar_ConfigINI_Configuracion_Minima(string tcComunes, string tcFileIni)
        {
#if DEBUG
            sage.ew.db.DB.Escribir_En_Log_Error(sage.ew.db.DB.Modo_Registro.Registro_Consulta, null, "Entrando en _Validar_ConfigINI_Configuracion_Minima. tcFileIni -> " + tcFileIni + " / _cPathInicio -> " + _cPathInicio);
#endif
            bool lbValidar = true;

            //CCR 185039 - Mirar si el fichero está vacío.
            string lcContent = FUNCTIONS._ReadFile(tcFileIni);
            if (string.IsNullOrWhiteSpace(lcContent))
            {
                _ErrorString = "El fichero de configuración está vacío.";
                lbValidar = false;
            }
            else
            {
                // [SERVIDOR]
                _cRutaServ = FUNCTIONS._AddBS(FUNCTIONS.LeerConfigIni("[SERVIDOR]", _cPathInicio));
                if (string.IsNullOrWhiteSpace(_cRutaServ))
                {
                    _ErrorString = "El fichero de configuración no tiene la estructura esperada. No contiene el tag [SERVIDOR].";
                    lbValidar = false;
                }
                else
                {
                    // Comprobar que sigui una ruta vàlida
                    if (!Directory.Exists(_cRutaServ))
                    {
                        _ErrorString = "La ruta del servidor encontrada en el fichero de configuración no es válida." + Environment.NewLine + _cRutaServ;
                        lbValidar = false;
                    }
                }

                if (lbValidar)
                {
                    // PE-97944. Insertamos ya la ruta a la global
                    EW_GLOBAL.ValorEnClave_VarGlob("wc_iniservidor", _cRutaServ);

                    // [COMUNES]
                    // PE-104599 - Mirar si tenemos comunes por parámetro
                    if (string.IsNullOrEmpty(tcComunes.Trim()))
                        _cComunes = FUNCTIONS.LeerConfigIni("[COMUNES]", _cPathInicio);
                    else
                        _cComunes = tcComunes;

                    if (string.IsNullOrWhiteSpace(_cComunes))
                    {
                        _ErrorString = "El fichero de configuración no tiene la estructura esperada. No contiene el tag [COMUNES].";
                        lbValidar = false;
                    }
                }
            }

            return lbValidar;
        }

        public static bool _Validar_CfgCliSrv()
        {
            //JP: Chapuza por bug 193418 porque Sage50 no soporta parametros opcionales debido a la forma en la que precarga ciertos metodos
            return _Validar_CfgCliSrv(string.Empty);
        }

        public static bool _Validar_CfgCliSrv(string tcComunes)
        {
           
            bool lbValidar = true;
            bool lbAutWin = false;
            string lcCfgCliSrvXml = "", lcNotificaComunes = "";

            LoadingLog(30, tcTextCentral: "Validando cfgclisrv.xml...");

            // Si pasa una segunda vez o más por aquí (por ejemplo en un cambio de grupo) y ya está creado el diccionario del cfgclisrv, ya no
            // accederemos al fichero XML sino que trabajaremos sobre el diccionario _oCfgCliSrv en memoria que representa al fichero
            // cfgclisrv.xml.
            //
            if (_oCfgCliSrv.Count == 0)
            {
                // Comprobar si existe cfgclisrv.xml
                lcCfgCliSrvXml = Path.Combine(_cRutaServ, "cfgclisrv.xml");
                if (!File.Exists(lcCfgCliSrvXml))
                {
                    _ErrorString = "No se ha encontrado el fichero de configuración del servidor (cfgclisrv.xml).";
                    lbValidar = false;
                }
                else
                    cargarCfgCliSrv(lcCfgCliSrvXml);
            }
            else
            {
                _cComunes = FUNCTIONS.LeerConfigIni("[COMUNES]", _cPathInicio);
            }

            if (lbValidar)
            {
                if (!Validar_Comunes(ref lbAutWin, ref lcNotificaComunes))
                {
                    _ErrorString = "No se ha encontrado el COMUNES en el fichero de configuración del servidor.";
                    lbValidar = false;
                }
            }

            if (lbValidar)
            {
                // Comprobar si se ha encontrado el nodo
                // TODO: Comprobar auth
                if (string.IsNullOrWhiteSpace(_cUser) && lbAutWin == false)
                {
                    _ErrorString = "No se ha encontrado el valor de COMUNES del fichero de configuración del terminal en el fichero de configuración del servidor.";
                    lbValidar = false;
                }
            }

            if (lbValidar)
            {
                bool llTopMost = false;

                // Desencriptar
                _cPassword = FUNCTIONS._Encripta(_cPassword).Trim().ToLower();

                if (_frmSplash is Form)
                {
                    llTopMost = !_lExternal_Entry && _frmSplash.TopMost; // Siempre está a true. pero pensando en el futuro lo gestionamos de esta forma

                    if (llTopMost)
                        _frmSplash.TopMost = false;
                }

                // Conectar
                //193353: JP: Cuando se conecta a Sage50 a través de un programa externo (pj. DTS), se viene del método _main_Sage_50_External_Entry
                //y no hay que conectar la DB al COMUNES que está en el ConfigIni sino al que viene como parámetro en la llamada. Ajustamos
                string _comunesForConnect = string.IsNullOrWhiteSpace(tcComunes) ? _cComunes : tcComunes;
                if (!DB.SQLConnect(_cIp, _cUser, _cPassword, _comunesForConnect, tcAliasConexion: "eurowin", tbAuthWin: lbAutWin))
                {
                    _ErrorString = "No ha sido posible realizar la conexión con el servidor de datos.";
                    lbValidar = false;
                }


                //PE-105614 - No comprobar el módulo TPV, si se ha entrado externamente.
                //PE-105536
                if (lbValidar && !_lExternal_Entry && faltaModuloTPV())
                {
                    ew.functions.AutoClosingMessageBox._Show("No se han encontrado AddOns necesarios para el correcto funcionamiento del programa." + Environment.NewLine
                        + Environment.NewLine + "Póngase en contacto con su soporte técnico habitual.", "Requisitos de AddOns instalados", 120000);
                    lbValidar = false;
                }
                //PE-105536
            }

            if (lbValidar)
            {
                LoadingLog(35, tcTextCentral: $"Ok{Environment.NewLine}");
                if (!string.IsNullOrWhiteSpace(lcNotificaComunes))
                    FUNCTIONS._Notificacion("Validación CONFIG.INI", "Etiqueta [COMUNES] con valor incorrecto", lcNotificaComunes, tcIcono: "warning");
            }
            else
            {
                LoadingLog(35, tcTextCentral: $"Fail{Environment.NewLine}");               
            }

            LoadingLog(35, tcTextCentral: "Driver:" + (!string.IsNullOrWhiteSpace(_cOdbc) ? _cOdbc : "SQL Native Client 2005") + Environment.NewLine);

            return lbValidar;
        }

        private static bool Validar_Comunes(ref bool tbAutWin, ref string tcNotifica)
        {
            bool llOk = false;
            string lcComunes = _cComunes;            

            llOk = obtenerDatosConexion(_cComunes, ref _cUser, ref _cPassword, ref _cIp, ref tbAutWin, ref _cOdbc);
            if (!llOk)
            {               
                // Ir comprobando los comunes definidos en el fichero CFGCLISRV
                foreach (KeyValuePair<string, RegCfgCliSrv> loComunes in _oCfgCliSrv)
                {
                    if (loComunes.Key != lcComunes)
                    {
                        _cComunes = loComunes.Key;
                        llOk = obtenerDatosConexion(_cComunes, ref _cUser, ref _cPassword, ref _cIp, ref tbAutWin, ref _cOdbc);
                        if (llOk)
                        {
                            // Sustituir COMUNES en el config.ini con el nuevo bueno que hemos encontrado
                            FUNCTIONS._GuardarConfigIni("[COMUNES]", _cComunes, _cPathInicio, "config.ini");

                            // Notificar que hay un COMUNES incorrecto en el config.ini y se ha sustituido por otro
                            tcNotifica = "Se ha encontrado el valor incorrecto '"+lcComunes+"' en la etiqueta [COMUNES] del fichero CONFIG.INI en "+
                                         "la siguiente ruta: "+ _cPathInicio+ "." +Environment.NewLine+Environment.NewLine+
                                         "Para poder iniciar la aplicación correctamente, se ha sustituido por el valor '" + _cComunes+"'.";                            

                            break;
                        }                        
                    }
                }                
            }

            return llOk;
        }


        private static void cargarCfgCliSrv(string tcFicheroXml)
        {
            XmlDocument xmlCfgCliSrv = new XmlDocument();
            xmlCfgCliSrv.Load(tcFicheroXml);

            // Get principal node
            XmlNode VFPDataNode = xmlCfgCliSrv["VFPData"];

            _oCfgCliSrv.Clear();

            foreach (XmlNode cfgclisrvNode in VFPDataNode.ChildNodes)
            {
                if (cfgclisrvNode.Name.ToLower().Trim() == "cfgclisrv")
                {
                    // Voy cargando el la propiedad diccionario que de main_s50 que tiene todos los registros del CFGCLISRV.XML
                    //
                    if (!string.IsNullOrWhiteSpace(cfgclisrvNode["comunes"].InnerText.Trim()))
                    {
                        // Me aseguro de que este COMUNES no exista ya en el diccionario. Si el XML estuviese mal y tuviese el mismo comunes
                        // más de una vez petaria el diccionario al añadir de nuevo el mismo comunes por segunda vez.
                        //
                        RegCfgCliSrv loExisteReg = null;
                        if (!_oCfgCliSrv.TryGetValue(cfgclisrvNode["comunes"].InnerText.Trim().ToUpper(), out loExisteReg))
                        {
                            RegCfgCliSrv loRegCfgCliServ = new RegCfgCliSrv()
                            {
                                _User = cfgclisrvNode["user"].InnerText.Trim(),
                                _Password = cfgclisrvNode["password"].InnerText.Trim(),
                                _Ip = cfgclisrvNode["ip"].InnerText.Trim(),
                                _Comunes = cfgclisrvNode["comunes"].InnerText.Trim().ToUpper()
                            };

                            if (cfgclisrvNode["server"] != null)
                                loRegCfgCliServ._Server = cfgclisrvNode["server"].InnerText.Trim();
                            else
                                loRegCfgCliServ._Server = "";

                            if (cfgclisrvNode["port"] != null)
                                loRegCfgCliServ._Port = Convert.ToInt32(cfgclisrvNode["port"].InnerText.Trim());
                            else
                                loRegCfgCliServ._Port = 0;

                            if (cfgclisrvNode["autwin"] != null)
                                loRegCfgCliServ._AutWin = Convert.ToBoolean(cfgclisrvNode["autwin"].InnerText.Trim());
                            else
                                loRegCfgCliServ._AutWin = false;

                            if (cfgclisrvNode["odbc"] != null)
                                loRegCfgCliServ._Odbc = cfgclisrvNode["odbc"].InnerText.Trim();
                            else
                                loRegCfgCliServ._Odbc = "";
                            
                            _oCfgCliSrv.Add(cfgclisrvNode["comunes"].InnerText.Trim(), loRegCfgCliServ);
                        }
                    }
                }
            }

            return;
        }


        private static bool obtenerDatosConexion(string tcComunes, ref string tcUser, ref string tcPassword, ref string tcIp, ref bool tlAutWin, ref string tcOdbc)
        {
            bool llOk = true;

            RegCfgCliSrv loRegCfgCliSrv = null;

            // El comunes está guardado en mayúsculas, lo buscamos en mayúsculas.
            //
            if (!_oCfgCliSrv.TryGetValue(tcComunes.ToUpper(), out loRegCfgCliSrv))
            {
                llOk = false;
            }
            else
            {
                tcUser = loRegCfgCliSrv._User;
                tcPassword = loRegCfgCliSrv._Password;
                tcIp = loRegCfgCliSrv._Ip;
                tlAutWin = loRegCfgCliSrv._AutWin;
                tcOdbc = loRegCfgCliSrv._Odbc;
            }

            return llOk;
        }


        private static bool faltaModuloTPV()
        {
             bool llFaltaModulo = (0 == Convert.ToInt32(DB._ValorSQL("MODULOS", new string[] { "NOMBRE='TPV'" }, new string[] { "COUNT(NOMBRE) AS CONTADOR" }, "COMUNES")));
             bool llFaltaPrgs = (2 > Convert.ToInt32(DB._ValorSQL("PRGS", new string[] { "MODULO='TPV'" }, new string[] { "COUNT(MODULO) AS CONTADOR" }, "COMUNES")));
             return (llFaltaModulo || llFaltaPrgs);
        }

        public static bool _Validar_Eurowin()
        {
            
            bool lbValidar = true;
            
            // Comprobar versión ficheros de Eurowin
            string lcDbVistasServidor = Path.Combine(_cRutaServ, "db_vistas_serv");
            string lcDbVistasTerminal = Path.Combine(_cPathInicio, "Db_Vistas");
            string lcTriggersServidor = Path.Combine(_cRutaServ, "triggers");
            string lcTriggersTerminal = Path.Combine(_cPathInicio, "Triggers");

            LoadingLog(30, tcTextCentral: "Validando ejecutable ... ");

            if (lbValidar)
            {
                // Comprobar directorio vistas                
                if (!Directory.Exists(lcDbVistasServidor))
                {
                    _ErrorString = "No se ha encontrado el directorio Db_Vistas_Serv en el servidor de la aplicación.";
                    lbValidar = false;
                }
            }

            if (lbValidar)
            {
                // Comprobar directorio triggers                
                if (!Directory.Exists(lcTriggersServidor))
                {
                    _ErrorString = "No se ha encontrado el directorio Triggers en el servidor de la aplicación.";
                    lbValidar = false;
                }
            }

            if (lbValidar)
            {
                // Comprobar directorio DB_Vistas
                if (!Directory.Exists(lcDbVistasTerminal))
                    Directory.CreateDirectory(lcDbVistasTerminal);
                if (!Directory.Exists(lcDbVistasTerminal))
                {
                    _ErrorString = "No se ha podido crear el directorio Db_Vistas en el terminal de la aplicación.";
                    lbValidar = false;
                }
            }

            if (lbValidar)
            {
                // Comprobar directorio DB_Vistas
                if (!Directory.Exists(lcTriggersTerminal))
                    Directory.CreateDirectory(lcTriggersTerminal);
                if (!Directory.Exists(lcTriggersTerminal))
                {
                    _ErrorString = "No se ha podido crear el directorio Triggers en el terminal de la aplicación.";
                    lbValidar = false;
                }
            }            

            if (lbValidar)
            {
                // Try para comprobar en uso
                try
                {
                    // Copiar DB_Vistas
                    foreach (string file in Directory.GetFiles(lcDbVistasServidor))
                    {
                        string lcNomFile = new FileInfo(file).Name;
                        File.Copy(Path.Combine(lcDbVistasServidor, lcNomFile), Path.Combine(lcDbVistasTerminal, lcNomFile), true);
                    }
                }
                catch (Exception loEx)
                {
                    DB.Registrar_Error(loEx); //Registramos excepción
                }

                // Comprovar si existeixen tots els fitxer
                if (!File.Exists(Path.Combine(lcDbVistasTerminal, "vistasbase.vcx"))
                    || !File.Exists(Path.Combine(lcDbVistasTerminal, "vistasbase.vct"))
                    || !File.Exists(Path.Combine(lcDbVistasTerminal, "vistas.vcx"))
                    || !File.Exists(Path.Combine(lcDbVistasTerminal, "vistas.vct")))
                {
                    _ErrorString = "No se han podido copiar las vistas al terminal.";
                    lbValidar = false;
                }
            }

            if (lbValidar)
            {
                // Try para comprobar en uso
                try
                {
                    // Copiar DB_Vistas
                    foreach (string file in Directory.GetFiles(lcTriggersServidor))
                    {
                        string lcNomFile = new FileInfo(file).Name;
                        File.Copy(Path.Combine(lcTriggersServidor, lcNomFile), Path.Combine(lcTriggersTerminal, lcNomFile), true);
                    }
                }
                catch (Exception)
                {
                }

                // Comprovar si existeixen tots els fitxer
                if (!File.Exists(Path.Combine(lcTriggersTerminal, "trigbase.vcx"))
                    || !File.Exists(Path.Combine(lcTriggersTerminal, "trigbase.vct"))
                    || !File.Exists(Path.Combine(lcTriggersTerminal, "triggers.vcx"))
                    || !File.Exists(Path.Combine(lcTriggersTerminal, "triggers.vct")))
                {
                    _ErrorString = "No se han podido copiar las triggers al terminal.";
                    lbValidar = false;
                }
            }

            LoadingLog(35, tcTextCentral: $"{(lbValidar ? "Ok" : "Fail")}{Environment.NewLine}");
           
            return lbValidar;
        }

        public static bool _Cargar_Licencia()
        {
            bool llOk = true;
            string lcLicencia;

            LoadingLog(45, tcTextCentral: $"Comprobando licencia ... ");
            // Obtener la licencia directamente de la BD y comprobarla
            lcLicencia = LICENCIAS._ObtenerLicenciaActual();
            if (string.IsNullOrWhiteSpace(lcLicencia))
            {
                _ErrorString = LICENCIAS._MensajeError;
                llOk = false;
            }

            LoadingLog(45, tcTextCentral: $"{(llOk ? "Ok" : "Fail")}{Environment.NewLine}");

            //if (LICENCIAS._EsLicenciaParaPruebas && !LICENCIAS._EsLicenciaParaEvaluacion)
            //    _frmSplash._MostrarMensajeLicenciaPruebas();

            return llOk;
        }

        public static bool _Cargar_Globales(bool tlVerificarLicencia, string tcEmpresa = "", string tcCajaTpv = "")
        {
            return cargarGlobales(tcEmpresa, tcCajaTpv, tlVerificarLicencia);
        }


        public static bool _Cargar_Globales(string tcEmpresa = "", string tcCajaTpv="")
        {
            return cargarGlobales(tcEmpresa, tcCajaTpv, true);
        }


        private static bool cargarGlobales(string tcEmpresa, string tcCajaTpv, bool tlVerificarLicencia)
        {
            bool lbValidar = true;
            string lcEmpresa = "";
            string lcCajaTpv = "";


            // Añadir estas variables al inicio de todo, ya que se necesitan antes.
            EW_GLOBAL.ValorEnClave_VarGlob("wl_sage50", true);  // PE-97745
            EW_GLOBAL.ValorEnClave_VarGlob("wc_pathinicio", _cPathInicio);
            EW_GLOBAL.ValorEnClave_VarGlob("wc_iniservidor", _cRutaServ);

            string lcLicencia = LICENCIAS._Licencia;

            // Task 142646 (Diciembre 2018), nueva variedad de producto Sage 50 Asesor Contable. 
            // Un Sage50 Asesor Contable será un Premium (wn_tipoprod=2) y además la licencia 
            // comience por  SY. Si se dan las anteriores condiciones pondremos wn_AsesorContable a 1
            //
            //
            EW_GLOBAL.ValorEnClave_VarGlob("wn_AsesorContable", 0);
            if (!string.IsNullOrWhiteSpace(lcLicencia) && lcLicencia.Length >= 2 && lcLicencia.Substring(0, 2) == "SY")
            {
                // Para el caso de licencia SY asignamos un nivel por defecto de wn_asesorcontable de 10
                //
                // Si algún dia se decide crear algun nivel superior o inferior de asesorcontable en función de un nuevo
                // prefijo de licencia, se declarará en wn_asesorcontable el valor que corresponda (superior o inferior a 10)
                //
                EW_GLOBAL._SetVariable("wn_AsesorContable", 10);
            }

            // Bug 167355 - Comprobar existencia empresa
            // Obtener valores mínimos para cargar diccionarios
            lcEmpresa = ObtenerEmpresa(tcEmpresa);

            // PE-104301. Sólo tener en cuenta la Caja de TPV si el módulo de TPV está activo.
            if (EW_GLOBAL._ModuloActivo("TPV"))
            {
                if (string.IsNullOrEmpty(tcCajaTpv))
                    lcCajaTpv = FUNCTIONS.LeerConfigIni("[CAJATPV]");
                else
                    lcCajaTpv = tcCajaTpv;

                // PE-100470. Comprobar que la caja no contenga NO
                if (lcCajaTpv.Trim().ToUpper() == "NO")
                    lcCajaTpv = string.Empty;
            }

            LoadingLog(45, tcTextCentral: "Cargando diccionarios ... ");
         
            if (string.IsNullOrWhiteSpace(lcCajaTpv))
                lbValidar = DiccionariosLoader.CargarDiccionarios(lcEmpresa);
            else
                lbValidar = DiccionariosLoader.CargarDiccionarios(lcEmpresa, lcCajaTpv);


            if (lbValidar)
            {
                LoadingLog(55, tcTextCentral: $"Ok{Environment.NewLine}");
                LoadingLog(55, tcTextCentral: "Obteniendo parámetros globales ... ");
            
                // Para saber si se ha actualizado sage 50
                EW_GLOBAL._Sage50Actualizado = FUNCTIONS._Sage50Actualizado();

                // Task 142425
                string lcUsuario = "";
                if (!string.IsNullOrWhiteSpace(Program._cUserEurowin))
                    lcUsuario = Program._cUserEurowin;
                else
                    lcUsuario = FUNCTIONS.LeerConfigIni("[USUARIO]");

                // Continuamos con la carga
                string lcLetra = FUNCTIONS.LeerConfigIni("[LETRA]");
                string lcAlmacen = FUNCTIONS.LeerConfigIni("[ALMACEN]"); //PE-102224                

                // Obtener ejercicio predeterminado
                string lcAny = DB.Ejercicio_EW.ToString().Trim();

                // Obtener operario predeterminado según caja
                string lcOperarioTpv = string.Empty;
                if (EW_GLOBAL._ModuloActivo("TPV"))
                    lcOperarioTpv = Convert.ToString(DB.SQLValor("CAJAS", "CODIGO", lcCajaTpv, "OPERARIO", "TPV"));

                // Otros valores
                string lcusergraf = Path.Combine(_cRutaServ, @"usergraf\");

                // Asignamos el valor proviniente de la variable SQL_LOG del config.ini
                string lcSqlLog = Convert.ToString(FUNCTIONS.LeerConfigIni("[SQL_LOG]")).ToUpper().Trim();

                // Asignamos si trabajamos con PRUEVAS SI
                string lcPrueva = Convert.ToString(FUNCTIONS.LeerConfigIni("[PRUEVAS]")).ToUpper();
                bool llPrueva = (lcPrueva == "SI" || lcPrueva == "PERMANENTE");

                // Carga de diccionarios
                if (!string.IsNullOrWhiteSpace(lcAny))
                {
                    // Bug-107350. Comprobar si el ejercicio existe en el grupo de empresas.
                    // En caso contrario, asignar el predeterminado
                    string lcDataBase = string.Empty;
                    lcAny = Convert.ToString(EW_GLOBAL._GetVariable("wc_any"));

                    // Obtenemos la base de datos del ejercicio que vamos a predeterminar como GESTION
                    if (!DB._oAliasDB.TryGetValue(lcAny, out lcDataBase))
                    {
                        lcAny = DB.Ejercicio_EW.ToString().Trim();
                    }

                    DB.SQLPredeterminarGestion(Convert.ToString(lcAny));
                }

                //Cargamos los esquemas => Se hace en este punto ya que antes no tenemos conexión y no se ha predeterminado ejercicio 
                DB.PreloadSchemas();

                // Añadirlos a la global
                EW_GLOBAL.ValorEnClave_VarGlob("wc_usuario", lcUsuario);
                EW_GLOBAL.ValorEnClave_VarGlob("wc_empresa", lcEmpresa);
                EW_GLOBAL.ValorEnClave_VarGlob("wc_cajatpv", lcCajaTpv);
                EW_GLOBAL.ValorEnClave_VarGlob("wc_concomunes", _cComunes);
                EW_GLOBAL.ValorEnClave_VarGlob("wc_any", lcAny);
                EW_GLOBAL.ValorEnClave_VarGlob("wc_operariotpv", lcOperarioTpv);
                EW_GLOBAL.ValorEnClave_VarGlob("wc_usergraf", lcusergraf);
                EW_GLOBAL.ValorEnClave_VarGlob("wc_sql_log", lcSqlLog);
                EW_GLOBAL.ValorEnClave_VarGlob("wl_prueva", llPrueva);
                EW_GLOBAL.ValorEnClave_VarGlob("formvfp", "");  // Por compatibilidad
                EW_GLOBAL.ValorEnClave_VarGlob("wl_EsEjecutable", _lEsEjecutable);  // PE-103025

                // PE-97592. Solo asignar el valor a wc_letra si hay valor en Config.ini. Si no, dejar la que se ha leido de Empresa
                if (!string.IsNullOrWhiteSpace(lcLetra))
                    EW_GLOBAL.ValorEnClave_VarGlob("wc_letra", lcLetra);

                //PE-102224: Si nos llega desde config.ini, lo establecemos en wc_empresa independientemente del valor (con wc_almacen y wc_operario)
                if (!string.IsNullOrWhiteSpace(lcAlmacen))
                    EW_GLOBAL.ValorEnClave_VarGlob("wc_almacen", lcAlmacen);

                LoadingLog(55, tcTextCentral: $"Ok{Environment.NewLine}");
            }
            else
            {
                LoadingLog(55, tcTextCentral: $"Fail{Environment.NewLine}");
                _ErrorString = "No se han podido cargar los diccionario de variables globales.";
            }


            if (tlVerificarLicencia)
            {
                // PE-99112. Descarga del fichero Sagelic
                LoadingLog(57, tcTextCentral: "Validando licencia ... ");

                if (LICENCIAS._Validar_Licencia_Suscripcion())
                {
                    LoadingLog(57, tcTextCentral: $"Ok{Environment.NewLine}");
                }
                else
                {
                    LoadingLog(57, tcTextCentral: $"Fail{Environment.NewLine}");
                    _ErrorString = LICENCIAS._MensajeError;  // PE-101933
                    return false;                   
                }
             

                // PE-100885. Es posible que dejemos entrar en la aplicación, pero mostrando alguna advertencia.
                if (!string.IsNullOrWhiteSpace(LICENCIAS._MensajeError))
                {
                    _ErrorString = LICENCIAS._MensajeError;
                    LICENCIAS._MensajeError = "";
                }
            }

            FunctionsDependencies functionsDependencies = new FunctionsDependencies()
            {
                GenerarChecksumOpciones = Criptografia.GenerarChecksumOpciones,
                GetSage50PathLibrerias = FUNCTIONS.GetSage50PathLibrerias,
                CodigoLicencia = LICENCIAS._CodigoLicencia,
                PluginActivo = FUNCTIONS._PluginActivo,
                CrearNotificacionWarning = FUNCTIONS.CrearNotificacionWarning
            };

            // PE-96322,PE-97109. Cargamos los addons (modulos, pam)
            AddonsController.Instance.AddonsManager._CargarAddOns(functionsDependencies, !_lExternal_Entry);
            if (_lExternal_Entry)
            {
                // Esperar a finalizar la carga asincrona de los addons            
                bool cargaraddonsuccess = AddonsController.Instance.AddonsManager._CargarAddons_WaitAll();
            }

            if ((!_garantizandoAddons || (!string.IsNullOrWhiteSpace(_cGrupo) && _cGrupo != _cGrupoEmpresaActual)) && !_lExternal_Entry)
            {
                //Solo se ejecutará una vez
                _garantizandoAddons = true;

                // La clase autoejecuta todo el codigo de validación
                // Pasar segundo parámetro "false" para que no se fuerce a bajar el fichero Sagelic
                // Adicionalmente le pasamos un true para que refresque los Addons destacados
                SetupAddons setup = new SetupAddons(true, false, false, true);
            }

            _cGrupo = _cGrupoEmpresaActual; // Asignamos el grupo para la carga de los Add-ons destacados al cambiar de grupo

            LoadServices();

            return lbValidar;
        }

        static bool _garantizandoAddons = false;

        private static string _cGrupo = string.Empty;

        private static string _cGrupoEmpresaActual
        {
            get
            {
                return DB.DbComunes.Substring(4, 4);
            }
        }

        private static bool LoadServices()
        {
            string lcError = string.Empty;

            FUNCTIONS._StateServiceForm(ref lcError); // De momento no es necesario gestionar el error para este tipo de petición

            return true;
        }

        public static bool _Cargar_LibreriasReports()
        {            
            bool llOk = false;
            string lcPatron = "Sage.ES.S50c.Reports";
            string lcPathInicio = FUNCTIONS.GetSage50PathLibrerias();

            if (Directory.Exists(lcPathInicio))
            {
                DirectoryInfo loDir = new DirectoryInfo(lcPathInicio);
                //Mirem si el nom de la dll es del tipus que ens interessa carregar
                List<FileInfo> loList = (from loFile in loDir.GetFiles("*.dll")
                                         where loFile.Name.ToLower().StartsWith(lcPatron.ToLower())
                                         select loFile).ToList();

                //Recorrem totes les dlls
                foreach (FileInfo loFileInfo in loList)
                {
                    
                    string lcFicheroDll = loFileInfo.FullName;
                    //La carreguem
                    Assembly addonAssembly = null;
                    try
                    {
                        var appDomain = AppDomain.CreateDomain(lcFicheroDll);
                        addonAssembly = appDomain.Load(System.IO.File.ReadAllBytes(lcFicheroDll));
                    }
                    catch (Exception)
                    {
                        addonAssembly = null;
                    }
                    if (addonAssembly == null)
                    {
                        try
                        {
                            addonAssembly = Assembly.LoadFrom(lcFicheroDll);
                        }
                        catch (Exception)
                        {
                            addonAssembly = null;
                        }
                    }
                    //Comprobem si s'ha carregat amb éxit
                    if (addonAssembly != null)
                        llOk = true;
                }
            }

            return llOk;
        }

        public static void _RegisterNotifications()
        {
            // Cogemos el comunes principal y el actual
            string lcComunesPripal = Convert.ToString(EW_GLOBAL._GetVariable("wc_ComunesPripal"));
            string lcComunesActual = Convert.ToString(EW_GLOBAL._GetVariable("wc_ComunesActual"));

            // Bug 172689 - Si el comunes actual está vacio, lo cogemos de la DB
            if (string.IsNullOrWhiteSpace(lcComunesActual))
            { 
                if (DB._oAliasDB.TryGetValue("COMUNES", out lcComunesActual))
                    lcComunesActual = lcComunesActual.Replace("].dbo.", "").Replace("[", "").Trim().ToUpper();
            }

            // PE-104253 - Si wc_ComunesPripal está vacio, indica que solamente hay un grupo
            // Solamente añadimos las notificaciones en el grupo principal
            // Mirar si el comunes principal y el actual no son el mismo 
            if (!String.IsNullOrEmpty(lcComunesPripal.Trim()) && lcComunesActual != lcComunesPripal)
                return;
            
            // Coger la ruta del servidor principal
            string lcRutaServidor = Convert.ToString(EW_GLOBAL._GetVariable("wc_iniservidor")).Trim();
            //string lcRutaServidor2 = FUNCTIONS.LeerConfigIni("[SERVIDOR_2]").Trim();

            //if (!string.IsNullOrWhiteSpace(lcRutaServidor2))
            //    lcRutaServidor = lcRutaServidor2;

            // Ruta fichero notificaciones
            string lcPath = FUNCTIONS._AddBS(lcRutaServidor) +  @"\LOGS\NOTIFICA";
            
            // Mirar si existe el directorio
            if (!Directory.Exists(lcPath))
                return;

            // Recorrer los ficheros del directorio con la máscara "notifica*.xml"
            DirectoryInfo ldDir = new DirectoryInfo(lcPath);
            foreach (var lcFile in ldDir.GetFiles("notifica*.xml"))
            {
                string lcFileXml = Path.Combine(lcPath, lcFile.Name);

                // tratar el fichero XML y cambiar el nombre del fichero
                if (_RegisterNotificationXml(lcFileXml))
                {
                    string lcFileCopy = Path.Combine(lcPath, "_" + lcFile.Name);

                    try
                    {
                        // Eliminar fichero
                        if (File.Exists(lcFileCopy))
                            File.Delete(lcFileCopy);

                        // renombrar fichero
                        File.Move(lcFileXml, lcFileCopy);
                    }
                    catch (Exception loEx)
                    {
                        DB.Registrar_Error(new Exception("No se ha podido copiar fichero "+lcFileXml+" ("+loEx.Message+")."));
                    }
                }
            }
        }

        private static bool _RegisterNotificationXml(string tcFile)
        {
            bool llOk = false, llReturn = false;
            DataTable ldtTabla = new DataTable();
            
            // Pasar el XML a Datatable
            if (System.IO.File.Exists(tcFile))
                llOk = FUNCTIONS._Xml2Datatable(tcFile, ref ldtTabla);

            // Mirar si existe la tabla
            if (!llOk || ldtTabla == null)
                return false;
            
            // Recorrer el datatable y añadir notificaciones
            foreach (DataRow ldrRow in ldtTabla.Rows)
            {
                string lcCat = "", lcNombre = "", lcDesc = "", lcLib = "", lcClase = "", lcPermanente = "";
                bool tlPermanente = false;

                if (ldtTabla.Columns.Contains("categoria"))
                    lcCat = Convert.ToString(ldrRow["categoria"]);
                
                if (ldtTabla.Columns.Contains("nombre"))
                    lcNombre = Convert.ToString(ldrRow["nombre"]);

                if (ldtTabla.Columns.Contains("descrip"))
                    lcDesc = Convert.ToString(ldrRow["descrip"]);

                if (ldtTabla.Columns.Contains("libreria"))
                    lcLib = Convert.ToString(ldrRow["libreria"]);

                if (ldtTabla.Columns.Contains("clase"))
                    lcClase = Convert.ToString(ldrRow["clase"]);

                if (ldtTabla.Columns.Contains("permanente"))
                {
                    lcPermanente = Convert.ToString(ldrRow["permanente"]);
                    if (!String.IsNullOrEmpty(lcPermanente.Trim()) && lcPermanente.Trim()=="true")
                        tlPermanente = true;
                }
            
                // Añadir la notificación
                if (!String.IsNullOrEmpty(lcCat.Trim()) && !String.IsNullOrEmpty(lcNombre.Trim()))
                {
                    Notifica._This._Add(lcCat, lcNombre, lcDesc, tcLibreria: lcLib, tcClase: lcClase, toIcono: NotificaIconos.info, tlPermanente: tlPermanente);
                    llReturn = true;
                }
            }

            return llReturn;
        }


        private static void RevisarLiveUpdate()
        {
            sage.ew.ewbase.LiveUpdate loLiveUpdate = new LiveUpdate(false);
            Task TaskLU = new Task(() => loLiveUpdate._RevisarLiveUpdate());
            TaskLU.Start();
        }


        public static bool Connect(string tcPathEuroTerm, string tcUser, string tcPassword, string tcEmpresa = "", bool tlMuestraErrores = true)
        {
            //Comprobació inicial per si ja tenim conexió a BD
            if (!string.IsNullOrWhiteSpace(sage.ew.db.DB.Conexion))
            {
                //Missatge d'error
                if(tlMuestraErrores)
                    sage.ew.functions.FUNCTIONS._MessageBox("Ya está conectado a "+ lcNameProd+".",
                        "Conexión a "+ lcNameProd, MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
                return true;
            }

            bool llOk = false;
            //Validem que el directori del terminal al menys existeixi
            if (!string.IsNullOrWhiteSpace(tcPathEuroTerm) && Directory.Exists(tcPathEuroTerm))
            {
                //Validacions y carrega de l'entorn
                sage._50.main_s50._frmSplash = new sage._50.Forms.frmSplash();
                sage._50.main_s50._cPathInicio = tcPathEuroTerm;
                if (sage._50.main_s50._main_Sage_50())
                {
                    DB._SetTimeCacheTo(0); //Deshabilitar caché de consultas ya que en este método connect no se estaba deshabilitando y hubiera dado problemas

                    //Invoquem la pantalla de login
                    sage.ew.usuario.Forms.frmLogin loForm = new sage.ew.usuario.Forms.frmLogin();
                    //Definim la empresa
                    if (!string.IsNullOrWhiteSpace(tcEmpresa))
                    {
                        loForm._Empresa = tcEmpresa;
                        if (loForm._Empresa != tcEmpresa)
                            _ErrorString += "No se ha podido asignar la empresa \"" + tcEmpresa + "\"." + Environment.NewLine + "¿Puede ser que la empresa no exista?";
                    }
                    //Comprobem errors
                    if (string.IsNullOrWhiteSpace(_ErrorString))
                    {
                        //Resposta per defecte
                        DialogResult leResposta = DialogResult.Cancel;
                        //Comprobació user/pass
                        if (string.IsNullOrWhiteSpace(tcUser) || string.IsNullOrWhiteSpace(tcPassword))
                            leResposta = loForm.ShowDialog(); //Mostrem pantalla de login
                        else
                            leResposta = loForm._CheckLogin(tcUser, tcPassword); //Login automàtic

                        llOk = (leResposta == DialogResult.OK);
                    }
                }
            }

            if (!llOk)
            {
                //Borrem l'string de conexió a BD
                DB.Conexion = "";
                //Missatge d'error
                if (tlMuestraErrores)
                {
                    string lcError = _ErrorString;
                    if (string.IsNullOrWhiteSpace(lcError))
                        lcError = "Usuario o contraseña incorrectos.";
                    MessageBox.Show(lcError, "Conexión a "+ lcNameProd, MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
                }
            }
            else
            {
                // TODO. Que fer amb els estils?
                EW_GLOBAL._CodiPerfilCarregat = ".predet";
            }

            return llOk;
        }

        public static bool Connect(string tcInstancia, string tcUser, string tcPassword, string tcBDComunes, string tcEmpresaGuid, bool tlMuestraErrores = true)
        {
            //Task 151163: Obtener el PathInicio y IniServidor para guardarlos en wc_pathinicio y wc_iniservidor de la global
            //sin que otras aplicaciones tengan que escribirlo (por ejemplo DTS)
            string codeBase = Assembly.GetExecutingAssembly().CodeBase;
            UriBuilder uri = new UriBuilder(codeBase);
            string pathInicio = Uri.UnescapeDataString(uri.Path);
            pathInicio = Path.GetDirectoryName(pathInicio);
            string iniServidor = string.Empty;

            if (!string.IsNullOrWhiteSpace(pathInicio))
            {
                pathInicio = System.IO.Directory.GetParent(pathInicio).FullName;
                if (!string.IsNullOrWhiteSpace(pathInicio))
                {                
                    pathInicio = FUNCTIONS._AddBS(pathInicio);                    

                    //A partir del pathInicio buscar el config.ini y obtener el iniServidor
                    iniServidor = FUNCTIONS._AddBS(FUNCTIONS.LeerConfigIni("[SERVIDOR]", pathInicio));
                }
            }

            if (!string.IsNullOrWhiteSpace(pathInicio) && !string.IsNullOrWhiteSpace(iniServidor))
            {
                //Si hemos podido cargar las dos variables las pasamos a las de la clase que se guardaran en EW_GLOBAL
                _cPathInicio = pathInicio;
                _cRutaServ = iniServidor;
                EW_GLOBAL.ValorEnClave_VarGlob("wc_pathinicio", _cPathInicio);
            }
            //FIN Task 151163

            EW_GLOBAL.ValorEnClave_VarGlob("wl_sage50", true);  //Necesario, en la otra sobrecarga si que se asigna a true y debe ser true para sage50

            //Comprobació inicial per si ja tenim conexió a BD
            if (!string.IsNullOrWhiteSpace(sage.ew.db.DB.Conexion))
            {
                //Missatge d'error
                if (tlMuestraErrores)
                    sage.ew.functions.FUNCTIONS._MessageBox("Ya está conectado a "+ lcNameProd+".",
                        "Conexión a "+lcNameProd, MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
                return true;
            }

            bool lbValidar = true;
            //Validem que tinguem dades
            if (!string.IsNullOrWhiteSpace(tcInstancia) && !string.IsNullOrWhiteSpace(tcUser)
                && !string.IsNullOrWhiteSpace(tcPassword) && !string.IsNullOrWhiteSpace(tcBDComunes))
            {
                //Definir variables
                _cComunes = tcBDComunes;
                _cUser = tcUser;
                _cPassword = tcPassword;
                _cIp = tcInstancia;

                // Conectar a Base de datos
                if (!DB.SQLConnect(_cIp, _cUser, _cPassword, _cComunes, tcAliasConexion: "eurowin", tbAuthWin: false))
                {
                    _ErrorString = "No ha sido posible realizar la conexión con el servidor de datos.";
                    lbValidar = false;
                }

                if (lbValidar)
                {
                    RegisterTypesDependencyInjector();
                    //CCR 148421 - Para crear el objeto Sagelic
                    LICENCIAS._ObtenerLicenciaActual();
                    LICENCIAS._Validar_Licencia_Suscripcion();

                    //Recuperar ID de empresa
                    string lcEmpresa = "";
                    DataTable ldtTemp = new DataTable();
                    string lcSql = "SELECT codigo FROM " + DB.SQLDatabase("EMPRESA") + " WHERE guid_id = " + DB.SQLString(tcEmpresaGuid);
                    if (DB.SQLExec(lcSql, ref ldtTemp) && ldtTemp.Rows.Count > 0 && !string.IsNullOrWhiteSpace(ldtTemp.Rows[0]["codigo"].ToString()))
                    {
                        lcEmpresa = ldtTemp.Rows[0]["codigo"].ToString();
                        //Cargar diccionarios
                        lbValidar = DiccionariosLoader.CargarDiccionarios(lcEmpresa);
                        if (!lbValidar)
                            _ErrorString = "No se han podido cargar los diccionario de variables globales.";
                    }
                    else
                    {
                        //Para DTS: Recorrer todos los ejercicios y el que contenga el guid de empresa es el que predeterminamos y cargamos diccionarios
                        lcSql = "SELECT [any] AS ano FROM " + DB.SQLDatabase("COMUNES", "ejercici") + " ORDER BY [any] DESC ";
                        DataTable ldtEjercicis = new DataTable();
                        if (DB.SQLExec(lcSql, ref ldtEjercicis) && ldtEjercicis.Rows.Count > 0)
                        {
                            foreach (DataRow ldr in ldtEjercicis.Rows)
                            {
                                EW_GLOBAL.ValorEnClave_VarGlob("wc_any", Convert.ToString(ldr["ano"]).Trim());
                                DB.SQLPredeterminarGestion(Convert.ToString(ldr["ano"]).Trim()); //PE-101549
                                DiccionariosLoader.ReCargarDiccionarios();

                                lcSql = "SELECT codigo FROM " + DB.SQLDatabase("EMPRESA") + " WHERE guid_id = " + DB.SQLString(tcEmpresaGuid);
                                if (DB.SQLExec(lcSql, ref ldtTemp) && ldtTemp.Rows.Count > 0 && !string.IsNullOrWhiteSpace(ldtTemp.Rows[0]["codigo"].ToString()))
                                {
                                    lcEmpresa = ldtTemp.Rows[0]["codigo"].ToString();
                                    //Cargar diccionarios
                                    lbValidar = DiccionariosLoader.CargarDiccionarios(lcEmpresa);
                                    if (!lbValidar)
                                        _ErrorString = "No se han podido cargar los diccionario de variables globales.";
                                    if (lbValidar)
                                        break;
                                }
                            }

                            if (!lbValidar)
                            {
                                _ErrorString = "No se ha encontrado ninguna empresa con el GUID \"" + tcEmpresaGuid + "\".";
                                lbValidar = false;
                            }
                        }
                        else
                        {
                            _ErrorString = "No se ha encontrado ninguna empresa con el GUID \"" + tcEmpresaGuid + "\".";
                            lbValidar = false;
                        }
                    }

                    if (lbValidar)
                    {
                        // Obtener ejercicio predeterminado
                        string lcAny = DB.Ejercicio_EW.ToString().Trim();

                        // Carga de diccionarios
                        if (!string.IsNullOrWhiteSpace(lcAny))
                        {
                            // Bug-107350. Comprobar si el ejercicio existe en el grupo de empresas.
                            // En caso contrario, asignar el predeterminado
                            string lcDataBase = string.Empty;
                            lcAny = Convert.ToString(EW_GLOBAL._GetVariable("wc_any"));

                            // Obtenemos la base de datos del ejercicio que vamos a predeterminar como GESTION
                            if (!DB._oAliasDB.TryGetValue(lcAny, out lcDataBase))
                            {
                                lcAny = DB.Ejercicio_EW.ToString().Trim();
                            }

                            DB.SQLPredeterminarGestion(Convert.ToString(lcAny));
                        }                        

                        // Añadirlos a la global
                        EW_GLOBAL.ValorEnClave_VarGlob("wc_pathinicio", _cPathInicio);
                        EW_GLOBAL.ValorEnClave_VarGlob("wc_iniservidor", _cRutaServ);
                        EW_GLOBAL.ValorEnClave_VarGlob("wc_usuario", "SUPERVISOR");   //Necesario para tener permiso completo a ciertas pantallas (asientos, por ejemplo)
                        EW_GLOBAL.ValorEnClave_VarGlob("wc_empresa", lcEmpresa);
                        EW_GLOBAL.ValorEnClave_VarGlob("wc_cajatpv", "");
                        EW_GLOBAL.ValorEnClave_VarGlob("wc_concomunes", _cComunes);
                        EW_GLOBAL.ValorEnClave_VarGlob("wc_any", lcAny);
                        EW_GLOBAL.ValorEnClave_VarGlob("wc_operariotpv", "");
                        EW_GLOBAL.ValorEnClave_VarGlob("wc_ewlicencia", "");                        
                        EW_GLOBAL.ValorEnClave_VarGlob("wc_usergraf", "");
                        EW_GLOBAL.ValorEnClave_VarGlob("wc_sql_log", "");
                        EW_GLOBAL.ValorEnClave_VarGlob("wl_prueva", false);
                        EW_GLOBAL.ValorEnClave_VarGlob("formvfp", "");  // Por compatibilidad
                        EW_GLOBAL.ValorEnClave_VarGlob("wl_EsEjecutable", _lEsEjecutable);
                        EW_GLOBAL.ValorEnClave_VarGlob("wl_sage50", true);  //Necesario, en la otra sobrecarga si que se asigna a true y debe ser true para sage50

                        //RegisterTypesDependencyInjector();
                        //DependencyInjector.Instance.RegisterTypes(RegisterType.All, true);

                        // Rellenar el diccionario _Modulos con información sobre los módulos instalados(suscripción) .
                        if (!LICENCIAS._CargarDiccionarioModulos())
                        {
                            _ErrorString = "No se ha podido cargar el diccionario de módulos.";
                        }
                        
                        EW_GLOBAL._Empresa = new Empresa(Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa")));  //Bug 114208: Faltaba inicializar el objeto empresa
                    }
                }
            }

            if (!lbValidar)
            {
                //Borrem l'string de conexió a BD
                DB.Conexion = "";
                //Missatge d'error
                if (tlMuestraErrores)
                {
                    string lcError = _ErrorString;
                    if (string.IsNullOrWhiteSpace(lcError))
                        lcError = "Error realizando conexión a base de datos.";
                    MessageBox.Show(lcError, "Conexión a "+ lcNameProd, MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
                }
            }
            else
            {
                // TODO. Que fer amb els estils?
                EW_GLOBAL._CodiPerfilCarregat = ".predet";
            }

            return lbValidar;
        }

        // Task 108063
        public static void _Show()
        {
            Forms.frmPrincipal loForm = new Forms.frmPrincipal(true);
            loForm.WindowState = FormWindowState.Maximized;   // Presentaremos la pantalla maximizada
            loForm.Icon = sage.ew.images.Properties.Resources.Sage50code;            
            loForm.ShowDialog();
        }
        // FTask 108063

        public static void RegisterTypesDependencyInjector()
        {
            //Registramos las dependencias
            RegisterTypesSage50 registerTypesSage50 = new RegisterTypesSage50();
            registerTypesSage50.RegisterTypes();
        }

        private static string ObtenerEmpresa(string tcEmpresa)
        {
            string lcEmpresa = "";

            if (string.IsNullOrEmpty(tcEmpresa))
                lcEmpresa = FUNCTIONS.LeerConfigIni("[EMPRESA]");
            else
                lcEmpresa = tcEmpresa;

            string lcEmpNew = FUNCTIONS._ExisteEmpresa(lcEmpresa);
            if (string.IsNullOrWhiteSpace(lcEmpresa) || lcEmpresa != lcEmpNew)
                FUNCTIONS._GuardarConfigIni("[EMPRESA]", lcEmpNew, _cPathInicio, "config.ini");

            return lcEmpNew;
        }
    }
}