GrupoempTools.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Data;
using System.Data.Sql;
using System.Data.SqlClient;
using System.IO;
using System.Xml;
using System.Data.Odbc;
using System.ComponentModel;
using System.Text.RegularExpressions;

namespace sage.ew.db
{
    public static class GrupoempTools
    {
        #region PROPIEDADES PUBLICAS

        public static string _Euroserv = "";

        public static int _LenCuenta = 8;

        public static int _LenMarca = 2;

        public static int _LenFamilia = 2;

        public static int _LenVendedor = 2;

        public static int _LenAlmacen = 2; // Bug 109147

        public static string _PrefijoDeudor3 = "440";

        public static string _PrefijoCli3 = "430";

        public static string _PrefijoPro3 = "400";

        public static string _PrefijoAcr3 = "410"; 

        public static string _PrefijoBan3 = "572";


        public static string _PrefijoCaj3 = "570";

        public static string _PrefijoCom3 = "600";

        public static string _PrefijoVen3 = "700"; 
        
        public static string _Error_Message = "";

        public static bool _Log = true;

        public static string _RutaFicheroLog = "";
        
        public static string _GrupoPrincipal = "";

        public static string _GrupoOrigen = "";

        public static string _DbComunesGrOrigen = "";
        
        public static string _DbEjerGrOrigen = "";

        public static DataTable _dtBdAddonsGrOrigen = new DataTable();

        public static string _CarpetaBackupServidorSql = "";    

        public static string _DbComunesGrNuevo = "";

        public static string _DbEjerGrNuevo = "";

        public static DataTable _dtBdAddonsGrNuevo = new DataTable();

        public static string _UserPropBdGrNuevo = "Sage50";

        public static string _EmpresaGrNuevo = "";

        public static string _NombreEmpresa = "";

        public static string _CifEmpresa = "";

        
        public static bool _CfgEjerPartiGrNuevo = false;

        public static string _EjerOrigen = "";

        public static string _EjerNuevo= "";


        public static bool _EjerNuevoMarcarPredet = false;

        public static DateTime? _FechaIniEjerOrigen = null;

        public static DateTime? _FechaFinEjerOrigen = null;


        public static DateTime? _FechaIniEjerNuevo = null;

        public static DateTime? _FechaFinEjerNuevo = null;

        public static string _SufiBdEjerGrNuevo = "";


        public static bool _ConservarClientes = false;

        public static bool _LongitudesEstandar = false;


        public static bool _ConservarUsuarios = false;

        public static string _DbComunesGrBorrar = "";

        public static DataTable _dtBdEjerGrBorrar = new DataTable();

        public static DataTable _dtBdAddonsGrBorrar = new DataTable();

        

        // PROPIEDADES PROPIAS DE LA CREACION DE NUEVO EJERCICIO A PARTIR DE OTRO EJERCICIO
        
        
        public static bool _ConservarArticulos = false;


        public static bool _ConservarProveedores = false;

        public enum TipoOperativaCreacion 
        { 
            PorCopiaRestauracionBd,

            PorTablas 
        };

        public static TipoOperativaCreacion _TipoOperativaCreacionGrupoEjer = TipoOperativaCreacion.PorCopiaRestauracionBd;

        public static BackgroundWorker _Worker = null;

        public static int _TotalPasosProgreso = 0;

        public static int _PasoProgreso = 0;
        
        public static string _CrearGrupoP = "";

        #endregion PROPIEDADES PUBLICAS

        #region PROPIEDADES PRIVADAS

        private static string[,] _CuentasCd = new string[,] { 
                                                { "12900001","PÉRDIDAS Y GANANCIAS","N","","",""} ,
                                                { "30000001","EXISTENCIAS DE MERCADERÍAS","N","","",""}  ,
                                                { "40000001","PROVEEDOR","N","","",""}  ,
                                                { "40600001","ENVASES A DEVOLVER A PROVEEDORES","N","","",""}  ,
                                                { "40700001","ANTICIPOS A PROVEEDORES","N","","",""}  ,
                                                { "41000001","ACREEDOR","N","","",""}  ,
                                                { "41400000","VALES","N","","",""},
                                                { "43000001","CLIENTE CONTADO","","","",""}  ,
                                                { "43600001","CLIENTES DE DUDOSO COBRO","","","",""}  ,
                                                { "43700001","ENVASES A  DEVOLVER POR CLIENTES","","000","",""}  ,
                                                { "43800001","ANTICIPOS CLIENTES","","000","",""}  ,
                                                { "44000001","DEUDOR","N","","",""}  ,
                                                { "46000000","ANTICIPOS DE REMUNERACIONES","N","","",""}  ,
                                                { "46500001","REMUNERACIONES PENDIENTES DE PAGO","N","","",""}  ,
                                                { "47000001","HACIENDA PÚBLICA DEUDORA POR CONCEPTOS FISCALES","N","","",""}  ,
                                                { "47200000","IVA SOPORTADO 0%","N","","",""}  ,
                                                { "47200001","IVA SOPORTADO","N","","",""}  ,
                                                { "47200002","RECARGO SOPORTADO","N","","",""}  ,
                                                { "47200004","IVA SOPORTADO 4%","N","","",""}  ,
                                                { "47200010","IVA SOPORTADO 10%","N","","",""}  ,
                                                { "47200011","IVA SOPORTADO 4% CEE","N","","",""}  ,
                                                { "47200012","IVA SOPORTADO 10% CEE","N","","",""}  ,
                                                { "47200013","IVA SOPORTADO 21% CEE","","000","",""}  ,
                                                { "47200020","RECARGO SOPORTADO 0%","N","","",""}  ,
                                                { "47200021","IVA SOPORTADO 21%","N","","",""}  ,
                                                { "47200024","RECARGO SOPORTADO 0.5%","N","","",""}  ,
                                                { "47200026","RECARGO SOPORTADO 5.2%","N","","",""}  ,
                                                { "47200027","RECARGO SOPORTADO 1.4%","N","","",""}  ,
                                                { "47200098","RECARGO SOPORTADO CRITERIO DE CAJA","N","","",""}  ,
                                                { "47200099","IVA SOPORTADO CRITERIO DE CAJA","N","","",""}  ,
                                                { "47200100","IVA SOPORTADO NO DEDUCIBLE (PRORRATA)","N","","",""}  ,
                                                { "47200101","IVA SOPORTADO NO DEDUCIBLE PENDIENTE DEVENGO (PRORRATA)","N","","",""}  ,
                                                { "47200104","04%  INVERSIÓN SUJETO PASIVO SOPORTADA","N","","",""}  ,
                                                { "47200110","10%  INVERSIÓN SUJETO PASIVO SOPORTADA","N","","",""}  ,
                                                { "47200121","21%  INVERSIÓN SUJETO PASIVO SOPORTADA","N","","",""}  ,
                                                { "47300001","HACIENDA PÚBLICA RETENCIONES Y PAGOS A CUENTA","N","","",""}  ,
                                                { "47500001","HACIENDA PÚBLICA ACREEDORA POR CONCEPTOS FISCALES","N","","",""}  ,
                                                { "47510001","H. PÚBLICA ACREEDOR POR RETENCIONES PRACTICADAS","N","","",""}  ,
                                                { "47700000","IVA REPERCUTIDO 0%","N","","",""}  ,
                                                { "47700001","IVA REPERCUTIDO","N","","",""}  ,
                                                { "47700002","RECARGO REPERCUTIDO","N","","",""}  ,
                                                { "47700004","IVA REPERCUTIDO 4%","N","","",""}  ,
                                                { "47700010","IVA REPERCUTIDO 10%","N","","",""}  ,
                                                { "47700011","IVA REPERCUTIDO 4% CEE","N","","",""}  ,
                                                { "47700012","IVA REPERCUTIDO 10% CEE","","","",""}  ,
                                                { "47700013","IVA REPERCUTIDO 21% CEE","","000","",""}  ,
                                                { "47700020","RECARGO REPERCUTIDO 0%","N","","",""}  ,
                                                { "47700021","IVA REPERCUTIDO 21%","N","","",""}  ,
                                                { "47700024","RECARGO REPERCUTIDO 0.5%","N","","",""}  ,
                                                { "47700026","RECARGO REPERCUTIDO 5.2%","N","","",""}  ,
                                                { "47700027","RECARGO REPERCUTIDO 1.4%","N","","",""}  ,
                                                { "47700098","RECARGO REPERCUTIDO CRITERIO DE CAJA","N","","",""}  ,
                                                { "47700099","IVA REPERCUTIDO CRITERIO DE CAJA","N","","",""}  ,
                                                { "47700104","04%  INVERSIÓN SUJETO PASIVO REPERCUTIDA","N","","",""}  ,
                                                { "47700110","10%  INVERSIÓN SUJETO PASIVO REPERCUTIDA","N","","",""}  ,
                                                { "47700121","21%  INVERSIÓN SUJETO PASIVO REPERCUTIDA","N","","",""}  ,
                                                { "52080001","DEUDAS POR EFECTOS DESCONTADOS","N","000","",""}  ,
                                                { "55500000","CUENTA PUENTE COBRO","N","000","",""}  ,
                                                { "55500001","CUENTA PUENTE PAGO","N","000","",""}  ,
                                                { "55500002","CUENTA PUENTE REPOSICION/RETIRADA","N","000","",""}  ,
                                                { "55509999","PARTIDAS PENDIENTES DE APLICACIÓN","N","000","",""}  ,   //Bug 138950
                                                { "56100000","DEPÓSITOS RECIBIDOS A CORTO PLAZO","N","000","",""}  ,   //Bug 138950
                                                { "57000000","CONTADO","N","000","",""}  ,
                                                { "57000001","CAJA EFECTIVO","N","000","",""}  ,
                                                { "57200000","TARJETAS","N","000","",""}  ,
                                                { "57200001","BANCOS","N","000","",""}  ,
                                                { "57300001","BANCO MONEDA EXTRANJERA","N","000","",""}  ,
                                                { "60000001","COMPRAS DE MERCADERÍAS","N","","02","G01"}  ,
                                                { "60000100","DESCUENTOS S/COMPRA POR PRONTO PAGO","","000","02","G01"}  ,
                                                { "60300001","COMPRAS PENDIENTES DE FACTURAR","","000","",""}  ,
                                                { "60500001","PORTES COMPRA","N","","",""}  ,
                                                { "60600000","DESCUENTO SOBRE COMPRAS POR PRONTO PAGO","N","000","",""}  ,    // Bug 173592
                                                { "60800000","DEVOLUCIONES DE COMPRAS","N","","",""}  ,                       // Bug 173592
                                                { "60900000","RAPPELS POR COMPRAS","N","000","",""}  ,                        // Bug 173592
                                                { "61000001","VARIACIÓN DE EXISTENCIAS DE MERCADERÍAS","N","","02","G02"}  ,
                                                { "62600000","GASTOS BANCARIOS","N","","08","G22"}  ,
                                                { "62600001","GASTOS IMPAGO","N","","08","G22"}  ,
                                                { "63100001","CANCELACIÓN IVA NO DEDUCIBLE","N","","10","G26"}  ,
                                                { "63410000","AJUSTES NEGATIVOS EN EL IVA DE ACTIVO CORRIENTE (PRORRATA)","N","","",""}  ,
                                                { "63420000","AJUSTES NEGATIVOS EN EL IVA DE INVERSIONES (PRORRATA)","N","","",""}  ,
                                                { "63910000","AJUSTES POSITIVOS EN EL IVA DE ACTIVO CORRIENTE (PRORRATA)","N","","",""}  ,
                                                { "63920000","AJUSTES POSITIVOS EN EL IVA DE INVERSIONES (PRORRATA)","N","","",""}  ,
                                                { "64000000","SUELDOS Y SALARIOS","N","","",""}  ,    // Bug 173592
                                                { "66800001","DIFERENCIAS NEGATIVAS DE CAMBIO","N","","",""}  ,
                                                { "70000001","VENTAS DE MERCADERÍAS","N","","18","I01"}  ,
                                                { "70000100","DESCUENTO S/VENTAS PRONTO PAGO","","000","18","I01"}  ,
                                                { "70500001","PORTES VENTA","N","","18","I01"}  ,
                                                { "70600000","DESCUENTO SOBRE VENTAS POR PRONTO PAGO","N","000","",""}  ,    // Bug 173592
                                                { "70800000","DEVOLUCIONES DE VENTAS","N","","",""}  ,                       // Bug 173592
                                                { "70900000","RAPPELS POR VENTAS","N","","",""}  ,                           // Bug 173592
                                                { "70700001","VENTAS PENDIENTES DE FACTURAR/CONTABILIZAR","","000","",""}  ,
                                                { "76800001","DIFERENCIAS POSITIVAS DE CAMBIO","N","","",""}  ,
                                                { "76900001","RECARGO FINANCIERO","N","","19","I07"}  ,
                                                { "76900002","INGRESOS POR REPERCUSIÓN DE GASTOS DE DEVOLUCIÓN","N","000","19","I07"},     //Bug 142346
                                                { "80000001","GASTOS IMPUTADOS A PATRIMONIO NETO","N","000","",""},     //Task 148839
                                                { "90000001","INGRESOS IMPUTADOS A PATRIMONIO NETO","N","000","",""}    //Task 148839
                                                };


        private static List<string> _AddonsInstal = new List<string>() { "TPV", "LOTES", "AMORTIZA", "MAYORIST", "INFORAUT" };

        private static StringBuilder _cCadenaLog = new StringBuilder();

        private static Dictionary<string, string> _oAliasDBCopia = new Dictionary<string, string>();

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

        public static Dictionary<string, DB._TableInformationSchema> _dicCacheSchemaCopia = new Dictionary<string, DB._TableInformationSchema>();

        private static Dictionary<string, bool> _oAddonsOrigen = new Dictionary<string, bool>();

        #endregion PROPIEDADES PRIVADAS

        #region METODOS PÚBLICOS

        // PE-104958.
        public static DataTable ObtenerTodosLosGrupos()
        {            
            DataTable ldtGrupos = new DataTable();
            string lcSql = "Select codigo, nombre From [EUROWINSYS].[dbo].[gruposemp]";
            DB.SQLExec(lcSql, ref ldtGrupos);

            return ldtGrupos;
        }

        // Task 151247. Sobrecarga para obtener todos los grupos del principal de grupo
        public static DataTable ObtenerTodosLosGrupos(string grupoprincipal)
        {
            DataTable ldtGrupos = new DataTable();
            string lcSql = "Select codigo, nombre From [EUROWINSYS].[dbo].[gruposemp] where codpripal = " + DB.SQLString(grupoprincipal);
            DB.SQLExec(lcSql, ref ldtGrupos);

            return ldtGrupos;
        }

        // PE-104958.
        public static string ObtenerGestionEjerciciActualGrupo(string databaseComunes)
        {
            string databaseGestion = "";

            DataTable datatableEjercici = new DataTable();
            string lcSql = "Select conexion From " + DB.SQLDatabaseReal(databaseComunes, "ejercici") + " Where [any] = " + DB.SQLString(DB._GetVariable("wc_any").ToString());

            DB.SQLExec(lcSql, ref datatableEjercici);
            if (datatableEjercici.Rows.Count > 0)
            {
                databaseGestion = datatableEjercici.Rows[0]["conexion"].ToString().Trim();
            }

            return databaseGestion;
        }

        public static string ObtenerGestionGrupo(string databaseComunes)
        {
            String lcSql = "";
            DataTable datatableEjercici = new DataTable();
            
            lcSql =  String.Format("SELECT CONEXION, PREDET,[any] FROM {0} WHERE [any] = {1} UNION  SELECT CONEXION, PREDET,[any] FROM {0} ORDER BY PREDET DESC ,[any] DESC", DB.SQLDatabaseReal(databaseComunes, "ejercici"), DB.SQLString(DB._GetVariable("wc_any").ToString()));
            DB.SQLExec(lcSql, ref datatableEjercici);

            return datatableEjercici.Rows.Count > 0 ? datatableEjercici.Rows[0]["CONEXION"].ToString().Trim() : String.Empty;
        }

        public static bool _BorrarGruposEmpXml()
        {
            bool llOk = true;
            string lcRutaServidor = Convert.ToString(DB._GetVariable("wc_iniservidor")).Trim();
            
            // Si no tenemos ruta al servidor no hacemos nada.
            if (!string.IsNullOrWhiteSpace(lcRutaServidor))
            {
                string lcFicheroXmlGrupos = Path.Combine(lcRutaServidor, "gruposemp.xml");
                if (System.IO.File.Exists(lcFicheroXmlGrupos))
                {
                    System.IO.File.Delete(lcFicheroXmlGrupos);
                    // Si despuésde borrar aún existe, devolvemos false.
                    if (System.IO.File.Exists(lcFicheroXmlGrupos))
                        llOk = false;
                }
            }

            return llOk;
        }

        public static string _Obtener_CodGrupoPripal(string tcGrupo)
        {
            string lcCodGrupoPripal = "";

            lcCodGrupoPripal = Convert.ToString(DB.SQLValor("gruposemp", "codigo", tcGrupo, "codpripal", "eurowinsys"));

            return lcCodGrupoPripal;
        }

        public static string _Obtener_NombreGrupo(string tcGrupo)
        {
            string lcNombreGrupo = "";

            lcNombreGrupo = Convert.ToString(DB.SQLValor("gruposemp", "codigo", tcGrupo, "nombre", "eurowinsys")).Trim();

            return lcNombreGrupo;
        }


        public static string _Obtener_CodigoGrupo_Inexistente()
        {
            string lcCodGrupo = "";
            string lcNewDbComunes = "";
            DataTable ldtAuxiliar = new DataTable();

            // Si no hay conexión a una instancia de servidor SQL no hay nada que averiguar.
            _Error_Message = "";
            if ( string.IsNullOrWhiteSpace(DB.Conexion) || string.IsNullOrWhiteSpace(DB.DbComunes) )
            {
                _Error_Message = "No se ha podido obtener un código de nuevo grupo, no se ha detectado conexión al servidor SQL.";
                return "";
            }

            
            // Obtener nombre de nueva base de datos COMUNES inexistente en el servidor SQL (revisa COMU0001, COMU0002, COMU0003 ... 
            // y así hasta que encuentra un código desocupado.)
            lcNewDbComunes = DB._Obtener_NuevaDb_Comunes("COMU", 8);
            if (string.IsNullOrWhiteSpace(lcNewDbComunes))
            {
                _Error_Message = "No se ha podido obtener un código de nuevo grupo, no se pudo obtener el nombre para una nueva base de datos de COMUNES.";
                return "";
            }


            // Revisar que el código obtenido tenga el formato correcto.
            if (!string.IsNullOrWhiteSpace(lcNewDbComunes) && lcNewDbComunes.Length == 8)
                lcCodGrupo = lcNewDbComunes.Substring(4,4);
            if (string.IsNullOrWhiteSpace(lcCodGrupo))
            {
                _Error_Message = "No se ha podido obtener un código de nuevo grupo, formato incorrecto para el nombre de la nueva base de datos de COMUENES.";
                return "";
            }

            // El código de grupo detectado no existe como base de datos, no debería existir por tanto tampoco en la tabla de grupos, si existe lo borramos
            // pues podria provocar problemas desde visual al intentar crear un nuevo grupo pero ya existiese en la tabla de grupos
            DB.SQLExec("select codigo from " + DB.SQLDatabase("eurowinsys", "gruposemp") + " where codigo='" + lcCodGrupo + "'", ref ldtAuxiliar);
            if (ldtAuxiliar.Rows.Count > 0 && Convert.ToString(ldtAuxiliar.Rows[0]["codigo"]) == lcCodGrupo)
                DB.SQLExec("delete from " + DB.SQLDatabase("eurowinsys", "gruposemp") + " where codigo='" + lcCodGrupo + "'");


            return lcCodGrupo;
        }


        public static string _Obtener_RutaLog_Automatica(string tcCodigo, int tnTipo)
        {
            string lcRutaLog = GrupoempTools._Euroserv.Trim();
            if (string.IsNullOrWhiteSpace(lcRutaLog))
                lcRutaLog = Path.GetTempPath();

            if (!lcRutaLog.EndsWith("\\"))
                lcRutaLog += "\\";

            string lcFecha = DateTime.Now.Date.ToString("yyyyMMdd");
            string lcHora = DateTime.Now.ToLongTimeString().Replace(":", "");

            lcRutaLog += (tnTipo == 1 ? "log_creagremp_" : (tnTipo == 2 ? "log_borragremp_" : "log_creaejer_")) + tcCodigo + "_" + lcFecha + "_" + lcHora + ".txt";

            return lcRutaLog;
        }

        
        public static int _Obtener_Numero_Grupos(out string tcGrupoActual, out string tcGrupoPripal, out List<string> tlsGrupos)
        {
            tlsGrupos = new List<string>();
            tcGrupoActual = "";
            tcGrupoPripal = "";

            // Si no hay conexión a una instancia de servidor SQL no hay nada que averiguar.
            _Error_Message = "";
            if (string.IsNullOrWhiteSpace(DB.Conexion) || string.IsNullOrWhiteSpace(DB.DbComunes))
            {
                _Error_Message = "No se ha podido obtener el número de grupos existentes, no se ha detectado conexión al servidor SQL.";
                tcGrupoActual = "";
                tcGrupoPripal = "";
                return 0;
            }

            // Partimos del COMUNES al que estamos conectados.
            string lcComunesActual = DB.DbComunes;
            DataTable ldtAuxiliar = new DataTable();


            // Averiguar el codigo de grupo origen correspondiente al grupo en el que estoy conectado (podría ser el mismo grupo)
            tcGrupoActual = DB.DbComunes.Trim().Substring(4, 4);
            DB.SQLExec("select codpripal from " + DB.SQLDatabase("eurowinsys", "gruposemp") + " where codigo='" + tcGrupoActual + "'", ref ldtAuxiliar);
            if (ldtAuxiliar.Rows.Count == 0)
            {
                _Error_Message = "No se ha podido obtener el número de grupos existentes, no se ha encontrado el grupo actual " + tcGrupoActual + " en la tabla de grupos.";
                return 0;
            }
            
            tcGrupoPripal = Convert.ToString(ldtAuxiliar.Rows[0]["codpripal"]);
            if (string.IsNullOrWhiteSpace(tcGrupoPripal))
            {
                _Error_Message = "No se ha podido obtener el número de grupos existentes, no se ha podido averiguar el código de grupo principal correspondiente al grupo actual " + tcGrupoActual + " en la tabla de grupos.";
                return 0;            
            }


            // Cuento cuantos grupos cuelgan de este grupo origen
            DB.SQLExec("select codigo from " + DB.SQLDatabase("eurowinsys", "gruposemp") + " where codpripal='" + tcGrupoPripal + "'", ref ldtAuxiliar);
            if (ldtAuxiliar.Rows.Count == 0)
            {
                _Error_Message = "No se ha podido obtener el número de grupos existentes, se han detectado 0 grupos asociados al grupo origen " + tcGrupoPripal + " en la tabla de grupos.";

                return 0;
            }


            // Bug 157079 - Comprobar que exista el comunes correspondiente
            foreach (DataRow dtRow in ldtAuxiliar.Rows)
            {
                string lcCodigo = Convert.ToString(dtRow["codigo"]).Trim().ToUpper();
                if (DB._SQLExisteBBDD("COMU" + lcCodigo))
                    tlsGrupos.Add(lcCodigo);
            }


            int lnCuantosGrupos = tlsGrupos.Count;
            if (lnCuantosGrupos == 1)
            {
                if (tcGrupoActual != tcGrupoPripal)
                {
                    _Error_Message = "No se ha podido obtener el número de grupos existentes, se han detectado incoherencia en los datos de la tabla de grupos: " +
                                     "Se ha detectado un solo grupo en la instalación actual pero con diferente codificación para el grupo actual " + tcGrupoActual + " " +
                                     "y el grupo origen " + tcGrupoPripal;
                    return 0;
                }
            }

            //tlsGrupos = ldtAuxiliar.AsEnumerable().Select(x => x[0].ToString().ToUpper()).ToList();

            return lnCuantosGrupos;
        }


        public static bool _Crear_Ejercicio(string tcGrupoOrigen, string tcEjerOrigen, string tcEjerNuevo, DateTime tdFIniEjerNuevo, DateTime tdFFinEjerNuevo, bool tlMarcarEjerPredet = false)
        {
            bool llOk = false;


            // Inicializamos la cadena de log, tanto si logueamos como si no.
            GrupoempTools._cCadenaLog = new StringBuilder();

            // Si se ha de loguear y no han declarado el fichero de log lo ponemos automático.
            if (_Log)
            {
                if (string.IsNullOrWhiteSpace(_RutaFicheroLog))
                    _RutaFicheroLog = GrupoempTools._Obtener_RutaLog_Automatica(tcEjerNuevo, 3);
            }




            // Comprobar que los parámetros llegan tal como se espera.
            Dictionary<string, object> lodDicParam = new Dictionary<string, object>();
            lodDicParam.Add("tcgrupoorigen", tcGrupoOrigen);
            lodDicParam.Add("tcejerorigen", tcEjerOrigen);
            lodDicParam.Add("tcejernuevo", tcEjerNuevo);
            lodDicParam.Add("tdfiniejernuevo", tdFIniEjerNuevo);
            lodDicParam.Add("tdffinejernuevo", tdFFinEjerNuevo);
            llOk = GrupoempTools.CrearEjercicio_Comprobar_Parametros(lodDicParam);
            if (!llOk)
            {
                if (_Log)
                {
                    Guardar_Mensaje("Paso incorrecto de parametros al método _Crear_Ejercicio()");
                    GrupoempTools.CopiarStringLog_Fichero(_RutaFicheroLog);
                }
                return false;
            }


            // Inicializa propiedades internas. 
            // La propiedad _Log no se inicializa, se selecciona externamente a la llamada a _Crear_Ejercicio()
            GrupoempTools._ResetearPropiedades();




            if (_Log)
                Guardar_Mensaje("CREACIÓN DE NUEVO EJERCICIO " + tcEjerNuevo + " EN GRUPO " + tcGrupoOrigen + " A PARTIR DE EJERCICIO " + tcEjerOrigen + Environment.NewLine);

            // Obtener todos los datos que nos hacen falta para poder hacer el BACKUP y el RESTORE posterior de la bd de ejercicio, y comprobar que todo esté correcto, que la nueva bd. no existe, que la bd origen sí exista, que el ejercicio origen exista, etc.
            llOk = GrupoempTools.CrearEjercicio_Comprobaciones_Previas(tcGrupoOrigen, tcEjerOrigen, tcEjerNuevo);
            if (!llOk)
            {
                if (_Log)
                    CopiarStringLog_Fichero(_RutaFicheroLog);
                return false;
            }

            // Aqui tenemos informado:
            // GrupoempTools._GrupoOrigen
            // GrupoempTools._DbComunesGrOrigen
            // GrupoempTools._DbEjerGrOrigen
            // GrupoempTools._SufiBdEjerGrNuevo 
            // GrupoempTools._DbEjerGrNuevo 
            // GrupoempTools._EmpresaGrNuevo;
            // GrupoempTools._UserPropBdGrNuevo
            GrupoempTools._EjerOrigen = tcEjerOrigen;
            GrupoempTools._EjerNuevo = tcEjerNuevo;
            GrupoempTools._FechaIniEjerNuevo = tdFIniEjerNuevo;
            GrupoempTools._FechaFinEjerNuevo = tdFFinEjerNuevo;
            GrupoempTools._EjerNuevoMarcarPredet = tlMarcarEjerPredet;  // El ejercicio que se crea quedará marcado como predeterminado en COMUNES!EJERCICI según lo que haya pasado por parámetro el usuario 




            // Via libre para crear el ejercicio, coger la base de datos del EJERCICIO que se ha pedido del grupo origen, hacer copia de seguridad de ella
            // y restaurarla con el nuevo nombre, luego ya vaciaremos todas las tablas menos las de sistema (COMUNES.TABSYS) 
            // y se haran los ajustes adicionales necesarios en las otras tablas en que sea necesario hacer algo.



            // ATENCION!! ATENCION !!
            // Si la operativa de BACKUP-RESTORE fuese lento se puede probar el segundo sistema que es creando la base de datos directamente y 
            // creando los indices y valores por defecto manualmente, tabla por tabla, para ello antes de realizar la llamada a _Crear_Ejercicio()
            // deberá ponerse la propiedad siguiente
            // 
            // GrupoempTools._TipoOperativaCreacionGrupoEjer = GrupoempTools.TipoOperativaCreacion.PorTablas;


            if (GrupoempTools._TipoOperativaCreacionGrupoEjer == GrupoempTools.TipoOperativaCreacion.PorCopiaRestauracionBd)
            {
                llOk = GrupoempTools.CrearEjercicio_BackupBd();
                if (!llOk)
                {
                    if (_Log)
                        CopiarStringLog_Fichero(_RutaFicheroLog);
                    return false;
                }


                llOk = GrupoempTools.CrearEjercicio_RestoreBd();
                if (!llOk)
                {
                    // Algo no fue bien, en teoria aqui deberiamos borrar la base de datos que se pudiera haber creado pero no vamos a hacerlo para evitar
                    // el riesgo de que accidentalmente por algún bug o por el motivo que sea se acabe borrando una base de datos que no toque.
                    if (_Log)
                        CopiarStringLog_Fichero(_RutaFicheroLog);
                    return false;
                }
            }
            else
            {
                llOk = GrupoempTools.CrearEjercicio_CrearBd();
                if (!llOk)
                {
                    if (_Log)
                        CopiarStringLog_Fichero(_RutaFicheroLog);
                    return false;
                }


                llOk = GrupoempTools.CrearEjercicio_CrearTablasBd();
                if (!llOk)
                {
                    if (_Log)
                        CopiarStringLog_Fichero(_RutaFicheroLog);
                    return false;
                }
            }


            llOk = GrupoempTools.CrearEjercicio_AjustarDatosBd();
            if (!llOk)
            {
                // Algo no fue bien, en teoria aqui deberiamos borrar la base de datos que se pudiera haber creado pero no vamos a hacerlo para evitar
                // el riesgo de que accidentalmente por algún bug o por el motivo que sea se acabe borrando una base de datos que no toque.
                if (_Log)
                    CopiarStringLog_Fichero(_RutaFicheroLog);
                return false;
            }


            // Proceso concluido, informamos de las bds. creadas.
            if (_Log)
            {
                Guardar_Mensaje("PROCESO DE CREACIÓN DE EJERCICIO " + tcEjerNuevo + " FINALIZADO." + Environment.NewLine);

                Guardar_Mensaje("Se ha creado la siguiente bases de datos:");
                Guardar_Mensaje("GESTION: " + GrupoempTools._DbEjerGrNuevo);

                CopiarStringLog_Fichero(_RutaFicheroLog);
            }

            return true;

        }


        public static bool _Crear_Grupo(string tcGrupo, string tcNombreGrupo, string tcEjercicio, string tcNombreEmpresa, string tcCifEmpresa, string tcGrOrigen="", bool tlConservarClientes=false, 
                                    bool tlConservarUsuarios=false, bool tlEjerPartido=false, DateTime? tdEjerPartiFIni = null, DateTime? tdEjerPartiFFin = null, bool tlLongitudesEstandar=false)
        {
            bool llOk=false;

            ActualizarBarraProgreso();

            // Inicializamos la cadena de log, tanto si logueamos como no.
            GrupoempTools._cCadenaLog = new StringBuilder();

            // Si se ha de loguear pero no tenemos la ruta al fichero de log instanciada la asignamos automaticamente, apuntará a un txt en EUROSERV\
            if (_Log)
            {            
                if (string.IsNullOrWhiteSpace(_RutaFicheroLog))
                    _RutaFicheroLog = GrupoempTools._Obtener_RutaLog_Automatica(tcGrupo, 1);
            }
 
            // Comprobar que los parámetros llegan tal como se espera.
            Dictionary<string,object> lodDicParam = new Dictionary<string,object>();
            lodDicParam.Add("tcgrupo",tcGrupo);
            lodDicParam.Add("tcnombregrupo",tcNombreGrupo); 
            lodDicParam.Add("tcejercicio",tcEjercicio);
            lodDicParam.Add("tcnombreempresa",tcNombreEmpresa);
            lodDicParam.Add("tccifempresa",tcCifEmpresa);
            lodDicParam.Add("tcgrorigen",tcGrOrigen);
            lodDicParam.Add("tlconservarclientes", tlConservarClientes);
            lodDicParam.Add("tlconservarusuarios", tlConservarUsuarios);
            lodDicParam.Add("tlejerpartido",tlEjerPartido);
            lodDicParam.Add("tdejerpartifini",tdEjerPartiFIni);
            lodDicParam.Add("tdejerpartiffin",tdEjerPartiFFin);
            lodDicParam.Add("tlLongitudesEstandar", tlLongitudesEstandar);

            llOk = CrearGrupo_Comprobar_Parametros(lodDicParam);
            if (!llOk)
            {
                if (_Log)
                {
                    Guardar_Mensaje("Paso incorrecto de parametros al método _Crear_Grupo()");
                    GrupoempTools.CopiarStringLog_Fichero(_RutaFicheroLog);
                }
                return false;
            }


            // Inicializa propiedades internas, las unicas propiedades que no se inicializan son:
            // _Log: si se ha de loguear el proceso.
            // _RutaFicheroLog: ruta al fichero de log
            // _Euroserv: carpeta de Euroserv de la instalación, es necesario por que al acabar la creacion se actualiza CFGCLISRV.XML en esta carpeta
            // _TipoOperativaCreaGrupoEjer
            GrupoempTools._ResetearPropiedades();


            if (_Log)
                Guardar_Mensaje("CREACION DE NUEVO GRUPO: " + tcGrupo + Environment.NewLine);


            // Asignar las propiedades internas que se pueda con los parámetros recibidos.
            GrupoempTools.CrearGrupo_AsignarPropiedades(lodDicParam);

            // Realizar todas las comprobaciones necesarias para evitar conflictos durante la creación del grupo, no existencia de las bases de datos que se van a crear, existencia de la tabla TABSYS donde toca con datos, etc.
            // Recordar que en el nuevo grupo solo van los ADDONS standar que se instalan en Sage50 
            // (TPV, LOTES, MAYORIST, INFORAUT y AMORTIZA), si tuviese algun ADDON mas no lo tendrá el nuevo grupo.
            llOk = GrupoempTools.CrearGrupo_Comprobaciones_Previas(tcGrupo, tcGrOrigen);
            if (!llOk)
            {
                if (_Log)
                    GrupoempTools.CopiarStringLog_Fichero(_RutaFicheroLog);
                return false;
            }
            ActualizarBarraProgreso();


            // Via libre para crear el grupo, coger la base de datos de COMUNES, ADDONS y EJERCICIO predet
            // del grupo origen detectado, hacer copia de seguridad de ellas y restaurarlas con el nuevo nombre, 
            // y luego ya vaciaremos todas las tablas menos las de sistema (COMUNES.TABSYS y ADDONS.TABSYS) 
            // y se haran los ajustes adicionales necesarios en las otras tablas en que sea necesario hacer algo.



            // ATENCION!! ATENCION !!
            // Si la operativa de BACKUP-RESTORE fuese lento se puede probar el segundo sistema que es creando las bases de datos directamente y 
            // creando los indices y valores por defecto manualmente, tabla por tabla, para ello antes de realizar la llamada a _Crear_Grupo()
            // deberá ponerse la propiedad siguiente
            // 
            // GrupoempTools._TipoOperativaCreacionGrupoEjer = GrupoempTools.TipoOperativaCreacion.PorTablas;


            if (GrupoempTools._TipoOperativaCreacionGrupoEjer == GrupoempTools.TipoOperativaCreacion.PorCopiaRestauracionBd)
            {
                llOk = GrupoempTools.CrearGrupo_BackupsBds();
                if (!llOk)
                {
                    if (_Log)
                        GrupoempTools.CopiarStringLog_Fichero(_RutaFicheroLog);
                    return false;
                }
                ActualizarBarraProgreso();

                llOk = GrupoempTools.CrearGrupo_RestoreBds();
                if (!llOk)
                {
                    // Algo no fue bien, en teoria aqui deberiamos borras las bases de datos que se pudieran haber creado del nuevo grupo pero no vamos a hacerlo para evitar
                    // el riesgo de que accidentalmente por algún bug o por el motivo que sea se acabe borrando una base de datos que no toque, si se quisiese asumir este riesgo
                    // poner aqui antes del return false una llamada a  GrupoempTools.CrearGrupo_BorrarBdsNuevas()
                    if (_Log)
                        GrupoempTools.CopiarStringLog_Fichero(_RutaFicheroLog);
                    return false;
                }
                ActualizarBarraProgreso();
            }
            else
            {


                llOk = GrupoempTools.CrearGrupo_CrearBds();
                if (!llOk)
                {
                    // Algo no fue bien, en teoria aqui deberiamos borras las bases de datos que se pudieran haber creado del nuevo grupo pero no vamos a hacerlo para evitar
                    // el riesgo de que accidentalmente por algún bug o por el motivo que sea se acabe borrando una base de datos que no toque.
                    if (_Log)
                        GrupoempTools.CopiarStringLog_Fichero(_RutaFicheroLog);
                    return false;
                }
                ActualizarBarraProgreso();

                llOk = GrupoempTools.CrearGrupo_CrearTablasBds();
                if (!llOk)
                {
                    // Algo no fue bien, en teoria aqui deberiamos borras las bases de datos que se pudieran haber creado del nuevo grupo pero no vamos a hacerlo para evitar
                    // el riesgo de que accidentalmente por algún bug o por el motivo que sea se acabe borrando una base de datos que no toque.
                    if (_Log)
                        GrupoempTools.CopiarStringLog_Fichero(_RutaFicheroLog);
                    return false;
                }
                ActualizarBarraProgreso();
            }            

            llOk = GrupoempTools.CrearGrupo_AjustarDatosBds();
            if (!llOk)
            {
                // Algo no fue bien, en teoria aqui deberiamos borras las bases de datos que se pudieran haber creado del nuevo grupo pero no vamos a hacerlo para evitar
                // el riesgo de que accidentalmente por algún bug o por el motivo que sea se acabe borrando una base de datos que no toque, si se quisiese asumir este riesgo
                // poner aqui antes del return false una llamada a  GrupoempTools.CrearGrupo_BorrarBdsNuevas()
                if (_Log)
                    GrupoempTools.CopiarStringLog_Fichero(_RutaFicheroLog);
                return false;
            }
            ActualizarBarraProgreso();



            // ACTUALIZAR EUROWINSYS.GRUPOSEMP: Buscamos si el grupo existe en la tabla de grupos y si no existe lo creamos.
            //
            // Desde Sage50 via formulario de grupos al crear un nuevo grupo en este punto existirá ya el registro en la tabla 
            // pues los mantenimientos visuales al crar un nuevo código ya lo inserta en la tabla y si al final se cancela se borra, por tanto en ese caso unicamnete 
            // UPDATAREMOS el nombre.
            //
            // En el caso de que se llame a este método desde el DTS de Contaplus/FacturaPlus el registro no existirá y deberá
            // crearse en este punto.
            if (_Log)
                Guardar_Mensaje("Actualizacion de tabla de grupos.");
            GrupoempTools.CrearGrupo_AnadirGrupo_Gruposemp(tcGrupo, tcNombreGrupo);
            if (_Log)
                Guardar_Mensaje("Actualizacion de euroserv\\gruposemp.xml.");

            

            // ACTUALIZAR EUROSERV\GRUPOSEMP.XML A PARTIR DE EUROWINSYS.GRUPOSEMP
            string lcEuroserv = GrupoempTools._Euroserv.Trim();
            DB._GrupoEmpresa_Table2Xml(Path.Combine(lcEuroserv,"gruposemp.xml"));
            


            // ACTUALIZAR EUROSERV\CFGCLISRV.XML Y EUROSERV\CFGCLISRV.DBF
            if (_Log)
                Guardar_Mensaje("Actualizacion de CFGCLISRV.");
            llOk = GrupoempTools.CrearGrupo_AnadirGrupo_CfgCliSrv();
            if (!llOk)
            {
                if (_Log)
                    GrupoempTools.CopiarStringLog_Fichero(_RutaFicheroLog);
                return false;
            }
            ActualizarBarraProgreso();

            // FIN !!


            // Proceso concluido, informamos de las bds. creadas.
            if (_Log)
            {
                Guardar_Mensaje("PROCESO DE CREACIÓN DE GRUPO "+tcGrupo+" FINALIZADO."+Environment.NewLine);
                Guardar_Mensaje("Se han creado las siguientes bases de datos:");
                Guardar_Mensaje("COMUNES: " + _DbComunesGrNuevo);
                Guardar_Mensaje("GESTION: " + _DbEjerGrNuevo);
                string lcNombreAddon = "", lcBdAddon = "";
                foreach (DataRow loRow in _dtBdAddonsGrNuevo.Rows)
                {
                    lcNombreAddon = Convert.ToString(loRow["nombre"]).Trim();
                    lcBdAddon = Convert.ToString(loRow["nom_conex"]).Trim();
                    Guardar_Mensaje("ADDON DE " + lcNombreAddon + ": " + lcBdAddon);
                }

                GrupoempTools.CopiarStringLog_Fichero(_RutaFicheroLog);
            }

            ActualizarBarraProgreso();

            return true;
        }

        public static void _ResetearPropiedades()
        {

            // Las propiedades _Log, _RutaFicheroLog y _Euroserv son las únicas que no se inicializan, 
            // se declaran externamente antes de llamar a _Crear_Grupo, _Borrar_Grupo(), _Crear_Ejercicio()
            if (_Log)
                Guardar_Mensaje("Inicializando propiedades internas.");

            // PROPIEDADES DE CREACION DE NUEVO GRUPO Y CREACION NUEVO EJERCICIO
            
            // Propiedades del grupo origen de la instalación de Sage50
            GrupoempTools._GrupoPrincipal = "";
            GrupoempTools._GrupoOrigen = "";
            GrupoempTools._DbComunesGrOrigen = "";
            GrupoempTools._DbEjerGrOrigen = "";
            GrupoempTools._dtBdAddonsGrOrigen = new DataTable();
            GrupoempTools._EjerOrigen = "";
            GrupoempTools._FechaIniEjerOrigen = null;
            GrupoempTools._FechaFinEjerOrigen = null;

            // Propiedades del nuevo grupo a crear.
            GrupoempTools._DbComunesGrNuevo = "";
            GrupoempTools._DbEjerGrNuevo = "";
            GrupoempTools._dtBdAddonsGrNuevo = new DataTable();
            GrupoempTools._SufiBdEjerGrNuevo = "";
            GrupoempTools._EjerNuevo = "";
            GrupoempTools._FechaIniEjerNuevo = null;
            GrupoempTools._FechaFinEjerNuevo = null;
            GrupoempTools._EmpresaGrNuevo = "";
            GrupoempTools._CfgEjerPartiGrNuevo = false;
            GrupoempTools._EjerNuevoMarcarPredet = false;

            GrupoempTools._NombreEmpresa = "";
            GrupoempTools._CifEmpresa = "";
            GrupoempTools._ConservarClientes = false;
            GrupoempTools._ConservarUsuarios = false;
            GrupoempTools._ConservarArticulos = false;
            GrupoempTools._ConservarProveedores = false;
            GrupoempTools._LongitudesEstandar = false;

            GrupoempTools._LenCuenta = 8;
            GrupoempTools._LenMarca = 2;
            GrupoempTools._LenFamilia = 2;
            GrupoempTools._LenVendedor = 2;
            GrupoempTools._LenAlmacen = 2; // Bug 109147
            GrupoempTools._PrefijoCli3 = "430";
            GrupoempTools._PrefijoDeudor3 = "440";
            GrupoempTools._PrefijoPro3 = "400";
            GrupoempTools._PrefijoAcr3 = "410";
            GrupoempTools._PrefijoBan3 = "572";
            GrupoempTools._PrefijoCaj3 = "570";
            GrupoempTools._PrefijoCom3 = "600";
            GrupoempTools._PrefijoVen3 = "700";
            GrupoempTools._UserPropBdGrNuevo = "Sage50";
            GrupoempTools._CarpetaBackupServidorSql = "";
            

            // PROPIEDADES DE BORRADO DE GRUPO
            GrupoempTools._DbComunesGrBorrar = "";
            GrupoempTools._dtBdEjerGrBorrar = new DataTable();
            GrupoempTools._dtBdAddonsGrBorrar = new DataTable();

            // OTROS
            GrupoempTools._Error_Message = "";
        }

        public static bool _Borrar_Grupo(string tcGrupo)
        {
            bool llOk = true;
            bool llOk2 = true;
            string tcCadenaError = "Hubo un problema con la eliminación de las bases de datos siguientes: ";

            ActualizarBarraProgreso();

            // INICIALIZAR PROPIEDADES
            // Inicializa propiedades internas, las unicas propiedades que no se inicializan son:
            // _Log: si se ha de loguear el proceso.
            // _RutaFicheroLog: ruta al fichero de log.
            // _Euroserv: carpeta de Euroserv de la instalación, es necesario por que al acabar la creacion se actualiza CFGCLISRV.XML en esta carpeta
            // _TipoOperativaCreacionGrupoEjer: tipo operativa creación grupo y ejercicio
            // y la cadena de log en la que acumulamos las incidencias de log
            GrupoempTools._cCadenaLog = new StringBuilder();
            GrupoempTools._ResetearPropiedades();

            
            // Si se ha de loguear pero no tenemos la ruta al fichero de log instanciada la asignamos automaticamente, apuntará a un txt en EUROSERV\
            if (_Log)
            {
                if (string.IsNullOrWhiteSpace(_RutaFicheroLog))
                    _RutaFicheroLog = GrupoempTools._Obtener_RutaLog_Automatica(tcGrupo, 2);
            }

            
            // Si no hay conexión a una instancia de servidor SQL no hay nada que hacer.
            if (string.IsNullOrWhiteSpace(DB.Conexion) || string.IsNullOrWhiteSpace(DB.DbComunes))
            {
                _Error_Message = "No se ha detectado conexión al servidor SQL, no se borrará el grupo.";
                if (_Log)
                {
                    Guardar_Mensaje(_Error_Message);
                    CopiarStringLog_Fichero(_RutaFicheroLog);
                }
                return false;
            }

            if (string.IsNullOrWhiteSpace(GrupoempTools._Euroserv))
            {
                _Error_Message = "No se ha dado valor a la propiedad _Euroserv de la clase GrupoempTools y es necesaria para la eliminacion del grupo, no se borrará el grupo.";
                if (_Log)
                {
                    Guardar_Mensaje(_Error_Message);
                    CopiarStringLog_Fichero(_RutaFicheroLog);
                }
                return false;
            }


            if (_Log)
            {
                Guardar_Mensaje("GRUPO A ELIMINAR: " + tcGrupo + Environment.NewLine);
                Guardar_Mensaje("INICIO DE COMPROBACIONES PREVIAS ANTES DE PROCEDER A BORRAR EL GRUPO."+Environment.NewLine);
            }

            ActualizarBarraProgreso();


            // COMPROBACIONES PREVIAS
            // Obtener todos los datos que nos hacen falta para poder hacer el BACKUP y el RESTORE posteiror.
            llOk = GrupoempTools.BorrarGrupo_Comprobaciones_Previas(tcGrupo);
            ActualizarBarraProgreso();

            // Despues de la llamada anterior las siguientes propiedades deberían estar informadas: 
            // GrupoempTools._DbComunesGrBorrar
            // GrupoempTools._dtBdEjerGrBorrar 
            // GrupoempTools._dtBdAddonsGrBorrar 

            if (!llOk)
            {
                if (_Log)
                    CopiarStringLog_Fichero(_RutaFicheroLog);
                return false;
            }

            if (_Log)
            {
                Guardar_Mensaje("Comprobaciones previas al borrado de grupo satisfactorias: OK."+Environment.NewLine);
                Guardar_Mensaje("Fin comprobaciones previas antes de revisar bases de datos." + Environment.NewLine);
            }
            ActualizarBarraProgreso();


            // Inicio de proceso de comprobación bases de datos.
            if (_Log)
            {
                Guardar_Mensaje("Inicio comprobación bases de datos del grupo " + tcGrupo + Environment.NewLine);
            }
            ActualizarBarraProgreso();


            // COMPROBACIONES BASES DE DATOS
            llOk = GrupoempTools.RevisarBaseDatosEnUso();
            ActualizarBarraProgreso();

            if (!llOk)
            {
                if (_Log)
                    CopiarStringLog_Fichero(_RutaFicheroLog);
                return false;
            }

            if (_Log)
            {
                Guardar_Mensaje("Comprobaciones bases de datos: OK." + Environment.NewLine);
                Guardar_Mensaje("FIN DE COMPROBACIONES PREVIAS ANTES DE PROCEDER A BORRAR EL GRUPO." + Environment.NewLine);
            }
            ActualizarBarraProgreso();



            // ELIMINACION DEL GRUPO
            // En principio, via libre para eliminar el grupo, eliminará el COMUNES, 
            // todas las bd que encuentra en COMUNES.EJERCICI y todas las bd que encuentre en COMUNES.MODULOS, la COMUNES
            // debe ser la ultima bd a eliminar.

            // Inicio de proceso de borrado de bases de datos.
            if (_Log)
            {
                Guardar_Mensaje("INICIO PROCESO DE ELIMINACION DE BASES DE DATOS DEL GRUPO " + tcGrupo + Environment.NewLine);
                Guardar_Mensaje("BORRADO DE BASES DE DATOS DE ADDONS"+Environment.NewLine);
            }
            ActualizarBarraProgreso();



            // ELIMINACION DE LAS BASES DE DATOS DE LOS ADD-ONS
            string lcBd = "";
            string  lcNombreAddon = "";

            foreach (DataRow loRow in GrupoempTools._dtBdAddonsGrBorrar.Rows)
            { 
                lcBd = Convert.ToString(loRow["nom_conex"]).Trim();
                lcNombreAddon = Convert.ToString(loRow["nombre"]).Trim();

                llOk2 = BorrarGrupo_Remove_Bd(lcBd, lcNombreAddon);
                llOk = llOk && llOk2;

                if (!llOk2)
                    tcCadenaError += lcNombreAddon+" ("+lcNombreAddon+") ";
            }
            ActualizarBarraProgreso();

            if (_Log)
            {
                Guardar_Mensaje(Environment.NewLine);
                Guardar_Mensaje("BORRADO DE BASES DE DATOS DE EJERCICIOS"+Environment.NewLine);
            }


            // ELIMINACION DE LAS BASES DE DATOS DE LOS EJERCICIOS
            string lcAny = "";
            foreach (DataRow loRow in GrupoempTools._dtBdEjerGrBorrar.Rows)
            {
                lcBd = Convert.ToString(loRow["conexion"]).Trim();
                lcAny = Convert.ToString(loRow["any"]).Trim();

                llOk2 = BorrarGrupo_Remove_Bd(lcBd, "EJERCICIO " + lcAny);
                llOk = llOk && llOk2;

                if (!llOk2)
                    tcCadenaError += "EJERCICIO " + lcAny+" ("+lcBd+") ";
            }
            ActualizarBarraProgreso();


            if (_Log)
            {
                Guardar_Mensaje(Environment.NewLine);
                Guardar_Mensaje("BORRADO DE BASE DE DATOS DE COMUNES"+Environment.NewLine);
            }

            // Si todo lo anterior fue bien, vamos a eliminar la base de datos de COMUNES que es la única que falta.
            // ELIMINACION DE LAS BASES DE DATOS DE COMUNES
            llOk2 = BorrarGrupo_Remove_Bd(GrupoempTools._DbComunesGrBorrar, "COMUNES");
            llOk = llOk && llOk2;
            if (llOk2 == false)
                tcCadenaError += "COMUNES (" + GrupoempTools._DbComunesGrBorrar + ") ";

            ActualizarBarraProgreso();

            if (llOk)
            {
                if (_Log)
                {
                    Guardar_Mensaje(Environment.NewLine);
                    Guardar_Mensaje("PROCESO DE BORRADO DE GRUPO " + tcGrupo + " FINALIZADO CORRECTAMENTE.");
                }


                if (_Log)
                    Guardar_Mensaje("Borrado de grupo de la tabla de grupos.");
                // Borramos el registro de la tabla de grupos
                DB.SQLExec("delete from "+DB.SQLDatabaseReal("eurowinsys","gruposemp")+" where codigo='"+tcGrupo+"'");

                if (_Log)
                    Guardar_Mensaje("Borrado de grupo de la tabla de control grupos.");
                // Borramos el registro de la tabla de control de grupos
                //Santi => No usamos la DA pues estamos directamente en la sage.ew.DB
                DB.SQLExec("delete from " + DB.SQLDatabaseReal("eurowinsys", "ctrlgrupos") + " where comunes='COMU" + tcGrupo + "'");

                if (_Log)
                    Guardar_Mensaje("Actualizacion de gruposemp.xml.");
                
                string lcEuroserv = GrupoempTools._Euroserv.Trim();
                DB._GrupoEmpresa_Table2Xml(Path.Combine(lcEuroserv,"gruposemp.xml"));

                if (_Log)
                    Guardar_Mensaje("Actualizacion de CFGCLISRV.");
                GrupoempTools._BorrarGrupo_QuitarGrupo_CfgCliSrv(tcGrupo);

                // PE-105138. Quitar el comunes borrado del diccionario de la DB
                if (DB._oAliasDB.ContainsKey("COMU" + tcGrupo.Trim()))
                {
                    DB._oAliasDB.Remove("COMU" + tcGrupo.Trim());
                }
            }
            else
                _Error_Message = tcCadenaError;

            // Solo que hay habido un problema con la eliminacion de una de las bases de datos 
            // ya es razón sufiiente para devolver false

            ActualizarBarraProgreso();

            if (_Log)
                CopiarStringLog_Fichero(_RutaFicheroLog);

            ActualizarBarraProgreso();

            return llOk;
        }

        public static void CambiarNombreGrupo(string tcGrupo, string tcNombre)
        {
            string lcSql = "UPDATE " + DB.SQLDatabaseReal("EUROWINSYS", "GRUPOSEMP") + " SET nombre = " + DB.SQLString(tcNombre) + " WHERE codigo = " + DB.SQLString(tcGrupo);
            DB.SQLExec(lcSql);
        }

        #endregion METODOS PÚBLICOS


        #region METODOS PRIVADOS

        private static void datosConexionActual(out string tcUsuario, out string tcPassword)
        {
            // Obtenemos los parámetros actuales de conexión.
            //
            SqlConnectionStringBuilder loBuilder = new SqlConnectionStringBuilder(DB.Conexion);

            tcUsuario = loBuilder.UserID;
            tcPassword = loBuilder.Password;

            return;
        }

        private static bool conectarUsuario(string tcUsuario, string tcPass)
        {
            bool lbOk;

            // Obtenemos los parámetros actuales de conexión
            //
            SqlConnectionStringBuilder loBuilder = new SqlConnectionStringBuilder(DB.Conexion);

            // Intentamos reconectar con los mismos parámetros cambiando el usuario por sa
            //
            lbOk = DB.SQLConnect(loBuilder.DataSource, tcComunes: DB.DbComunes, tcUser: tcUsuario, tcPassword: tcPass, tbAuthWin: false);

            return lbOk;
        }

        private static bool restoreUsuario(string tcDbNombreViejo, string tcDbNombreNuevo,  string tcUsuarioActual, out string tcMsgError, string tcMensalog = "")
        {
            bool llOk = false;
            tcMsgError = "";

            if (_Log)
                Guardar_Mensaje("Conectando con usuario 'sa'");

            // Cambiar conexion a usuario sa
            //
            DB.Error_Message = "";
            llOk = conectarUsuario("sa", GrupoempTools._CrearGrupoP);

            if (llOk)
            {
                if (_Log)
                {
                    Guardar_Mensaje("Conexión con usuario 'sa': OK");
                    Guardar_Mensaje("Intentando restaurar la base Conexión con usuario 'sa'");
                }

                DB.Error_Message = "";
                llOk = DB._DbRestore(tcDbNombreViejo, tcDbNombreNuevo, GrupoempTools._CarpetaBackupServidorSql, tcUsuarioActual);
                if (llOk)
                {
                    if (_Log)
                        Guardar_Mensaje("La creación de la nueva base de datos de " + tcMensalog + " " + tcDbNombreNuevo + " se ha realizado correctamente: OK");
                }
                else
                {
                    tcMsgError = "NO se ha podido restaurar la copia de seguridad de la base de datos de " + tcMensalog + " " + 
                                 tcDbNombreViejo + " como " + tcDbNombreNuevo + " utilizando conexión con usuario 'sa', "+
                                 "imposible crear grupo. Error: " + DB.Error_Message;
                }
            }
            else
                tcMsgError = "No se ha podido conectar con el usuario 'sa' (" + DB.Error_Message + ").";

            // Si devuelve error el mensaje de error se loguea a la vuelta del procedimiento, en origen.
            //

            return llOk;
        }

        private static bool borrarBaseDatos(string tcBd)
        {
            // Mirar si existe base de datos y eliminar
            try
            {
                if (DB._SQLExisteBBDD(tcBd))
                    DB._DBRemove(new SqlConnection(DB.Conexion), tcBd);
            }
            catch (Exception loEx)
            {
                _Error_Message = "Se ha producido un error al eliminar la base de datos " + tcBd
                                 + " ( " + loEx.Message + System.Environment.NewLine + DB.Error_Message + ").";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);

                return true;
            }

            return true;
        }

        private static void ActualizarBarraProgreso()
        {
            if (_Worker != null && _TotalPasosProgreso > 0)
            {
                // Calculamos el progreso relativo a la barra teniendo en cuenta que la barra va de 0 a 100 %
                _PasoProgreso++;
                int lnProgresoRelativo100 = (_PasoProgreso * 100) / _TotalPasosProgreso;

                if (lnProgresoRelativo100 > 100)
                    lnProgresoRelativo100 = 100;

                _Worker.ReportProgress(lnProgresoRelativo100);
                Application.DoEvents();
            }
        }

        private static bool CrearGrupo_Comprobar_Existencia_BdNuevas(string tcEjerNuevo, string tcSufijo)
        {
            string lcBd = tcEjerNuevo + tcSufijo;

            
            // Verifico bd. ejercicio del nuevo grupo a crear.
            if (DB._SQLExisteBBDD(lcBd))
            {
                if (GrupoempTools._Log)
                    GrupoempTools.Guardar_Mensaje("La base de datos " + lcBd + " para el ejercicio a crear en el grupo ya existe en el servidor SQL.");
                return true;
            }

            // Exigiremos que no exista bd para 15 ejercicios anterior y posteriores con este sufijo
            //
            int lnEjerNuevo = Convert.ToInt16(tcEjerNuevo);
            string lcBdGesIni = Convert.ToString(lnEjerNuevo - 15) + tcSufijo;
            string lcBdGesFin = Convert.ToString(lnEjerNuevo + 15) + tcSufijo;
            if (GrupoempTools.CrearGrupo_ExistenBdsGestion(lcBdGesIni, lcBdGesFin))
            { 
                if (GrupoempTools._Log)
                    GrupoempTools.Guardar_Mensaje("La base de datos " + lcBd + " para el ejercicio a crear en el grupo ya está asignada en otra instalación.");

                return true;
            }



            // Verifico existencia de las bases de datos de los Addons standar a crear en el nuevo grupo
            string lcNombreAddon = "";
            foreach (DataRow loRow in GrupoempTools._dtBdAddonsGrOrigen.Rows)
            {
                lcNombreAddon = Convert.ToString(loRow["nombre"]).Trim().ToUpper();
                lcBd = lcNombreAddon.Trim();
                
                if (lcBd.Length>6)
                    lcBd = lcBd.Substring(0,6);
                
                lcBd = lcBd.PadRight(6, '0') + tcSufijo;
                
                if (DB._SQLExisteBBDD(lcBd))
                {
                    if (GrupoempTools._Log)
                        GrupoempTools.Guardar_Mensaje("La base de datos " + lcBd + " a crear en el grupo correspondiente al Addon de "+lcNombreAddon+" ya existe en el servidor SQL.");
                    return true;
                }

            }

            return false;
        }

        public static bool CrearGrupo_ExistenBdsGestion(string tcNombreBBDDMin, string tcNombreBBDDMax)
        {
            bool llOk = false;
            string lcSql = String.Empty;
            DataTable ldtResultado = new DataTable();

            tcNombreBBDDMin = tcNombreBBDDMin.Trim();
            tcNombreBBDDMax = tcNombreBBDDMax.Trim();

            if (String.IsNullOrWhiteSpace(tcNombreBBDDMin) || String.IsNullOrWhiteSpace(tcNombreBBDDMax))
                return llOk;

            string lcSufijo2Letras = "";

            if (tcNombreBBDDMin.Length == tcNombreBBDDMax.Length)
            {
                int lnLenNameBd = tcNombreBBDDMin.Length;
                lcSufijo2Letras = tcNombreBBDDMin.Substring(lnLenNameBd - 2, 2);
            }

            lcSql = "IF EXISTS (SELECT 1 FROM [master].sys.databases " +
                    " WHERE name >= " + DB.SQLString(tcNombreBBDDMin) + " and name <= " + DB.SQLString(tcNombreBBDDMax) +
                    " and right(name,2)=" + DB.SQLString(lcSufijo2Letras) + ") " +
                    " SELECT 1 AS ExisteBBDD ELSE SELECT 0 AS ExisteBBDD ";

            llOk = DB.SQLExec(lcSql, ref ldtResultado);

            if (llOk && ldtResultado.Rows.Count > 0)
                llOk = Convert.ToBoolean(ldtResultado.Rows[0]["ExisteBBDD"]);

            return llOk;
        }

        private static void Proc_Adicional_ComunesGrNuevo()
        {
            string lcSql="UPDATE "+DB.SQLDatabaseReal(GrupoempTools._DbComunesGrNuevo,"ejercici")+" SET "+
                         "RUTA=LEFT(RUTA,4)+'@@', RUTASER=LEFT(RUTASER,4)+'@@', CONEXION=LEFT(CONEXION,4)+'@@'";
            DB.SQLExec(lcSql);

            lcSql = "UPDATE " + DB.SQLDatabaseReal(GrupoempTools._DbComunesGrNuevo, "modulos") + " SET " +
             "NOM_CONEX=LEFT(NOM_CONEX,6)+'@@', TABLAS=LEFT(TABLAS,6)+'@@'";
            DB.SQLExec(lcSql);

            return;
        }

        private static bool CrearGrupo_RestoreBds()
        {
            bool llOk = false;

            if (_Log)
                Guardar_Mensaje("INICIO PROCESO DE RESTAURACIÓN DE BASES DE DATOS."+Environment.NewLine);

            
            // RESTAURACION BD COMUNES CON NUEVO NOMBRE
            llOk = GrupoempTools.Restore_Bd(GrupoempTools._DbComunesGrOrigen, GrupoempTools._DbComunesGrNuevo, "COMUNES");
            if (!llOk)
                return false;

            // En este punto y como medida de seguridad en la bd de COMUNES del grupo nuevo, quitaremos los nombres de las bds de EJERCICIOS
            // y ADDONS de COMUNES.EJERCICI y COMUNES.MODULOS pues aun siendo la bd. de COMUNES del nuevo grupo
            // en este punto su contenido tiene aún los nombres de las bd del grupo origen. 
            // Se hace este paso como medida de seguridad por que si por casualidad la creacion de grupo se interrumpiese
            // despues de la restauración del COMUNES y antes de restaurar el resto de bases de datos, si algún programador llamase
            // al método _Borrar_Grupo() de este grupo que se está creando, acabaría borrando las bds. de ejercicios y 
            // addons del grupo origen puesto que el contenido de COMUNES.EJERCICI y COMUNES.MODULOS en este punto aún
            // apunta a las bds. del grupo origen pues justo acabamos de restaurar la copia con otro nombre !!!!
            GrupoempTools.Proc_Adicional_ComunesGrNuevo();


            // RESTAURACION BD EJERCICIO CON NUEVO NOMBRE
            llOk = GrupoempTools.Restore_Bd(GrupoempTools._DbEjerGrOrigen, GrupoempTools._DbEjerGrNuevo, "EJERCICIO");
            if (!llOk)
                return false;



            // RESTAURACION BD DE ADDONS CON NUEVO NOMBRE

            string lcDbAddOnPripal = "", lcNewBdAddon = "", lcNombreAddon="";
            foreach (DataRow loRow in GrupoempTools._dtBdAddonsGrOrigen.Rows)
            {
                lcNombreAddon = Convert.ToString(loRow["nombre"]).Trim();
                lcDbAddOnPripal = Convert.ToString(loRow["nom_conex"]).Trim();

                lcNewBdAddon = lcDbAddOnPripal.Substring(0, lcDbAddOnPripal.Length - 2);
                lcNewBdAddon = lcNewBdAddon + GrupoempTools._SufiBdEjerGrNuevo;

                // RESTAURACION BD ADDON CON NUEVO NOMBRE
                llOk =  GrupoempTools.Restore_Bd(lcDbAddOnPripal, lcNewBdAddon,"el módulo del Add-On de " + lcNombreAddon);
                if (!llOk)
                    return false;
            }


            if (_Log)
            {
                Guardar_Mensaje("Proceso de restauración de base de datos finalizado correctamente."+Environment.NewLine);
                Guardar_Mensaje("FIN PROCESO DE RESTAURACIÓN DE BASES DE DATOS."+Environment.NewLine);
            }

            return true;
        }

        private static bool CrearGrupo_BorrarBdsNuevas()
        {
            bool llOk = true;
            bool llOk2 = false;


            // PASO 1/3
            // BORRADO DE BASE DE DATOS DE COMUNES DEL NUEVO GRUPO QUE SE PRETENDIA CREAR.
            
            if (!string.IsNullOrWhiteSpace(GrupoempTools._DbComunesGrNuevo))
            {
                if (DB._SQLExisteBBDD(GrupoempTools._DbComunesGrNuevo))
                {
                    
                    if (_Log)
                        Guardar_Mensaje("Proceso de creación de grupo no se pudo ejecutar correctamente, eliminando base de datos de COMUNES del nuevo grupo que se pretendía crear " + GrupoempTools._DbComunesGrNuevo + " debido a un fallo en el proceso.");
                    
                    llOk2 = DB._DBRemove(new SqlConnection(DB.Conexion), GrupoempTools._DbComunesGrNuevo);
                    llOk = llOk2 && llOk;

                    if (_Log)
                    {
                        if (llOk2)
                            Guardar_Mensaje("Base de datos de COMUNES " + GrupoempTools._DbComunesGrNuevo + "  eliminada correctamente.");
                        else
                            Guardar_Mensaje("Base de datos de COMUNES " + GrupoempTools._DbComunesGrNuevo + " no se pudo eliminar correctamente.");

                    }
                }
            }



            // PASO 2/3
            // BORRADO DE BASE DE DATOS DE EJERCICIO DEL NUEVO GRUPO QUE SE PRETENDIA CREAR.

            if (!string.IsNullOrWhiteSpace(GrupoempTools._DbEjerGrNuevo))
            {
                if (DB._SQLExisteBBDD(GrupoempTools._DbEjerGrNuevo))
                {
                    // Borramos la base de datos de EJERCICIOS pues el grupo no se va a crear.
                    if (_Log)
                        Guardar_Mensaje("Proceso de creación de grupo no se pudo ejecutar correctamente, eliminando base de datos de EJERCICIO del nuevo grupo que se pretendía crear " + GrupoempTools._DbEjerGrNuevo + " debido a un fallo en el proceso.");

                    llOk2 = DB._DBRemove(new SqlConnection(DB.Conexion), GrupoempTools._DbEjerGrNuevo);
                    llOk = llOk2 && llOk;

                    if (_Log)
                    {
                        if (llOk2)
                            Guardar_Mensaje("Base de datos de EJERCICIO " + GrupoempTools._DbEjerGrNuevo + "  eliminada correctamente.");
                        else
                            Guardar_Mensaje("Base de datos de EJERCICIO " + GrupoempTools._DbEjerGrNuevo + " no se pudo eliminar correctamente.");

                    }
                }
            }




            // PASO 3/3
            // BORRADO DE BASE DE DATOS DE ADDONS DEL NUEVO GRUPO QUE SE PRETENDIA CREAR.

            if (GrupoempTools._dtBdAddonsGrNuevo is DataTable && GrupoempTools._dtBdAddonsGrNuevo.Rows.Count > 0)
            {
                string lcBdAddon = "", lcNombreAddon="";
                foreach (DataRow loRow in GrupoempTools._dtBdAddonsGrNuevo.Rows)
                {
                    lcBdAddon = Convert.ToString(loRow["nom_conex"]).Trim();
                    lcNombreAddon = Convert.ToString(loRow["nombre"]).Trim();

                    if (!string.IsNullOrWhiteSpace(lcBdAddon))
                    {
                        if (DB._SQLExisteBBDD(lcBdAddon))
                        {
                            // Borramos la base de datos deL AddOn que se había creado pero al fallar la creación del grupo, al final no lo creamos
                            if (_Log)
                                Guardar_Mensaje("Proceso de creación de grupo no se pudo ejecutar correctamente, eliminando base de datos del ADDON del "+lcNombreAddon+" " + lcBdAddon + " debido a un fallo en el proceso.");

                            llOk2 = DB._DBRemove(new SqlConnection(DB.Conexion), lcBdAddon);
                            llOk = llOk2 && llOk;
                            
                            if (_Log)
                            {
                                if (llOk2)
                                    Guardar_Mensaje("Base de datos de AddOn de " + lcNombreAddon + " " + lcBdAddon + " eliminada correctamente.");
                                else
                                    Guardar_Mensaje("Base de datos de Addon de " + lcNombreAddon + " " + lcBdAddon + " no se pudo eliminar correctamente.");

                            }
                        }
                    
                    }
                }
            }

            // Se intenta eliminar todas las bases de datos del nuevo grupo que se pudiera haber creado hasta el momento en que hubo el error, y devolvemos false caso de que al menos una de ellas no se haya podido
            // borrar.

            return llOk;
        }

        
        private static bool CrearGrupo_BackupsBds()
        {
            bool llOk = false;

            ActualizarBarraProgreso();

            if (_Log)
                Guardar_Mensaje("INICIO PROCESO COPIA DE BASES DE DATOS."+Environment.NewLine);

            // COPIA BASE DE DATOS DE COMUNES DEL grupo origen
            llOk = GrupoempTools.Backup_Bd(GrupoempTools._DbComunesGrOrigen, "COMUNES");
            ActualizarBarraProgreso();
            if (!llOk)
                return false;


            // COPIA BASE DE DATOS DE EJERCICIO DEL grupo origen
            llOk = GrupoempTools.Backup_Bd(GrupoempTools._DbEjerGrOrigen, "EJERCICIO");
            ActualizarBarraProgreso();
            if (!llOk)
                return false;


            // COPIA BASES DE DATOS DE ADDONS BASE DEL grupo origen
            string lcBdAddon = "", lcNombreAddon = "";
            foreach (DataRow loRow in GrupoempTools._dtBdAddonsGrOrigen.Rows)
            {
                lcBdAddon = Convert.ToString(loRow["nom_conex"]).Trim();
                lcNombreAddon = Convert.ToString(loRow["nombre"]).Trim().ToUpper();

                llOk = GrupoempTools.Backup_Bd(lcBdAddon, "Add-On " + lcNombreAddon);                
                if (!llOk)
                    return false;
            }
            ActualizarBarraProgreso();

            if (_Log)
            {
                Guardar_Mensaje("Proceso de copia de bases de datos del grupo origen finalizado correctamente."+Environment.NewLine);
                Guardar_Mensaje("FIN PROCESO COPIA DE BASES DE DATOS."+Environment.NewLine);
            }
            ActualizarBarraProgreso();

            return true;
        }

        private static bool CrearEjercicio_CrearTablasBd()
        {
            bool llOk = false;

            if (_Log)
                Guardar_Mensaje("INICIO PROCESO CREACION DE TABLAS EN LA BASES DE DATOS DEL NUEVO EJERCICIO." + Environment.NewLine);


            // CREACION DE TABLAS EN LA NUEVA BASE DE DATOS EJERCICIO A PARTIR DE LAS TABLAS DEL EJERCICIO ORIGEN
            llOk = GrupoempTools.CrearGrupoEjer_CrearTablasBd("GESTION");
            if (!llOk)
                return false;

            if (_Log)
                Guardar_Mensaje("FIN PROCESO CREACION DE TABLAS EN LA BASES DE DATOS DEL NUEVO EJERCICIO." + Environment.NewLine);

            return true;
        }

        private static bool CrearEjercicio_CrearBd()
        {
            bool llOk = false;
            string lcSql = "";


            // CREACION BD GESTION PARA EL NUEVO GRUPO
            if (_Log)
                Guardar_Mensaje("Creando base de datos de EJERCICIO " + GrupoempTools._DbEjerGrNuevo);
            
            if (DB._SQLExisteBBDD(_DbEjerGrNuevo))
            {
                _Error_Message = "La base de datos de EJERCICIO que se pretende crear " + GrupoempTools._DbEjerGrNuevo + " ya existe, imposible crear base de datos de EJERCICIO.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }


            llOk = DB._DBCreate(GrupoempTools._DbEjerGrNuevo.Trim());
            if (!llOk)
            {
                _Error_Message = "Se produjo un error al crear la base de datos de EJERCICIO " + GrupoempTools._DbEjerGrNuevo;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
            }
            else
            {
                lcSql = "ALTER AUTHORIZATION ON DATABASE::[" + GrupoempTools._DbEjerGrNuevo + "] TO " + GrupoempTools._UserPropBdGrNuevo;
                DB.SQLExec(lcSql);

                if (_Log)
                    Guardar_Mensaje("Base de datos de EJERCICIO " + GrupoempTools._DbEjerGrNuevo+" creada correctamente.");

            }

            return llOk;
        }

        private static bool CrearGrupo_CrearBds()
        {
            bool llOk = false;
            string lcNomBd = "", lcNombreAddon = "", lcSql="";


            // CREACION BD COMUNES PARA EL NUEVO GRUPO
            if (_Log)
                Guardar_Mensaje("Creando base de datos de COMUNES " + GrupoempTools._DbComunesGrNuevo);

            
            if (DB._SQLExisteBBDD(GrupoempTools._DbComunesGrNuevo.Trim()))
            {
                _Error_Message = "La base de datos de COMUNES " + GrupoempTools._DbComunesGrNuevo + " ya existe, imposible crear base de datos.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }

            
            llOk = DB._DBCreate(GrupoempTools._DbComunesGrNuevo.Trim());
            if (!llOk)
            {
                _Error_Message = "Se produjo un error al crear la base de datos de COMUNES " + GrupoempTools._DbComunesGrNuevo;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
            }
            else
            {
                lcSql = "ALTER AUTHORIZATION ON DATABASE::[" + GrupoempTools._DbComunesGrNuevo + "] TO " + GrupoempTools._UserPropBdGrNuevo;
                DB.SQLExec(lcSql);
            }
            if (!llOk)
                return false;


            
            // CREACION BD GESTION PARA EL NUEVO GRUPO
            if (_Log)
                Guardar_Mensaje("Creando base de datos de EJERCICIO " + GrupoempTools._DbEjerGrNuevo);

            
            if (DB._SQLExisteBBDD(GrupoempTools._DbEjerGrNuevo.Trim()))
            {
                _Error_Message = "La base de datos de EJERCICIO " + GrupoempTools._DbEjerGrNuevo + " ya existe, imposible crear base de datos.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }

            
            llOk = DB._DBCreate(GrupoempTools._DbEjerGrNuevo.Trim());
            if (!llOk)
            {
                _Error_Message = "Se produjo un error al crear la base de datos de EJERCICIO " + GrupoempTools._DbEjerGrNuevo;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
            }
            else
            {
                lcSql = "ALTER AUTHORIZATION ON DATABASE::[" + GrupoempTools._DbEjerGrNuevo + "] TO " + GrupoempTools._UserPropBdGrNuevo;
                DB.SQLExec(lcSql);

            }
            if (!llOk)
                return false;




            // CREACION BD DE ADDONS PARA EL NUEVO GRUPO
            foreach (DataRow loRow in GrupoempTools._dtBdAddonsGrNuevo.Rows)
            {
                lcNomBd = Convert.ToString(loRow["nom_conex"]).Trim();
                lcNombreAddon = Convert.ToString(loRow["nombre"]).Trim();
                    
                if (_Log)
                    Guardar_Mensaje("Creando base de datos de ADDON " + lcNombreAddon+" "+lcNomBd);

                
                if (DB._SQLExisteBBDD(lcNomBd))
                {
                    _Error_Message = "La base de datos de ADDON " + lcNombreAddon + " " + lcNomBd + " ya existe, imposible crear base de datos.";
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }

                
                llOk = DB._DBCreate(lcNomBd);
                if (!llOk)
                {
                    _Error_Message = "Se produjo un error al crear la base de datos del ADDON " + lcNombreAddon + " " + lcNomBd; 
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                }
                else
                {
                    lcSql = "ALTER AUTHORIZATION ON DATABASE::[" + lcNomBd + "] TO " + GrupoempTools._UserPropBdGrNuevo;
                    DB.SQLExec(lcSql);
                }
                if (!llOk)
                    return false;
            }
            
            return true;
        }


        private static bool CrearGrupoEjer_CrearIndices_ValsDefecto_Tabla(string tcBdOrigen, string tcBdNueva, string tcTabla, DataTable tdtIndices, DataTable tdtValsDefecto)
        {
            bool llOk = false, llEsPrimario=false;
            string lcSql = "", lcNombreIndice ="", lcExpresionIndice="", lcNombreConstraintValDef="", lcValorDefecto="", lcCampoDefecto="", lcFiltroTabla="", lcTabla="";

            tcTabla = tcTabla.ToLower().Trim();
            tcBdNueva = tcBdNueva.ToLower().Trim();
            tcBdOrigen = tcBdOrigen.ToLower().Trim();

            
            // CREAR CLAVE PRIMARIA Y VALORES POR DEFECTO PARA LA NUEVA TABLA ...

            //Revisar si tenemos de filtrar por tabla
            lcFiltroTabla = !string.IsNullOrEmpty(tcTabla.Trim()) ? "tabla='" + tcTabla + "'" : "";

            DataRow[] laRows = tdtIndices.Select(lcFiltroTabla, "tabla, indice asc, indice_orden asc");  // Hay una fila para cada columna que interviene en un índice de la tabla
            int ln_i=0;

            while (ln_i<laRows.GetLength(0))
            {
                lcNombreIndice = Convert.ToString(laRows[ln_i]["indice"]).Trim();
                llEsPrimario = Convert.ToBoolean(laRows[ln_i]["indice_primario"]);
                lcTabla = Convert.ToString(laRows[ln_i]["tabla"]).Trim();

                lcExpresionIndice = "";
                while (ln_i<laRows.GetLength(0) && Convert.ToString(laRows[ln_i]["indice"]).Trim() == lcNombreIndice)
                {
                    lcExpresionIndice +=  " ["+Convert.ToString(laRows[ln_i]["columna"]).Trim()+"] ASC, ";
                    ln_i++; 
                }
                if (!string.IsNullOrWhiteSpace(lcExpresionIndice))
                {
                    lcExpresionIndice = lcExpresionIndice.Trim();
                    lcExpresionIndice = lcExpresionIndice.Substring(0, lcExpresionIndice.Length - 1);
                }
 
                if (llEsPrimario)
                {
                    //lcNombreIndice = lcNombreIndice.Replace(tcBdOrigen,tcBdNueva);  // En el nombre del índice primario aparece el nombre de la bd.
                    lcNombreIndice = Regex.Replace(lcNombreIndice, tcBdOrigen, tcBdNueva, RegexOptions.IgnoreCase); //CCR 170491
                    lcSql += " ALTER TABLE [" + tcBdNueva + "].[dbo].[" + lcTabla + "] ADD CONSTRAINT [" + lcNombreIndice + "] " +
                             " PRIMARY KEY CLUSTERED ( "+lcExpresionIndice+")  WITH ( STATISTICS_NORECOMPUTE = OFF, "+
                             " IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON)  ON [eurowind]; ";
                }
                else
                {
                    lcSql += "CREATE NONCLUSTERED INDEX [" + lcNombreIndice + "] ON [" + tcBdNueva + "].[dbo].[" + lcTabla + "] " +
                             "("+lcExpresionIndice+") WITH (STATISTICS_NORECOMPUTE  = OFF, SORT_IN_TEMPDB = OFF, DROP_EXISTING = OFF, "+
                             "IGNORE_DUP_KEY = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [eurowini]; ";
                }
            }
            
            // Ejecutar instrucción para crear todos los indices, clave primaria incluida, todo en una unica instruccion, controlo que haya algo que hacer pues caso de una tabla sin indices ni clave primaria
            // aqui no deberia haber nada.
            if (!string.IsNullOrWhiteSpace(lcSql))
            {
                llOk = DB.SQLExec(lcSql);
                if (!llOk)
                {
                    if (string.IsNullOrEmpty(tcTabla))
                        _Error_Message = "Error al crear los índices de la base de datos " + tcBdNueva;
                    else
                        _Error_Message = "Error al crear los índices para la tabla " + tcTabla + " de la base de datos " + tcBdNueva;
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }
            }


            // CREAR VALORES POR DEFECTO PARA LA NUEVA TABLA ...

            laRows = tdtValsDefecto.Select(lcFiltroTabla);  // Hay una fila para cada columna que interviene en un índice de la tabla
            ln_i=0;
            lcSql="";
            foreach (DataRow loRow in laRows)
            {
                lcNombreConstraintValDef = Convert.ToString(loRow["constr_nombre"]).Trim();
                lcValorDefecto =  Convert.ToString(loRow["constr_defin"]).Trim();
                lcCampoDefecto = Convert.ToString(loRow["campo"]).Trim();
                lcTabla = Convert.ToString(loRow["tabla"]).Trim();

                //lcNombreConstraintValDef = lcNombreConstraintValDef.Replace(tcBdOrigen,tcBdNueva);  // En el nombre de la constraint aparece el nombre de la bd.
                lcNombreConstraintValDef = Regex.Replace(lcNombreConstraintValDef, tcBdOrigen, tcBdNueva, RegexOptions.IgnoreCase); //CCR 170491

                lcSql += " ALTER TABLE [" + tcBdNueva + "].[dbo].[" + lcTabla + "] ADD CONSTRAINT [" + lcNombreConstraintValDef + "] " +
                         " DEFAULT ("+lcValorDefecto+") FOR ["+lcCampoDefecto+"]; ";
            }

            if (!string.IsNullOrWhiteSpace(lcSql))  // Esto debería cumplirse siempre pero por si acaso.
            {
                // Ejecutar instrucción para crear todas las constraints de valores por defecto.
                llOk = DB.SQLExec(lcSql);

                if (!llOk)
                {
                    if (string.IsNullOrEmpty(tcTabla))
                        _Error_Message = "Error al crear los valores por defecto de la base de datos " + tcBdNueva;
                    else
                        _Error_Message = "Error al crear los valores por defecto para la tabla " + tcTabla + " de la base de datos " + tcBdNueva;
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }
            }

            


        // GENERAR LA CLAVE PRIMARIA, AUTOMATICAMENTE APARECERA TAMBIEN UN INDICE COMO ESTE
        //
        //
        // ALTER TABLE [2007NA].[dbo].[C_ALBVEN] ADD CONSTRAINT [pk__2006na__c_albven__empnumlet]
        // PRIMARY KEY CLUSTERED ( [EMPRESA] ASC, [NUMERO] ASC, [LETRA] ASC) 
        // WITH ( STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) 
        // ON [eurowind]



        // GENERAR EL RESTO DE INDICES QUE NO SON CLAVE PRIMARIA
        //
        //
        // CREATE NONCLUSTERED INDEX [empcli] ON [2007NA].[DBO].[C_ALBVEN] 
        // ([EMPRESA] ASC,  [CLIENTE] ASC,  [NUMERO] ASC,   [LETRA] ASC) 
        // WITH (STATISTICS_NORECOMPUTE  = OFF, SORT_IN_TEMPDB = OFF, DROP_EXISTING = OFF, IGNORE_DUP_KEY = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [eurowini]



        // GENERAR CONSTRAINT DE VALOR POR DEFECTO DE CAMPO
        // ALTER TABLE [2017VO].dbo].[c_comuni] ADD  CONSTRAINT [df__2017vo__c_comuni__empresa]  DEFAULT ('') FOR [EMPRESA]

        //
        // OJO QUE SI SE CREAN LAS TABLAS MEDIANTE SELECT * INTO [newbd].dboi.tabla from [actbd].dbo.tabla la crea en el gurpo de archivo PRIMARY y no en [eurowind], ver que trascendencia podria tener.

            return true;

        }


        private static bool CrearGrupoEjer_EliminarIndices_ValsDefecto_Tabla(string tcBdOrigen, string tcBdNueva, string tcTabla, DataTable tdtIndices, DataTable tdtValsDefecto)
        {
            bool llOk = false, llEsPrimario = false;
            string lcSql = "", lcNombreIndice = "", lcNombreConstraintValDef = "", lcValorDefecto = "", lcCampoDefecto = "", lcTabla = "", lcFiltroTabla = "";

            tcTabla = tcTabla.ToLower().Trim();
            tcBdNueva = tcBdNueva.ToLower().Trim();
            tcBdOrigen = tcBdOrigen.ToLower().Trim();


            // ELIMINAR CLAVE PRIMARIA Y VALORES POR DEFECTO PARA LA NUEVA TABLA ...
            lcFiltroTabla = !string.IsNullOrEmpty(tcTabla.Trim()) ? "tabla='" + tcTabla + "'" : "";
            
            // En la tabla de índices tenemos tantos registros de un índice como campos componen el índice y nos interesa tener un registro por tabla e índice
            DataView dtView = new DataView(tdtIndices);
            DataTable dtDistinctValues = dtView.ToTable(true, "tabla", "indice", "indice_primario");
            DataRow[] laRows = dtDistinctValues.Select(lcFiltroTabla, "tabla, indice asc");  

            foreach (DataRow loRow in laRows)
            {
                llEsPrimario = Convert.ToBoolean(loRow["indice_primario"]);
                lcNombreIndice = Convert.ToString(loRow["indice"]).Trim();
                lcTabla = Convert.ToString(loRow["tabla"]).Trim();

                if (llEsPrimario)
                {
                    lcNombreIndice = lcNombreIndice.Replace(tcBdOrigen, tcBdNueva);  // En el nombre del índice pirmario aparece el nombre de la bd.
                    lcSql = lcSql + "ALTER TABLE [" + tcBdNueva + "].[dbo].[" + lcTabla + "] DROP CONSTRAINT [" + lcNombreIndice + "]; ";
                }
                else
                {
                    lcSql = lcSql + "DROP INDEX [" + lcNombreIndice + "] ON [" + tcBdNueva + "].[dbo].[" + lcTabla + "]; ";
                }
            }

            // Ejecutar instrucción para crear todos los indices, clave primaria incluida, todo en una unica instruccion, controlo que haya algo que hacer pues caso de una tabla sin indices ni clave primaria
            // aqui no deberia haber nada.
            if (!string.IsNullOrWhiteSpace(lcSql))
            {
                llOk = DB.SQLExec(lcSql);
                if (!llOk)
                {
                    if (string.IsNullOrEmpty(tcTabla))
                        _Error_Message = "Error al eliminar los índices de la base de datos " + tcBdNueva;
                    else
                        _Error_Message = "Error al eliminar los índices para la tabla " + tcTabla + " de la base de datos " + tcBdNueva;
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }
            }


            // ELIMINAR VALORES POR DEFECTO PARA LA NUEVA TABLA ...

            laRows = tdtValsDefecto.Select(lcFiltroTabla);  
            lcSql = "";
            foreach (DataRow loRow in laRows)
            {
                lcNombreConstraintValDef = Convert.ToString(loRow["constr_nombre"]).Trim();
                lcValorDefecto = Convert.ToString(loRow["constr_defin"]).Trim();
                lcCampoDefecto = Convert.ToString(loRow["campo"]).Trim();
                lcTabla = Convert.ToString(loRow["tabla"]).Trim();

                lcNombreConstraintValDef = lcNombreConstraintValDef.Replace(tcBdOrigen, tcBdNueva);  // En el nombre de la constraint aparece el nombre de la bd.

                lcSql += " ALTER TABLE [" + tcBdNueva + "].[dbo].[" + lcTabla + "] DROP CONSTRAINT [" + lcNombreConstraintValDef + "] ; ";
            }

            if (!string.IsNullOrWhiteSpace(lcSql))  // Esto debería cumplirse siempre pero por si acaso.
            {
                // Ejecutar instrucción para crear todas las constraints de valores por defecto.
                llOk = DB.SQLExec(lcSql);

                if (!llOk)
                {
                    if (string.IsNullOrEmpty(tcTabla))
                        _Error_Message = "Error al eliminar los valores por defecto de la base de datos " + tcBdNueva;
                    else
                        _Error_Message = "Error al eliminar los valores por defecto para la tabla " + tcTabla + " de la base de datos " + tcBdNueva;
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }
            }

            return true;

        }

        private static bool CrearGrupoEjer_Actualizar_Indices(string tcBdOrigen, string tcBdNueva, string tcTabla, DataTable tdtIndices)
        {
            bool llOk = false;
            string lcSql = "", lcNombreIndice = "", lcFiltro = "", lcNombreIndiceNuevo = "";

            tcTabla = tcTabla.ToLower().Trim();
            tcBdNueva = tcBdNueva.ToLower().Trim();
            tcBdOrigen = tcBdOrigen.ToLower().Trim();


            // RENOMBRAR CLAVE PRIMARIA ...

            // filtro por indice primario y tabla si existe
            lcFiltro = "indice_primario " +  (!string.IsNullOrEmpty(tcTabla.Trim()) ? " and tabla='" + tcTabla + "'" : "");

            // En la tabla de índices tenemos tantos registros de un índice como campos componen el índice y nos interesa tener un registro por tabla e índice
            DataView dtView = new DataView(tdtIndices);
            DataTable dtDistinctValues = dtView.ToTable(true, "tabla", "indice", "indice_primario");
            DataRow[] laRows = dtDistinctValues.Select(lcFiltro, "tabla, indice asc");

            foreach (DataRow loRow in laRows)
            {
                lcNombreIndice = Convert.ToString(loRow["indice"]).Trim();

                //lcNombreIndiceNuevo = lcNombreIndice.Replace(tcBdOrigen, tcBdNueva);
                lcNombreIndiceNuevo = Regex.Replace(lcNombreIndice, tcBdOrigen, tcBdNueva, RegexOptions.IgnoreCase); //CCR 170491

                lcSql = lcSql + " exec sp_rename '" + lcNombreIndice + "', '" + lcNombreIndiceNuevo + "', 'object'";
            }

            // Ejecutar instrucción para renombrar los nombres de las claves primarias
            if (!string.IsNullOrWhiteSpace(lcSql))
            {
                lcSql = "use [" + tcBdNueva + "]; " + lcSql;
                
                llOk = DB.SQLExec(lcSql);
                if (!llOk)
                {
                    if (string.IsNullOrEmpty(tcTabla))
                        _Error_Message = "Error al renombrar los índices de la base de datos " + tcBdNueva;
                    else
                        _Error_Message = "Error al renombrar los índices para la tabla " + tcTabla + " de la base de datos " + tcBdNueva;
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }
            }

            return true;

        }


        private static bool CrearGrupoEjer_Actualizar_ValoresDefecto(string tcBdOrigen, string tcBdNueva, string tcTabla, DataTable tdtValsDefecto)
        {
            bool llOk = false;
            string lcSql = "", lcNombreConstraintValDef = "", lcFiltroTabla = "", lcNombreConstraintNuevo = "";

            tcTabla = tcTabla.ToLower().Trim();
            tcBdNueva = tcBdNueva.ToLower().Trim();
            tcBdOrigen = tcBdOrigen.ToLower().Trim();

            // CAMBIAR EL NOMBRE DE LOS VALORES POR DEFECTO
            
            // filtrar por tabla
            lcFiltroTabla = !string.IsNullOrEmpty(tcTabla.Trim()) ? "tabla='" + tcTabla + "'" : "";
            
            DataRow[] laRows = tdtValsDefecto.Select(lcFiltroTabla);

            // Montar instrucción para hacer el cambio en una sola instrucción
            foreach (DataRow loRow in laRows)
            {
                lcNombreConstraintValDef = Convert.ToString(loRow["constr_nombre"]).Trim();
                
                // Actualizar el nombre 
                //lcNombreConstraintNuevo = lcNombreConstraintValDef.Replace(tcBdOrigen, tcBdNueva);
                lcNombreConstraintNuevo = Regex.Replace(lcNombreConstraintValDef, tcBdOrigen, tcBdNueva, RegexOptions.IgnoreCase); //CCR 170491

                lcSql = lcSql + " exec sp_rename '" + lcNombreConstraintValDef + "', '" + lcNombreConstraintNuevo + "', 'object'";
            }


            // Ejecutar instrucción para cambiar todos los valores por defecto
            if (!string.IsNullOrWhiteSpace(lcSql))
            {
                lcSql = "use [" + tcBdNueva + "]; " + lcSql;

                llOk = DB.SQLExec(lcSql);
                if (!llOk)
                {
                    if (string.IsNullOrEmpty(tcTabla))
                        _Error_Message = "Error al renombrar los valores por defecto de la base de datos " + tcBdNueva;
                    else
                        _Error_Message = "Error al renombrar los valores por defecto para la tabla " + tcTabla + " de la base de datos " + tcBdNueva;
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }
            }

            return true;
        }



        private static bool CrearGrupoEjer_CrearTablasBd(string tcTipoBd, string tcNombreAddon="", string tcBdAddonOri="", string tcBdAddonNuevo="")
        {
            bool llOk = false;

            string lcSql = "", lcTabla = "";
            string lcBdOrigen="", lcBdNueva = "";

            switch (tcTipoBd)
            { 
                case "COMUNES":
                    lcBdOrigen = GrupoempTools._DbComunesGrOrigen;
                    lcBdNueva = GrupoempTools._DbComunesGrNuevo;
                    break;
                case "GESTION":
                    lcBdOrigen = GrupoempTools._DbEjerGrOrigen;
                    lcBdNueva = GrupoempTools._DbEjerGrNuevo;
                    break;
                case "ADDON":
                    lcBdOrigen = tcBdAddonOri;
                    lcBdNueva = tcBdAddonNuevo;
                    break;
            }

            // En la tabla COMUNES!TABSYS guardamos las tablas de COMUNES y GESTION que son de sistema y no deben borrarse, por tanto en el nuevo grupo se respetará su contenido
            // En el caso de los Addons tambien existe la tabla TABSYS. De momento Sage50 instala 5 addons de forma predeterminada aunque no tienen por estar visibles (TPV, AMORTIZA, MAYORIST, LOTES, INFORAUT)

            // El proceso de creación de tablas revisa todas las tablas de la base de datos y si la detectada en la lista de tabla que no deben borrarse la deja igual, y si detecta que está en la lista
            // de tablas a las que hay que aplicar algún proceso, la procesa.

            if (_Log)
                Guardar_Mensaje("INICIO PROCESO DE CREACION DE TABLAS EN LA BASE DE DATOS DE " + tcTipoBd + " [" + lcBdNueva + "] " + tcNombreAddon + Environment.NewLine);




            // TABLAS DE SISTEMA QUE NO DEBEN BORRARSE, CONSULTAR TABSYS
            DataTable ldtTablasNoborr = new DataTable();
            lcSql = "select tabla from " + DB.SQLDatabaseReal(tcTipoBd == "COMUNES" || tcTipoBd == "GESTION" ? _DbComunesGrOrigen : tcBdAddonOri, "tabsys") + " " +
                      (tcTipoBd == "COMUNES" || tcTipoBd == "GESTION" ? "where basedatos='" + tcTipoBd + "'" : "");
            DB.SQLExec(lcSql, ref ldtTablasNoborr);
            List<string> lstTablasNoBorr = ldtTablasNoborr.AsEnumerable().Select(x => x[0].ToString().Trim().ToUpper()).ToList();

            if (_Log)
                Guardar_Mensaje("Detectadas " + lstTablasNoBorr.Count.ToString() + " tablas de sistema en la base de datos de " + tcTipoBd + " (" + lcBdOrigen + ")" + tcNombreAddon + " cuyo contenido no debe borrarse.");




            // TABLAS CON ALGUN TRATAMIENTO ESPECIAL A REALIZAR

            // Tratamientos: eliminar registros de empresas sobrantes, eliminar registros de usuarios diferentes de SUPERVISOR, 
            // poner contadores a 0
            List<string> lstTablasEspeciales = null;

            lstTablasEspeciales = GrupoempTools.CrearGrupoEjer_Tablas_Especiales(tcTipoBd, tcNombreAddon);

            // Cualquier tabla que esté en cualquiera de las dos listas anteriores (lstTablasNoBorr, lstTablasEspeciales) no se borrará.

            
            
            // OBTENER TODAS LAS TABLAS DE LA BASE DE DATOS
            if (_Log)
                Guardar_Mensaje("Consultando tablas existentes en la base de datos  de " + tcTipoBd + " " + tcNombreAddon + " " + lcBdOrigen);

            DataTable ldtTablasBd = new DataTable();
            try
            {
                lcSql = "SELECT table_name as tabla  " +
                        "FROM [" + lcBdOrigen + "].INFORMATION_SCHEMA.TABLES " +
                        "ORDER BY table_name ";
                DB.SQLExec(lcSql, ref ldtTablasBd);
            }
            catch (Exception loEx)
            {
                _Error_Message = "No se puedieron obtener las tablas existentes en la base de datos de " + tcTipoBd + " " + lcBdOrigen;
                if (_Log)
                {
                    Guardar_Mensaje(_Error_Message);
                    Guardar_Mensaje(loEx.Message);
                }
                return false;
            }

            
            
            
            // PROCESAR CADA UNA DE LAS TABLAS DE LA BASE DE DATOS ORIGEN PARA CREAR LA CORRESPONDIENTE EN LA BD DESTINO

            // Obtener en un DataTable los indices de las tablas de la base de datos origen, los utilizaremos para crear los indices en las tablas de la bd. destino
            DataTable ldtIndicesBdOri = new DataTable();
            llOk = DB._DbIndicesCampos(lcBdOrigen, ref ldtIndicesBdOri);
            if (!llOk)
            {
                _Error_Message = "No se pudieron obtener los índices de las tablas de la base de datos de " + tcTipoBd + " " + lcBdOrigen;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }


            // Obtener en un DataTable los valores por defecto de las tablas de la base de datos origen, los utilizaremos para crear los valores por defecto en las tablas de la bd. destino
            DataTable ldtValsDefecto = new DataTable();
            llOk = DB._DbValoresDefectoCampos(lcBdOrigen, ref ldtValsDefecto);
            if (!llOk)
            {
                _Error_Message = "No se pudieron obtener los valores por defecto de las tablas de la base de datos de " + tcTipoBd + " " + lcBdOrigen;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }
            


            // Nos recorremos las tablas de la base de datos y si la tabla en questión no está ni en la lista de tablas no borrables, 
            // ni está en la lista de tablas a la que realizar algún proceso, la creamos vacía
            bool llConDatos = true;
            foreach (DataRow loRow in ldtTablasBd.Rows)
            {
                lcTabla = Convert.ToString(loRow["tabla"]).Trim().ToUpper();

                llConDatos = lstTablasNoBorr.Contains(lcTabla) || (lstTablasEspeciales != null ? lstTablasEspeciales.Contains(lcTabla) : false);
                
                if (_Log)
                    Guardar_Mensaje("Creando tabla " + (llConDatos ? "con datos" : "sin datos") + lcBdNueva + "." + lcTabla);

                // Creo la tabla en la nueva base de datos a partir de la tabla del mismo nombre en el grupo origen
                try
                {
                    DB.SQLExec("select "+ (llConDatos==false ? " top 0 " : "")+" * into " + DB.SQLDatabaseReal(lcBdNueva, lcTabla.ToLower()) + " from " + DB.SQLDatabaseReal(lcBdOrigen, lcTabla));
                }
                catch (Exception loEx)
                {
                    _Error_Message = "No se pudo crear la tabla "+lcTabla+" "+ ( llConDatos ? "con datos " : "sin datos ")+" en la base de datos "+ lcBdNueva +
                                     " a partir de la tabla " +lcTabla+" de la base de datos "+lcBdOrigen;
                    if (_Log)
                    {
                        Guardar_Mensaje(_Error_Message);
                        Guardar_Mensaje(loEx.Message);
                    }
                    return false;
                }

                // Creo los índices primarios y secundarios y todas las constraints de valores por defecto de la tabla.
                llOk = GrupoempTools.CrearGrupoEjer_CrearIndices_ValsDefecto_Tabla(lcBdOrigen,lcBdNueva, lcTabla, ldtIndicesBdOri, ldtValsDefecto);   // Pasamos también la bd origen pues en el nombre del indice primario y de las constraints de valor defecto aparece este nombre y hay que cambiarlo por la nueva bd.
                
                if (!llOk)
                {
                    _Error_Message = "No se pudiero crear los índices y asignar los valores por defecto correspondientes en la tabla de la base de datos de " + tcTipoBd + " " + lcBdNueva + " " + lcTabla;
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }
            }

            if (_Log)
            {
                Guardar_Mensaje(Environment.NewLine);
                Guardar_Mensaje("FIN PROCESO DE CREACION DE TABLAS EN LA BASE DE DATOS DE " + tcTipoBd + " [" + lcBdNueva + "] " + tcNombreAddon + Environment.NewLine);
            }


            return true;
        }

        private static bool CrearGrupo_CrearTablasBds()
        {
            bool llOk = false;

            ActualizarBarraProgreso();

            if (_Log)
                Guardar_Mensaje("INICIO PROCESO CREACION DE TABLAS EN LAS BASES DE DATOS DEL NUEVO GRUPO." + Environment.NewLine);


            // CREACION DE TABLAS EN LA NUEVA BASE DE DATOS COMUNES DEL NUEVO GRUPO A PARTIR DE LAS TABLAS DE COMUNES DEL GRUPO ORIGEN
            llOk = GrupoempTools.CrearGrupoEjer_CrearTablasBd("COMUNES");
            ActualizarBarraProgreso();
            if (!llOk)
                return false;


            // CREACION DE TABLAS EN LA NUEVA BASE DE DATOS EJERCICIO DEL NUEVO GRUPO A PARTIR DE LAS TABLAS DE EJERCICIO DEL GRUPO ORIGEN
            llOk = llOk && GrupoempTools.CrearGrupoEjer_CrearTablasBd("GESTION");
            ActualizarBarraProgreso();
            if (!llOk)
                return false;


            // CREACION DE TABLAS EN LAS NUEVAS BASES DE DATOS DE ADDONS DEL NUEVO GRUPO A PARTIR DE LAS TABLAS DEL ADDON DEL GRUPO ORIGEN
            string lcNombreAddon = "", lcNewBdAddon = "", lcSufijoGrOrigen="",lcOriBdAddon="";
            lcSufijoGrOrigen = GrupoempTools._DbEjerGrOrigen.Trim().Substring(4,2);
            foreach (DataRow loRow in _dtBdAddonsGrNuevo.Rows)
            {
                lcNombreAddon = Convert.ToString(loRow["nombre"]).Trim().ToUpper();
                lcNewBdAddon = Convert.ToString(loRow["nom_conex"]).Trim();

                lcOriBdAddon = lcNewBdAddon.Substring(0,6)+lcSufijoGrOrigen;

                //  CREACION DE TABLAS EN LA NUEVA BASE DE DATOS DE ADDONS DEL NUEVO GRUPO
                llOk = GrupoempTools.CrearGrupoEjer_CrearTablasBd("ADDON", lcNombreAddon, lcOriBdAddon, lcNewBdAddon);                
                if (!llOk)
                    return false;
            }
            ActualizarBarraProgreso();

            if (_Log)
                Guardar_Mensaje("FIN PROCESO CREACION DE TABLAS EN LAS BASES DE DATOS DEL NUEVO GRUPO." + Environment.NewLine);

            ActualizarBarraProgreso();

            return true;
        }


        private static bool CrearGrupo_AjustarDatosBds()
        {
            bool llOk = false;
            string lcOrigenBdAddon = string.Empty;

            ActualizarBarraProgreso();

            if (_Log)
                Guardar_Mensaje("INICIO PROCESO AJUSTE DE DATOS EN LAS BASES DE DATOS DEL NUEVO GRUPO."+Environment.NewLine);


            // AJUSTES EN NUEVA BASE DE DATOS COMUNES DE NUEVO GRUPO
            llOk = GrupoempTools.AjustarDatos_Bd(_DbComunesGrNuevo, "COMUNES");
            ActualizarBarraProgreso();
            if (!llOk)
                return false;

            // Eliminar y crear las claves primarias y valores por defecto
            llOk = Restore_Indices_ValoresDefecto(_DbComunesGrOrigen, _DbComunesGrNuevo);
            ActualizarBarraProgreso();
            if (!llOk)
                return false;


            // AJUSTES EN NUEVA BASE DE DATOS EJERCICIO DEL NUEVO GRUPO
            llOk = llOk && GrupoempTools.AjustarDatos_Bd(_DbEjerGrNuevo, "GESTION");
            ActualizarBarraProgreso();
            if (!llOk)
                return false;

            // Eliminar y crear las claves primarias y valores por defecto
            llOk = Restore_Indices_ValoresDefecto(_DbEjerGrOrigen, _DbEjerGrNuevo);
            ActualizarBarraProgreso();
            if (!llOk)
                return false;


            // AJUSTES EN NUEVA BASE DE DATOS DE ADDONS DEL NUEVO GRUPO
            string lcNombreAddon = "", lcNewBdAddon = "";
            foreach (DataRow loRow in _dtBdAddonsGrNuevo.Rows)
            {
                lcNombreAddon = Convert.ToString(loRow["nombre"]).Trim().ToUpper();
                lcNewBdAddon = Convert.ToString(loRow["nom_conex"]).Trim();

                //  AJUSTES EN NUEVA BASE DE DATOS DE ADDON
                llOk = GrupoempTools.AjustarDatos_Bd(lcNewBdAddon, "ADDON", lcNombreAddon);
                if (!llOk)
                    return false;

                // Obtener el nombre anterior de la base de datos del addon
                DataRow [] loRowViejo = _dtBdAddonsGrOrigen.Select("nombre = '" + lcNombreAddon + "'");
                if (loRowViejo.Count() > 0) 
                {
                    lcOrigenBdAddon = Convert.ToString(loRowViejo[0]["nom_conex"]).Trim();

                    if (!string.IsNullOrEmpty(lcOrigenBdAddon))
                    {
                        // Eliminar y crear las claves primarias y valores por defecto
                        llOk = Restore_Indices_ValoresDefecto(lcOrigenBdAddon, lcNewBdAddon);
                        if (!llOk)
                            return false;
                    }
                }
            }
            ActualizarBarraProgreso();

            // Si se ha configurado el nuevo grupo para utilizar las mismas anchuras de campos que el grupo origen ya hemos acabado, solo resta añadir las cuentas contables básicas a la tabla cuentas.
            //
            if (GrupoempTools._LongitudesEstandar == false)
            {
                if (_Log)
                    Guardar_Mensaje("CREACIÓN DEL NUEVO GRUPO CON LAS MISMAS LONGITUDES DE CAMPO QUE EN EL GRUPO ORIGEN." + Environment.NewLine);
            }
            else
            {
                // Se ha configurado el nuevo grupo para utilizar anchuras de campos standar, hay que detectar que anchuras son diferentes en el grupo origen de las standar y hacer los cambios según se detecte.
                llOk = CrearGrupo_Longitudes();
                if (!llOk)
                    return false;
            }
            ActualizarBarraProgreso();

            // Añadir las cuentas contables básicas a la tabla CUENTAS del nuevo grupo
            AjustarTablaCuentas_Paso2();
            ActualizarBarraProgreso();

            if (_Log)
            {
                Guardar_Mensaje("PROCESO DE AJUSTE DE DATOS EN LAS BASES DE DATOS DEL NUEVO GRUPO FINALIZADO CORRECTAMENTE."+Environment.NewLine);
                Guardar_Mensaje("FIN PROCESO AJUSTE DE DATOS EN LAS BASES DE DATOS DEL NUEVO GRUPO."+Environment.NewLine);
            }

            ActualizarBarraProgreso();

            return true;
        }


        private static bool CrearGrupo_AjustarDatos_TablaComunes(string tcTabla, string tcNombreBaseDatos)
        {
            string lcSql = "";
            DataTable ldtAuxiliar =  new DataTable();

            

            switch (tcTabla)
            {
                case "ACCESOLIC":
                    // ACCESOLIC en principio mantener lo que haya en el grupo origen puesto que la licencia no cambia, en esta tabla hay un registro para COMUNES y para cada addon instalado
                    // Como al nuevo grupo solo van a parar los addons estandar podria ser que quedase algun registro en ACCESOLIC del nuevo grupo correspondiente a un modulo que no tenga en COMUNES!MODULOS
                    // pero no deberia afectar pues al ser la misma licencia el MD5 estara calculado correctamente == > De momento no hacer nada.
                    break;

                case "CODCOM":
                    // En principio debe respetarse todo lo que hay en el grupo origen, la licencia es la misma en el nuevo grupo y no veo que haya ningún contador.
                    // Hay 2 campos más SAGEID y PRODUCTNAME que no se si se deberá hacer algo.
                    lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CODCOM") + " " +
                            "SET EMAILO365='', IDCALO365='', TOKENO365='', RRIDSO365='', CMPCALO365='', BROWSER=0, PRCLIENT=0, PLANTILLAS=0 ";
                    DB.SQLExec(lcSql);
                    break;

                case "EJERCICI":
                    DB.SQLExec( "TRUNCATE TABLE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "EJERCICI"));

                    lcSql = "INSERT INTO "+ DB.SQLDatabaseReal(tcNombreBaseDatos, "EJERCICI") + " ([ANY], RUTA, RUTASER, CONEXION, PERIODOINI, PERIODOFIN, PREDET, ANTERIOR) VALUES (" +
                            "'" + _EjerNuevo +"', "+
                            "'" + _DbEjerGrNuevo + "', " +
                            "'" + _DbEjerGrNuevo + "', " +
                            "'" + _DbEjerGrNuevo + "', " +
                            DB.SQLString(_FechaIniEjerNuevo) + ", "+
                            DB.SQLString(_FechaFinEjerNuevo) + ", "+
                            DB.SQLTrue() + ", "+
                            "'')";
                    DB.SQLExec(lcSql);
                    break;

                case "FORMULS":
                    // Esta tabla ya está en TABSYS conforme no debe borrarse pero se añadió además a la lista de tablas que pueden requerir algun tratamiento
                    // especial por Hay unos campos de tipo CHECKSUM que en principio no deberia afectar que no se recalculen, dejamos el caso abierto por si hiciera falta
                    // hacer algo.
                    break;

                case "LETRAS":
                    // Dejar solo letra por defecto
                    DB.SQLExec("TRUNCATE TABLE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "LETRAS"));

                    lcSql = "INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "LETRAS") + " (CODIGO, NOMBRE) VALUES ('SF','SERIE DEFECTO')";
                    lcSql += "INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "LETRAS") + " (CODIGO, NOMBRE) VALUES ('SD','SERIE ALBARANES AUTOMATICOS')";   // Bug 161762
                    DB.SQLExec(lcSql);
                    break;

                case "LICENCIA":
                    // En principio no debe hacerse nada pues es la misma licencia que el grupo origen
                    break;

                case "MODULOS":
                    // Dejar solo los modulos standar y cambiar los nombres de las bd en los campos NOM_CONEX, TABLAS y el comentario para que ponga la nueva fecha de creación

                    string lcCadenaWhereAddons = "";
                    foreach (string lcAddon in GrupoempTools._AddonsInstal)
                        lcCadenaWhereAddons += " NOMBRE != '" + lcAddon.Trim().ToUpper() + "' AND ";

                    if (!string.IsNullOrWhiteSpace(lcCadenaWhereAddons))
                    {
                        lcCadenaWhereAddons = lcCadenaWhereAddons.Substring(0, lcCadenaWhereAddons.Length - 4);

                        lcSql = "DELETE FROM " + DB.SQLDatabaseReal(tcNombreBaseDatos, "MODULOS") + " " +
                                "WHERE " + lcCadenaWhereAddons;
                        DB.SQLExec(lcSql);
                    }

                    
                    // Dejamos todos los ADDONS desactivados en el nuevo grupo
                    lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "MODULOS") + " " +
                            "SET CONTROL='', ID=0," +
                            "VISIBLE=" + DB.SQLFalse() + "," +
                            "INSTALADO=" + DB.SQLFalse() + ",TIPO=0 "+    
                            "WHERE (TIPO != 4 OR NOMBRE = 'ECOMMERCE' OR NOMBRE = 'PREVENTA')";   //Bug 132259, Bug 174401
                    DB.SQLExec(lcSql);
                    
                    //Bug 132259 - Los addons de tipo 4, marcarlos como instalados
                    lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "MODULOS") + " " +
                            "SET CONTROL='', ID=0," +
                            "VISIBLE=" + DB.SQLTrue() + "," +
                            "INSTALADO=" + DB.SQLTrue() + " " +  
                            "WHERE TIPO = 4 AND NOMBRE <> 'ECOMMERCE' AND NOMBRE <> 'PREVENTA'"; //Bug 174401
                    DB.SQLExec(lcSql);

                    string lcNombreAddon = "";
                    string lcBdAddon = "";
                    string lcComentario = "";

                    foreach (DataRow loRow in _dtBdAddonsGrNuevo.Rows)
                    {
                        lcNombreAddon = Convert.ToString(loRow["nombre"]).Trim().ToUpper();
                        lcBdAddon = Convert.ToString(loRow["nom_conex"]).Trim().ToUpper();
                        lcComentario = "Instalación del módulo de " + lcNombreAddon + " Fecha: " + DateTime.Today.Date.ToString("dd/MM/yy");
                                    
                        lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "MODULOS") + " " +
                                "SET NOM_CONEX='" + lcBdAddon + "', "+
                                "TABLAS='" + lcBdAddon + "', " +
                                "COMENTARIO='" + lcComentario + "' "+
                                "WHERE NOMBRE='" + lcNombreAddon + "'";
                        DB.SQLExec(lcSql);
                    }
                    break;
                            
                case "OPERARIO":
                    // Dejar solo operario por defecto
                    DB.SQLExec("TRUNCATE TABLE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "OPERARIO"));

                    DB.SQLExec("INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "OPERARIO") + " (CODIGO, NOMBRE) VALUES ('01','OPERARIO PRINCIPAL')");
                    break;
                            
                case "OPC_USER":
                    // Dejar solo los opc_user del operario 01
                    DB.SQLExec("TRUNCATE TABLE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "OPC_USER"));
                    
                    string lcBdOpcUser = DB.SQLDatabaseReal(tcNombreBaseDatos, "OPC_USER");
                    lcSql =  "insert into " + lcBdOpcUser + " (opctpv, operario, valor) values ('01','01',1); ";
                    lcSql += "insert into " + lcBdOpcUser + " (opctpv, operario, valor) values ('02','01',1); ";
                    lcSql += "insert into " + lcBdOpcUser + " (opctpv, operario, valor) values ('03','01',0); ";
                    lcSql += "insert into " + lcBdOpcUser + " (opctpv, operario, valor) values ('04','01',0); ";
                    lcSql += "insert into " + lcBdOpcUser + " (opctpv, operario, valor) values ('05','01',0); ";
                    lcSql += "insert into " + lcBdOpcUser + " (opctpv, operario, valor) values ('06','01',1); ";
                    lcSql += "insert into " + lcBdOpcUser + " (opctpv, operario, valor) values ('07','01',1); ";
                    lcSql += "insert into " + lcBdOpcUser + " (opctpv, operario, valor) values ('08','01',1); ";
                    lcSql += "insert into " + lcBdOpcUser + " (opctpv, operario, valor) values ('09','01',0); ";
                    lcSql += "insert into " + lcBdOpcUser + " (opctpv, operario, valor) values ('10','01',0); ";
                    lcSql += "insert into " + lcBdOpcUser + " (opctpv, operario, valor) values ('11','01',0); ";

                    DB.SQLExec(lcSql);
                    break;

                case "OPCEMP":
                case "OTROSCFG":
                    // Dejar solo los registros de la empresa 01
                    DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, tcTabla) + " WHERE EMPRESA != '"+_EmpresaGrNuevo+"' ");

                    // Marco/desmarco el opcflag de trabajar con año partido según se ha especificado.
                    if (tcTabla == "OPCEMP")
                    {
                        
                        // Todos a false excepto los que se especifican mas abajo que se activaran
                        lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "OPCEMP") + " " +
                                "SET ESTADO = " + DB.SQLFalse() + " " +
                                "WHERE EMPRESA = '" + _EmpresaGrNuevo + "' ";
                        DB.SQLExec(lcSql);

                        // Bug 213524  Activar el opcflag 10035 - ORDENAR LÍNEAS FACTURACIÓN GENERAL ALBARANES VENTA POR FECHA       
                        // Bug 147789: añado los opcflags de listas previas en documentos y en mantenimientos (9100, 9110) pues se deben activar al crear un nuevo
                        // grupo, al igual que lo están cuando se instala Sage50 por primera vez.
                        // Bug 171578: Al crear un nuevo grupo de empresas nuevo no activar el add-on de Fabricación con código 10009
                        List<int> lstOpcFlagsActivar = new List<int>() { 9003, 9040, 9100, 9110, 10023, 10035, 10314, 10330, 10339, 10405, 10920, 
                                                                         20008, 20014, 30003, 30015, 30020, 31017, 34003, 40002, 
                                                                         50002, 50003, 14030, 20050, 30010, 30203 };
                        lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "OPCEMP") + " " +
                                "SET ESTADO = " + DB.SQLTrue() + " " +
                                "WHERE EMPRESA = '" + _EmpresaGrNuevo + "' AND (";

                        foreach (int lnOpc in lstOpcFlagsActivar)
                            lcSql += " TIPO_OPC = " + lnOpc.ToString() + " OR ";

                        lcSql = lcSql.Substring(0, lcSql.Length - 3) + ")";
                        DB.SQLExec(lcSql);


                        // Opcflag de configuracion de año partido.
                        DB.SQLExec("select empresa from " + DB.SQLDatabaseReal(tcNombreBaseDatos, "OPCEMP") + " " +
                                   "where empresa='" + _EmpresaGrNuevo + "' and tipo_opc=9008", ref ldtAuxiliar);
                        if (ldtAuxiliar.Rows.Count == 0)
                        {
                            // En teoria esto no deberia ocurrir pero nos aseguramos
                            DB.SQLExec("INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "OPCEMP") + " (EMPRESA,TIPO_OPC,ESTADO) " + 
                                       "VALUES ('" + _EmpresaGrNuevo + "',9008,"+ ( GrupoempTools._CfgEjerPartiGrNuevo ? DB.SQLTrue() : DB.SQLFalse() )+")");
                        }
                        else
                        {

                            lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "OPCEMP") + " " +
                                    "SET ESTADO="+ ( GrupoempTools._CfgEjerPartiGrNuevo ? DB.SQLTrue() : DB.SQLFalse() )+" "+
                                    "WHERE EMPRESA='" + _EmpresaGrNuevo + "' AND TIPO_OPC=9008";
                            DB.SQLExec(lcSql);
                        }


                        // Tratamiento especial opcflag de "ACTIVAR CONTRASEÑAS SEGURAS DE USUARIO". 
                        // Tanto si se ha configurado que se arrastren usuarios del grupo origen al grupo destino como si no (en este último caso se pasa solo el usuario SUPERVISOR) debe arrastrarse 
                        // también obligatoriamente el valor de dicho opcflag puesto que en la tabla de usuarios estan las contraseñas.

                        // Captar valor del opcflag en la empresa del grupo origen.
                        bool llValorOpcFlag = false;

                        DB.SQLExec("select estado from " + DB.SQLDatabaseReal(_DbComunesGrOrigen, "OPCEMP") + " " +
                                    "where empresa='" + _EmpresaGrNuevo + "' and tipo_opc=50030", ref ldtAuxiliar);
                        if (ldtAuxiliar.Rows.Count == 1)
                            llValorOpcFlag = Convert.ToBoolean(ldtAuxiliar.Rows[0]["estado"]);


                        // Buscamos el opcemp en el grupo destino, si no existe el registro lo creamos, sino lo updatamos, siempre con el valor del opcflag hallado en el grupo origen.
                        DB.SQLExec("select empresa from " + DB.SQLDatabaseReal(tcNombreBaseDatos, "OPCEMP") + " " +
                                    "where empresa='" + _EmpresaGrNuevo + "' and tipo_opc=50030", ref ldtAuxiliar);
                        if (ldtAuxiliar.Rows.Count == 0)
                        {
                            DB.SQLExec("INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "OPCEMP") + " (EMPRESA,TIPO_OPC,ESTADO) " +
                                        "VALUES ('" + _EmpresaGrNuevo + "',50030," + (llValorOpcFlag ? DB.SQLTrue() : DB.SQLFalse()) + ")");
                        }
                        else
                        {

                            lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "OPCEMP") + " " +
                                    "SET ESTADO=" + (llValorOpcFlag ? DB.SQLTrue() : DB.SQLFalse()) + " " +
                                    "WHERE EMPRESA='" + _EmpresaGrNuevo + "' AND TIPO_OPC=50030";
                            DB.SQLExec(lcSql);
                        }


                        //Bug 161447 - Activar el opcflag "AMPLIAR DEFINICIÓN EN VENTAS" si en el grupo principal tenemos el addon de conceptos facturables
                        if (AddonGrupoOrigen("ConceptosFacturables"))
                            ActivarOpcflag(tcNombreBaseDatos, 10006, true);

                        // Activamos el opcflag "DESCRIPCIÓN LARGA POR DEFECTO EN LAS DEFINICIONES DEBE Y HABER EN ASIENTOS FACTURAS"
                        // Task 191494
                        ActivarOpcflag(tcNombreBaseDatos, 30203, true);
                    }
                    else if (tcTabla == "OTROSCFG")
                    {
                        DB.SQLExec("select empresa from " + DB.SQLDatabaseReal(tcNombreBaseDatos, "OTROSCFG") + " where empresa='" + _EmpresaGrNuevo + "'", ref ldtAuxiliar);
                        if (ldtAuxiliar.Rows.Count == 0)
                        {
                            // En teoria esto no deberia ocurrir pero nos aseguramos
                            DB.SQLExec("INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "OTROSCFG") + " (EMPRESA) VALUES ('" + _EmpresaGrNuevo + "')");
                        }
                    }

                    break;

                case "OPCESPUS":
                case "PERF_USERS":
                case "USRBROWSER":
                case "USRWIDGET":
                case "ACCE_MON":
                    // Dejar solo los registros del usuario SUPERVISOR o de todos los usuarios en función de si arrastramos usuarios o no
                    if (!_ConservarUsuarios)
                    {
                        DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, tcTabla) + " WHERE USUARIO!='SUPERVISOR'");
                    }
                    break;

                case "PRGS":
                    // Dejar solo los modulos standar 
                    string lcCadenaWhereMods = "";
                    foreach (string lcAddon in GrupoempTools._AddonsInstal)
                        lcCadenaWhereMods += " MODULO != '" + lcAddon.Trim().ToUpper() + "' AND ";

                    if (!string.IsNullOrWhiteSpace(lcCadenaWhereMods))
                    {
                        lcCadenaWhereMods = lcCadenaWhereMods.Substring(0, lcCadenaWhereMods.Length - 4);
                        lcSql = "DELETE FROM " + DB.SQLDatabaseReal(tcNombreBaseDatos, "PRGS") + " " +
                                "WHERE "+lcCadenaWhereMods;
                        DB.SQLExec(lcSql);
                    }
                    break;

                case "OPCINDICA":
                    // Esta tabla ya está en TABSYS conforme no debe borrarse pero se añadió además a la lista de tablas que pueden requerir algun tratamiento
                    // especial por Hay unos campos de tipo CHECKSUM que en principio no deberia afectar que no se recalculen, dejamos el caso abierto por si hiciera falta
                    // hacer algo.
                    break;

                case "USRDESKTOP":
                    // Si conservamos usuarios no tocaremos nada, si no conservamos usuarios dejamos solo los escritorios del SUPERVISOR y el base el cual no tiene declarado USUARIO
                    if (!_ConservarUsuarios)
                    {
                        DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, "USRDESKTOP") + " WHERE USUARIO!='' AND USUARIO!='SUPERVISOR'");
                    }
                    break;

                case "USUARIOS":
                    // Si conservamos usuarios no tocaremos nada, si no conservamos usuarios dejamos solo los escritorios del SUPERVISOR y el base el cual no tiene declarado USUARIO
                    if (!_ConservarUsuarios)
                    {
                        DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, "USUARIOS") + " WHERE CODIGO != 'SUPERVISOR' AND CODIGO != 'SAGESYSTEM' AND IDUSUARIO = '' ");
                    }
                    
                    string lcGrupoActual = tcNombreBaseDatos.Substring(4);
                    string lcGrupoPripal = _Obtener_CodGrupoPripal(DB.DbComunes.Trim().Substring(4, 4));

                    // Para evitar "mandangas", vaciamos la tabla antes de hacer la inserción
                    DB.SQLExec("DELETE FROM " + DB.SQLDatabase("EUROWINSYS", "accesogrup") + 
                                " FROM " + DB.SQLDatabase("EUROWINSYS", "accesogrup") + " a " +
                                " INNER JOIN ( " +
                                                " SELECT DISTINCT c.IDSAGE50, " + DB.SQLString(lcGrupoActual) + " as GRUPO, c.MODULO, c.USUARIO " +
                                                " FROM " + DB.SQLDatabaseReal(tcNombreBaseDatos, "usuarios") + " a " +
                                                " INNER JOIN " + DB.SQLDatabase("EUROWINSYS", "uniusers") + " b on a.idusuario = b.IDUSUARIO " +
                                                " INNER JOIN " + DB.SQLDatabase("EUROWINSYS", "accesogrup") + " c on b.IDSAGE50 = c.IDSAGE50 " +
                                                " WHERE a.idusuario != '' and c.grupo = " + DB.SQLString(lcGrupoPripal) +
                                "            ) b ON a.idsage50 = b.idsage50 AND a.grupo = b.grupo AND a.modulo = b.modulo AND a.usuario = b.usuario ");

                    // Crear registro en tabla EUROWINSYS.ACCESOGRUP para el nuevo grupo que se crea 
                    DB.SQLExec("INSERT INTO " + DB.SQLDatabase("EUROWINSYS", "accesogrup") + " (IDSAGE50, GRUPO, MODULO, USUARIO, NIVEL, GUID_ID) " +
                                " SELECT DISTINCT c.IDSAGE50, " + DB.SQLString(lcGrupoActual) + " as GRUPO, c.MODULO, c.USUARIO, CASE WHEN c.USUARIO = 'SUPERVISOR' THEN c.NIVEL ELSE " + (_ConservarUsuarios ? " c.NIVEL " : DB.SQLString(0)) + " END as NIVEL, c.GUID_ID " +
                                " FROM " + DB.SQLDatabaseReal(tcNombreBaseDatos, "usuarios") + " a " +
                                " INNER JOIN " + DB.SQLDatabase("EUROWINSYS", "uniusers") + " b on a.idusuario = b.IDUSUARIO " +
                                " INNER JOIN " + DB.SQLDatabase("EUROWINSYS", "accesogrup") + " c on b.IDSAGE50 = c.IDSAGE50 " +
                                " WHERE a.idusuario != '' and c.grupo = " + DB.SQLString(lcGrupoPripal));
                    
                    break;

                case "COMPRCNF":
                    lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "COMPRCNF") + " " +
                            "SET NUMSERIE=100000000000";   
                    DB.SQLExec(lcSql);
                    break;

                case "DATA_IV2":
                case "DATA_RE2":

                    // Vaciamos el contenido que pudiera haber, pudieramos haber conseguido lo mismo quitando estas 2 tablas de las lista de tablas con procesos
                    // especiales a realizar pero lo dejamo abierto por si hubiera que hacer algún cambio en un futuro. Así pues, vacío las tablas manualmente.
                    DB.SQLExec("TRUNCATE TABLE " + DB.SQLDatabaseReal(tcNombreBaseDatos, tcTabla));

                    if(GrupoempTools._CfgEjerPartiGrNuevo)
                    {
                        lcSql = String.Empty;
                        int mesesPorPerido = 12 / 4;

                        DateTime inicioPeriodo = new DateTime(Convert.ToInt32(_EjerNuevo), 1, 1);                        

                        for (int periodo = 1; periodo <= 4; periodo++)
                        {
                            DateTime ultimoDiaPeriodo = inicioPeriodo.AddMonths(periodo * mesesPorPerido).AddDays(-1);
                            string lcFechaFinPeriodo = DB.SQLString(ultimoDiaPeriodo);

                            lcSql += "INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, tcTabla) + " (PERIODO, SOPOR, REPER, EMPRESA, EJERCICIO) " +
                                        "VALUES (" + periodo + ", " + lcFechaFinPeriodo + ", " + lcFechaFinPeriodo + ", " + DB.SQLString(_EmpresaGrNuevo) + "," + _EjerNuevo + "); ";
                        }
                        
                        inicioPeriodo = inicioPeriodo.AddYears(1);

                        for (int periodo = 1; periodo <= 4; periodo++)
                        {
                            DateTime ultimoDiaPeriodo = inicioPeriodo.AddMonths(periodo * mesesPorPerido).AddDays(-1);
                            string lcFechaFinPeriodo = DB.SQLString(ultimoDiaPeriodo);

                            lcSql += "INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, tcTabla) + " (PERIODO, SOPOR, REPER, EMPRESA, EJERCICIO) " +
                                        "VALUES (" + periodo + ", " + lcFechaFinPeriodo + ", " + lcFechaFinPeriodo + ", " + DB.SQLString(_EmpresaGrNuevo) + "," + (Convert.ToInt32(_EjerNuevo) + 1) + "); ";
                        }
                        DB.SQLExec(lcSql);

                    }

                    break;

                case "FPAG_GIR":
                    // Si conservamos clientes no tocaremos nada, si no conservamos clientes dejamos los giros de las formas de pago.
                    if (!_ConservarClientes)
                    {
                        DB.SQLExec( "DELETE FROM " + DB.SQLDatabaseReal(tcNombreBaseDatos, "FPAG_GIR"));
                    }
                    break;

                case "VARIABLE":
                    // Eliminar variables de bankingcloud que puedan haber grabadas provenientes del grupo origen a partir del que se crea el grupo, así como la variable utilizada para la activación del módulo de banking cloud 
                    // (es un modulo que no instala ficheros, solo variable), idem esto último también para sage capture.
                    //Bug 172290 => Eliminamos variables de DTS ya que el nuevo grupo no tiene ese origen
                    // El resto de variables las dejamos.
                    lcSql = "DELETE FROM " + DB.SQLDatabaseReal(tcNombreBaseDatos, "VARIABLE") + " " +
                            "WHERE LOWER(VARIABLE)='wc_sbforganization' or " +
                            "LOWER(VARIABLE)='wc_sbfsigningkey' or " +
                            "LOWER(VARIABLE)='wc_sbfemailadmin' or " +
                            "LOWER(VARIABLE)='wc_sbfcompany' or " +
                            "LOWER(VARIABLE)='wl_sagebankfeeds' or " +
                            "LOWER(VARIABLE)='wl_sagecapture' or " +
                            "LOWER(VARIABLE)='wl_dts_lanzado' or " +
                            "LOWER(VARIABLE)='new_calculopm' or " +
                            "LOWER(VARIABLE)='wl_gestcomercial' or " +
                            "LOWER(VARIABLE)='wn_dts_tipo' or " +
                            "LOWER(VARIABLE)='aviso_ultcost' ";
                    DB.SQLExec(lcSql);

                    // Nuevo método de cálculo de precios medios
                    DB.SQLExec("insert into " + DB.SQLDatabaseReal(tcNombreBaseDatos, "VARIABLE") + " (variable, tipo, valor) values ('NEW_CALCULOPM','L','.T.')");
                    break;

                case "ASINOM":

                    // Solo pasamos los asientos predefinidos que no tengan declarados cuentas contables concretas (8 ó más dígitos), 
                    // borramos los que no cumplen esta condición.
                    //
                    // Ojo que las tablas ASINOM y ASIDEFIN estan tanto en COMUNES como en GESTION
                    //
                    AjustarTablasPredefinidos(tcNombreBaseDatos);
                    
                    break;

                case "ASIDEFIN":
                    // Realmente esta tabla se procesa en el momento que nos encontramos con ASINOM, ponemos
                    // su caso aquí de forma simbólica. Esta incluida en la lista de tablas con tratamiento especifico
                    // para que al crear grupo no se pase al nuevo grupo ni llena ni vacía. Debe tratarse, y esto se 
                    // hace cuando se encuentra la tabla "padre" de ella que es "ASIINOM". El tratamiento consiste en
                    // eliminar plantillas que contengan cuentas contables de 8 o más digitos pues al no pasarse las 
                    // cuentas contables al nuevo grupo éstas es muy probable que no existan.
                    //
                    // Ojo que las tablas ASINOM y ASIDEFIN estan tanto en COMUNES como en GESTION
                    //
                    break;

                case "PLSEPA_C":
                case "PLSEPA_D":
                    // Dejar solo los registros de la empresa 01
                    DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, tcTabla) + " WHERE EMPRESA!='' AND EMPRESA!='" + _EmpresaGrNuevo + "'");
                    break;


            }

            return true;
        }


        private static void AjustarTablasPredefinidos(string tcNombreBaseDatos)
        {

            //CCR 159418 => Damos plantillas con cuentas informadas que al crear grupos no se traspasan. Se acuerda un nuevo enfoque del problema
            //para no perde plantillas. Aquellas que utilicen cuentas completas se mantendrán pero cambiando la cuenta por su nivel 1 (que sí podemos garantizar)
            //de esta forma la plantilla se mantiene y no darán error al ejecutar ya que previamente a la ejecución el usuario ha de informar la cuenta
            //Bug 163590 => Se corta a Nivel 3 y no Nivel 1 para preservar las contrapartidas (que se borran al validar cuentas inferiores a nivel 3)
            string lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "ASIDEFIN") + " SET CUENTA = LEFT(LTRIM(CUENTA),3) WHERE LEN(LTRIM(RTRIM(CUENTA))) >= 8 ";
            DB.SQLExec(lcSql);

            //DEPRECATED

            //string lcSql = "SELECT CODIGO FROM " + DB.SQLDatabaseReal(tcNombreBaseDatos, "ASINOM") + " " +
            //               "WHERE CODIGO IN (SELECT CODIGO FROM " + DB.SQLDatabaseReal(tcNombreBaseDatos, "ASIDEFIN") + " " +
            //               "WHERE LEN(LTRIM(RTRIM(CUENTA))) >= 8)";
            //DataTable ldtAsiNom = new DataTable();
            //DB.SQLExec(lcSql, ref ldtAsiNom);
            //if (ldtAsiNom.Rows.Count > 0)
            //{
            //    string lcCodPlantilla = "";
            //    foreach (DataRow loRow in ldtAsiNom.Rows)
            //    {
            //        lcCodPlantilla = Convert.ToString(loRow["codigo"]);

            //        lcSql = "DELETE FROM " + DB.SQLDatabaseReal(tcNombreBaseDatos, "ASINOM") + " " +
            //                "WHERE CODIGO = '" + lcCodPlantilla + "'";
            //        DB.SQLExec(lcSql);

            //        lcSql = "DELETE FROM " + DB.SQLDatabaseReal(tcNombreBaseDatos, "ASIDEFIN") + " " +
            //                "WHERE CODIGO = '" + lcCodPlantilla + "'";
            //        DB.SQLExec(lcSql);
            //    }
            //}
        }


        private static bool CrearGrupoEjer_AjustarDatos_TablaGestion(string tcTabla, string tcNombreBaseDatos)
        {
            string lcSql = "";
            DataTable ldtAuxiliar = new DataTable();


            // lstTablasEspeciales = new List<string>() {"ACCESOS","ALMACEN","CFGFACT","CODIGOS","CONTACNF","CONTADOR","COTIZA","DATA_IVA","DATA_RET","EMPRESA","FACTUCNF","FAMILIAS", "FLAGS",
            //                                          "LLIS_PER","LLIS_RET","MARCAS", "MENUS","MESES","PLTCOMU", "PROGRAMS", "SERIES","TIPO_RET",
            //                                          "ACTI_CLI","ACTIVI", "AGENCIA", "BANC_CLI","CIA_CRED","CLIENTES","CONTLF_CLI","CONT_CLI","CUENTAS","ENV_CLI","FPAG","GIRO_CLI","IDIOMA","RUTAS", 
            //                                          "TELF_CLI","TIPO_FAC","VACA_CLI","VENDEDOR","RET_EMP"};

            switch (tcTabla)
            {
                case "ACCESOS":
                    // Dejar solo los accesos de la empresa de trabajo y los usuarios segun se haya seleccionado
                    lcSql = "DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, "ACCESOS") + " " +
                            "WHERE EMPRESA != '" + _EmpresaGrNuevo + "' " + (_ConservarUsuarios ? "" : " OR USUARIO != 'SUPERVISOR' ");
                    DB.SQLExec(lcSql);
                    break;

                case "ALMACEN":
                    DB.SQLExec("TRUNCATE TABLE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "ALMACEN"));
                    DB.SQLExec("INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "ALMACEN") + " (CODIGO,NOMBRE) VALUES ('" + new string('0', _LenAlmacen) + "','SIN ALMACEN')"); // Bug 109147
                    break;

                case "CFGFACT":
                    // Dejar solo los registros de la empresa con la que se trabaje
                    DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CFGFACT") + " WHERE EMPRESA != '" + _EmpresaGrNuevo + "'");

                    // Nos aseguramos de que exista el registro de configuración para la empresa de trabajo.
                    DB.SQLExec("select empresa from " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CFGFACT") + " where empresa='" + _EmpresaGrNuevo + "'", ref ldtAuxiliar);
                    if (ldtAuxiliar.Rows.Count == 0)
                    {
                        // En teoria esto no deberia ocurrir pero nos aseguramos
                        DB.SQLExec("INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CFGFACT") + " (EMPRESA) VALUES ('" + _EmpresaGrNuevo + "')");
                    }
                    else
                    {
                        // Bug 164299 : Facturar sin contabilizar. Al crear grupo de empresas, si en el principal están a false CONTAVE y CONTACO, los crea desmarcados
                        lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CFGFACT") + " " +
                                "SET EF_ENABL=0, EF_PATHVEN='', EF_PATHCOM='',MENSAJE='', EF_EXECRTF='', EF_EXEVAL='', EF_CERT='', EF_EMIS='', EF_XSIG=0, CONTAVE=1, CONTACO=1, CONTACUO=1 " +
                                "WHERE EMPRESA='" + _EmpresaGrNuevo + "'";
                        DB.SQLExec(lcSql);
                    }
                    break;

                case "CODIGOS":
                    // Dejar solo los registros de la empresa con la que se trabaje
                    DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CODIGOS") + " WHERE EMPRESA != '" + _EmpresaGrNuevo + "'");

                    // Añadimos los registros correspondientes en la tabla GESTION!CODIGOS para la empresa actual
                    String tccPathInicio, tcFileRutaIped;
                    string tcIntrastat = @"Documentos\INTRASTAT\";

                    tccPathInicio = Convert.ToString(DB._GetVariable("wc_pathinicio"));
                    tcFileRutaIped = Path.Combine(tccPathInicio, tcIntrastat);

                    // Nos aseguramos de que exista el registro de configuración para la empresa de trabajo.
                    DB.SQLExec("select empresa from " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CODIGOS") + " where empresa='" + _EmpresaGrNuevo + "'", ref ldtAuxiliar);
                    if (ldtAuxiliar.Rows.Count == 0)
                    {
                        // En teoria esto no deberia ocurrir pero nos aseguramos
                        DB.SQLExec("INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CODIGOS") + " (EMPRESA,PAIS,VENDEDOR,MODOTRANS,NA1,NA2,REGESTAT,RUTAIDEP) " +
                                        "VALUES ('" + _EmpresaGrNuevo + "'," +
                                        "'034'," +
                                        "'" + new string('0', _LenVendedor - 1) + "1', " +
                                        "'3'," + 
                                        "9, " +
                                        "1, " +
                                        "1,'" +
                                        DB.SQLString(tcFileRutaIped) + ")") ; // Bug 109147
                    }
                    else
                    {
                        if (!_ConservarClientes)
                        {
                            lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CODIGOS") + " " +
                                    "SET VENDEDOR='" + new string('0', _LenVendedor - 1) + "1', " + // Bug 109147
                                         "MODOTRANS = '3', NAT1 = 9, NAT2 = 1, REGESTAT = 1, RUTAIDEP = " + DB.SQLString(tcFileRutaIped) +
                                    "WHERE EMPRESA='" + _EmpresaGrNuevo + "'";
                            DB.SQLExec(lcSql);
                        }
                    }
                    break;

                case "CONTACNF":
                case "FLAGS":
                    // Dejar solo los registros de la empresa con la que se trabaje
                    DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, tcTabla) + " WHERE EMPRESA != '" + _EmpresaGrNuevo + "'");
                    
                    // Nos aseguramos de que exista el registro de configuración para la empresa de trabajo.
                    DB.SQLExec("select empresa from " + DB.SQLDatabaseReal(tcNombreBaseDatos, tcTabla) + " where empresa='" + _EmpresaGrNuevo + "'", ref ldtAuxiliar);
                    if (ldtAuxiliar.Rows.Count == 0)
                    {
                        // En teoria esto no deberia ocurrir pero nos aseguramos
                        DB.SQLExec("INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, tcTabla) + " (EMPRESA) VALUES ('" + _EmpresaGrNuevo + "')");

                        if (tcTabla == "CONTACNF")
                        {
                            string lcEuroserv = GrupoempTools._Euroserv.Trim();
                            string lcDirCartas = Path.Combine(lcEuroserv,"Reports\\");
                            string lcDirPagares = Path.Combine(lcEuroserv,"Reports\\Pagares\\");

                            lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONTACNF") + " " +
                                    "SET DIAS_RIESGO=15, AUTIVARET = 1, " +
                                    "IMPUTAR_AN=1, PLAN1='', PLAN2='', " +
                                    "CARTAS='"+lcDirCartas+"', "+
                                    "DIRPAGA='" + lcDirPagares + "', " +
                                    "COBROEFEC='"+_PrefijoBan3+new String('0',_LenCuenta-4)+"1' " +
                                    "WHERE EMPRESA='" + _EmpresaGrNuevo + "'";
                            DB.SQLExec(lcSql);
                        }
                    }

                    if (tcTabla == "CONTACNF")
                    {
                        lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONTACNF") + " " +
                                    "SET IMPUTAR_AN = 1, PLAN1 = '', PLAN2 = '' " +                                    
                                    "WHERE EMPRESA='" + _EmpresaGrNuevo + "'";
                        DB.SQLExec(lcSql);
                    }

                    break;

                case "FAMILIAS":
                    string lcCtaCompra = _PrefijoCom3 + new string('0', _LenCuenta - 4) + "1";
                    string lcCtaVenta = _PrefijoVen3 + new string('0', _LenCuenta - 4) + "1";
                    DB.SQLExec("TRUNCATE TABLE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "FAMILIAS"));

                    DB.SQLExec("INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "FAMILIAS") + " (CODIGO,NOMBRE,CTA_COMPRA,CTA_VENTA) VALUES ('"+new string('0',_LenFamilia)+"','SIN FAMILIA','" + lcCtaCompra + "','" + lcCtaVenta + "')");

                    break;

                case "DATA_IVA":
                case "DATA_RET":
                    DB.SQLExec("TRUNCATE TABLE  " + DB.SQLDatabaseReal(tcNombreBaseDatos, tcTabla));

                    string lcTablaPeriodos = DB.SQLDatabaseReal(tcNombreBaseDatos, tcTabla);

                    lcSql  = "insert into " + lcTablaPeriodos + " (empresa, periodo, reper, sopor) values ('" + _EmpresaGrNuevo + "', 1, '31/03/" + GrupoempTools._EjerNuevo + "', '31/03/" + GrupoempTools._EjerNuevo + "'); ";
                    lcSql += "insert into " + lcTablaPeriodos + " (empresa, periodo, reper, sopor) values ('" + _EmpresaGrNuevo + "', 2, '30/06/" + GrupoempTools._EjerNuevo + "', '30/06/" + GrupoempTools._EjerNuevo + "'); "; // Bug 109011
                    lcSql += "insert into " + lcTablaPeriodos + " (empresa, periodo, reper, sopor) values ('" + _EmpresaGrNuevo + "', 3, '30/09/" + GrupoempTools._EjerNuevo + "', '30/09/" + GrupoempTools._EjerNuevo + "'); ";
                    lcSql += "insert into " + lcTablaPeriodos + " (empresa, periodo, reper, sopor) values ('" + _EmpresaGrNuevo + "', 4, '31/12/" + GrupoempTools._EjerNuevo + "', '31/12/" + GrupoempTools._EjerNuevo + "'); ";

                    DB.SQLExec(lcSql);

                    break;

                case "CONTADOR":
                    // Dejar solo los registros de la empresa con la que se trabaje
                    DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONTADOR") + " WHERE EMPRESA != '" + _EmpresaGrNuevo + "'");

                    // Nos aseguramos de que existan registro de la empresa en cuestion
                    DB.SQLExec("select empresa from " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONTADOR") + " where empresa='" + _EmpresaGrNuevo + "'", ref ldtAuxiliar);
                    if (ldtAuxiliar.Rows.Count == 0)
                        DB.SQLExec("INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONTADOR") + " (EMPRESA) VALUES ('" + _EmpresaGrNuevo + "')");


                    // Calculo el contador para cuotas
                    int lnContador = Convert.ToInt32( Convert.ToDateTime(_FechaIniEjerNuevo).Year.ToString().Substring(2,2)) * 100000;
                   
                    // Los campos SERIES si en el origen se trabaja con artículos serializados debería haber 8758, lo resetamos.
                    // En el campo TYC si en el origen se trabaja con tallas y colores debería haber 5400, lo resetamos.
                    

                    lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONTADOR") + " " +
                            "SET PRESUVEN=0, CLIENTES=0, TRABAJO=0, PLANTILLAS=0, PRODUCCION=0, TRANSFORM=0, " +
                            "ETIQUETA=0, MODELO=0, DESCUADRE=0, CONT_ARTI=0, ENTREGAS=0, SERIES=0, TYC=0, CUOTAS=" + lnContador.ToString().Trim() +
                            "WHERE EMPRESA='" + _EmpresaGrNuevo + "'";
                    DB.SQLExec(lcSql);
                    break;

                case "PROGRAMS":

                    string lcCadenaWhereAddon = "";
                    foreach (string lcAddon in GrupoempTools._AddonsInstal)
                        lcCadenaWhereAddon += " (UPPER(COMANDO) NOT LIKE '%"+lcAddon+"%') AND ";

                    if (!string.IsNullOrWhiteSpace(lcCadenaWhereAddon))
                        lcCadenaWhereAddon = lcCadenaWhereAddon.Substring(0, lcCadenaWhereAddon.Length - 4);                    

                    // Dejar solo los registros standar de CONTABILIDAD, VENTAS, COMPRAS y los de ADDONS estandar LOTES, TPV, MAYORIST, AMORTIZA, INFORAUT
                    lcSql = "DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, "PROGRAMS") + " " +
                            "WHERE COMANDO != '' AND " +
                            "(UPPER(COMANDO) NOT LIKE '%CONTABIL%') AND " +
                            "(UPPER(COMANDO) NOT LIKE '%VENTAS%') AND " +
                            "(UPPER(COMANDO) NOT LIKE '%COMPRAS%') AND " + lcCadenaWhereAddon;
                    DB.SQLExec(lcSql);

                    break;

                case "TIPO_RET":   // La tabla TIPO_IVA no la ponemos pues ya esta en TABSYS conforme no se ha de borrar, OJO con las cuentas declaradas en TIPO_RET y TIPO_IVA
                case "COTIZA":
                    // Mantenemos su contenido, no hacemos nada
                    break;

                case "MARCAS":
                    DB.SQLExec("TRUNCATE TABLE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "MARCAS"));

                    DB.SQLExec("INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "MARCAS") + " (CODIGO,NOMBRE) VALUES ('"+new string('0',_LenMarca)+"','SIN MARCA')");

                    break;

                case "SERIES":
                    // Dejaremos solamente los registros de la empresa y serie SF
                    DB.SQLExec("TRUNCATE TABLE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "SERIES"));

                    string lcTabSer = DB.SQLDatabaseReal(tcNombreBaseDatos, "SERIES");

                    // Bug 161762 - Añadir la serie SF
                    // Bug 164310 - Volver a añadir la serie SD ya que sigue estando en el mantenimiento de series y por tanto se puede utilizar.
                    List<string> lstSeries = new List<string> { "SF", "SD" };
                    lcSql = string.Empty;

                    foreach (string lcSerie in lstSeries)
                    {
                        for (int i = 1; i < 9; i++)
                        {
                            lcSql += "INSERT INTO " + lcTabSer + " (EMPRESA,SERIE,TIPODOC) VALUES ('" + _EmpresaGrNuevo + "','"+lcSerie+"',"+Convert.ToString(i)+");";
                        }
                    }

                    DB.SQLExec(lcSql);

                    break;

                case "RET_EMP":
                    if (!_ConservarClientes)
                    {
                        // Si no conservamos clientes del grupo origen borramos su contenido
                        DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, "RET_EMP"));
                    }
                    else
                    {
                        // Si conservamos clientes borramos todo lo que no sea de clientes o de la empresa
                        DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, "RET_EMP") + " " +
                                   "WHERE EMPRESA != '" + _EmpresaGrNuevo + "' OR LEFT(CUENTA,3)!='" + GrupoempTools._PrefijoCli3 + "'");
                    }
                    break;

                case "PLTCOMU":
                    // Borramos las plantillas que no sean del sistema, es decir, las que no comiencen por 9
                    DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, "PLTCOMU") + " " + 
                               "WHERE LEFT(CODIGO,1) != '9'");
                    break;

                case "MESES":
                    // Borramos los registros que no sean de la empresa
                    DB.SQLExec("TRUNCATE TABLE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "MESES"));
                    string lcBdMeses = DB.SQLDatabaseReal(tcNombreBaseDatos, "MESES");

                    // Ejercicio partido
                    Dictionary<int, string> loDicMeses = new Dictionary<int, string>() { { 1, "ENERO" }, { 2, "FEBRERO" }, { 3, "MARZO" }, { 4, "ABRIL" }, { 5, "MAYO" }, { 6, "JUNIO" }, { 7, "JULIO" }, { 8, "AGOSTO" }, { 9, "SEPTIEMBRE" }, { 10, "OCTUBRE" }, { 11, "NOVIEMBRE" }, { 12, "DICIEMBRE" } };

                    if (GrupoempTools._CfgEjerPartiGrNuevo)
                    {
                        int lnMesIni = Convert.ToDateTime(GrupoempTools._FechaIniEjerNuevo).Month;
                        int lnMesFin = Convert.ToDateTime(GrupoempTools._FechaFinEjerNuevo).Month;

                        int lnYearIni = Convert.ToDateTime(GrupoempTools._FechaIniEjerNuevo).Year;
                        int lnYearFin = Convert.ToDateTime(GrupoempTools._FechaFinEjerNuevo).Year;

                        int lnInterval = (lnYearFin - lnYearIni) * 12 + lnMesFin - lnMesIni;

                        int lnNumMes = 1;

                        for (int ln = lnMesIni; ln <= lnMesIni + lnInterval; ln++)
                        {
                            int lnMes = ln % 12 == 0 ? 12 : ln % 12;
                            String lcMes = loDicMeses[lnMes];

                            lcSql += String.Format("INSERT INTO {0} (EMPRESA, CODIGO, MES, NUMMES, CERRADO) VALUES ('{1}', {2}, '{3}', {4}, {5}); ", lcBdMeses, _EmpresaGrNuevo, lnNumMes, lcMes, Convert.ToString(lnMes).Trim(), DB.SQLFalse());

                            lnNumMes++;
                        }
                    }
                    else
                    {
                        foreach (KeyValuePair<int, string> loMes in loDicMeses)
                        {
                            lcSql += String.Format("INSERT INTO {0} (EMPRESA, CODIGO, MES, NUMMES, CERRADO) VALUES ('{1}', {2}, '{3}', {2}, {4}); ", lcBdMeses, _EmpresaGrNuevo, loMes.Key, loMes.Value, DB.SQLFalse());
                        }
                    }

                    DB.SQLExec(lcSql);
                    break;

                case "MENUS":
                    // Si conservamos usuarios no tocaremos nada, si no conservamos usuarios dejamos solo los escritorios del SUPERVISOR y el base el cual no tiene declarado USUARIO
                    lcSql = "DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, "MENUS") + " " +
                            "WHERE EMPRESA!='" + _EmpresaGrNuevo + "' " + (!_ConservarUsuarios ? " OR USUARIO!='SUPERVISOR' " : "");
                    DB.SQLExec(lcSql);
                    break;

                case "LLIS_RET":
                case "LLIS_PER":
                    
                    // Vaciar tabla
                    DB.SQLExec("TRUNCATE TABLE " + DB.SQLDatabaseReal(tcNombreBaseDatos, tcTabla));
                    
                    // Insertar registros
                    string lcTablaLlis = DB.SQLDatabaseReal(tcNombreBaseDatos, tcTabla);
                    lcSql  = "insert into " + lcTablaLlis + " (empresa, periodo) values ('" + _EmpresaGrNuevo + "', 1);";
                    lcSql += "insert into " + lcTablaLlis + " (empresa, periodo) values ('" + _EmpresaGrNuevo + "', 2);";
                    lcSql += "insert into " + lcTablaLlis + " (empresa, periodo) values ('" + _EmpresaGrNuevo + "', 3);";
                    lcSql += "insert into " + lcTablaLlis + " (empresa, periodo) values ('" + _EmpresaGrNuevo + "', 4);";

                    DB.SQLExec(lcSql);
                    break;

                case "TARIFAS":

                    lcSql = String.Format("TRUNCATE TABLE {0} ", DB.SQLDatabaseReal(tcNombreBaseDatos, "TARIFAS"));
                    DB.SQLExec(lcSql);
                    //
                    lcSql = String.Format("INSERT INTO {0} (CODIGO, NOMBRE, COSTE, IVA_INC, TIPO_TPC, NUMDEC, MONEDA) VALUES ('TD', 'TARIFA POR DEFECTO', 1, 0, 1, 2, '000' ) ", DB.SQLDatabaseReal(tcNombreBaseDatos, "TARIFAS"));
                    DB.SQLExec(lcSql);

                    break;
                case "FACTUCNF":
                    // Borramos los registros que no sean de la empresa
                    DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, "FACTUCNF") + " WHERE EMPRESA!='" + _EmpresaGrNuevo + "'");

                    // Nos aseguramos de que exista el registro de la empresa de trabajo, si no encontrase nada de la empresa (no debería pasar) los creamos.
                    string lcCtaVDol = "";
                    string lcCtaCDol = "";
                    DB.SQLExec("select empresa,c_cta_dol,v_cta_dol from " + DB.SQLDatabaseReal(tcNombreBaseDatos, "FACTUCNF") + " where empresa='" + _EmpresaGrNuevo + "'", ref ldtAuxiliar);
                    if (ldtAuxiliar.Rows.Count == 0)
                    {
                        lcCtaVDol = _PrefijoVen3 + new string('0', _LenCuenta - 4) + "1";
                        lcCtaCDol = _PrefijoCom3 + new string('0', _LenCuenta - 4) + "1";
                        DB.SQLExec("insert into " + DB.SQLDatabaseReal(tcNombreBaseDatos, "FACTUCNF") + " (empresa, v_iva_dol, c_iva_dol, v_cta_dol, c_cta_dol) values ('" + _EmpresaGrNuevo + "','03','03','" + lcCtaCDol + "','" + lcCtaVDol + "')");
                    }
                    else
                    {
                        lcCtaVDol = Convert.ToString(ldtAuxiliar.Rows[0]["v_cta_dol"]);
                        lcCtaCDol = Convert.ToString(ldtAuxiliar.Rows[0]["c_cta_dol"]);
                    }

                    String lcCodigoGrup = _DbComunesGrNuevo.Replace("COMU", "");

                    // Bug 161762: Si tenemos el addon de conceptos facturables, asignar el vendedor '01'
                    string lcVendedorCutoas = AddonGrupoOrigen("ConceptosFacturables") ? "01" : "";

                    string lcTarifaPret = "TD";
                    if (AddonGrupoOrigen("ConceptosFacturables"))
                        lcTarifaPret = ObtenerTarifaDefecto(lcTarifaPret);

                    // Actualizamos campos
                    lcSql = String.Format("UPDATE {0} SET EMP_STOCK= '{1}', CONVERSION=1, DIAS_ENTRE=15, UNIDADES='999,999.99', GRANUNIDADES='999,999.99', ALBAVEN='ALBAVEN', FACTUVEN='FACTUVEN', PEDIVEN='PEDIVEN', " + 
                            "DEPOVEN='DEPOVEN', PRESUVEN='PRESUVEN', PEDICOM='PEDICOM', ALBACOM='ALBACOM'," +
                            "FACTUCOM='FACTUCOM', ENVIO='ENVIO', ENVIO2='ENVIO2', RECIBO='RECIBO', REC_ESPE='REC_ESPE', PRESUVEN2='PRESUVEN', RECCUOTA='RECCUOTA', PAGARE='PAGARE', TICKET='TICKET'," +
                            "ENTREGA='ENTREGA', VALE='VALE', PRECOM='PRECOM', DEPCOM='DEPOCOM', C_ALBAVEN=0, C_ALBACOM=0, TARIFAPRET= "+DB.SQLString(lcTarifaPret)+", RUTAEXP='" + Path.Combine(Convert.ToString(DB._GetVariable("wc_iniservidor")).Trim(), "DOCS_SAGE\\" + lcCodigoGrup) + "', FAMENV='', CALBDTOS=2, VALBDTOS=2, REPARTO='HOJA_REP', " + //Bug 109060, Bug 111844
                            "LFPAGCUOTAS = 1,  LIMPFACTUCUOTAS = 1, LIMPRECIBOCUOTA = 1, LCONTADORCUOTAS = 1, " +
                            "OPERARIOCUOTAS='', VENDEDORCUOTAS= " + DB.SQLString(lcVendedorCutoas) +", FPAGCUOTAS='', LETRACUOTAS='', BANCOCUOTAS='' "+     // BUG 133632
                            "WHERE EMPRESA='{1}' ", DB.SQLDatabaseReal(tcNombreBaseDatos, "FACTUCNF"), _EmpresaGrNuevo); 
                    DB.SQLExec(lcSql);

                    //Bug 147964: Crear la carpeta de exportación de documentos si no existe
                    if (!Directory.Exists(Path.Combine(Convert.ToString(DB._GetVariable("wc_iniservidor")).Trim(), "DOCS_SAGE\\" + lcCodigoGrup)))                    
                        Directory.CreateDirectory(Path.Combine(Convert.ToString(DB._GetVariable("wc_iniservidor")).Trim(), "DOCS_SAGE\\" + lcCodigoGrup));                    
             
                    break;

                case "EMPRESA":
                    // Borramos los registros que no sean de la empresa
                    DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, "EMPRESA") + " WHERE CODIGO!='" + _EmpresaGrNuevo + "'");

                    // Comrpobamos que exista el registro de la empresa que nos interesa, caso de no existir lo creamos.
                    DB.SQLExec("select codigo from " + DB.SQLDatabaseReal(tcNombreBaseDatos, "EMPRESA") + " where codigo='" + _EmpresaGrNuevo + "'", ref ldtAuxiliar);
                    if (ldtAuxiliar.Rows.Count == 0)
                        DB.SQLExec("insert into " + DB.SQLDatabaseReal(tcNombreBaseDatos, "EMPRESA") + " (codigo)  values ('" + _EmpresaGrNuevo + "')");

                    // Calculo el contador per FRACEE
                    int lnContEmail = Convert.ToInt32(Convert.ToDateTime(_FechaIniEjerNuevo).Year.ToString().Substring(2, 2)) * 100000;
                    int lnContFracee = lnContEmail + 50000;

                    // Bug 162721 - Asignar la serie "SF"
                    // Bug 161762: Si tenemos el addon de conceptos facturables, asignar la serie 'SD'
                    string lcLetra = "SF";

                    string lcTarifaCF = "";
                    if (AddonGrupoOrigen("ConceptosFacturables"))
                    {
                        // Bug 162717 - Asignar tarifa, por defecto, TD 
                        lcTarifaCF = "TD";
                        lcTarifaCF = ObtenerTarifaDefecto(lcTarifaCF);

                    }

                    // Actualizamos campos
                    lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "EMPRESA") + " " +
                            "SET NOMBRE=" + DB.SQLString(_NombreEmpresa) + ", CIF=" + DB.SQLString(_CifEmpresa) + ", NOMBRE2='', DIRECCION='', CODPOS='',  TELEFONO='', POBLACION='', PROVINCIA='', " +
                            "FAX='', MONEDA='000', TIPO='Normal', FRACEE=" + lnContFracee.ToString().Trim() + ", " +
                            "PEDIVEN=0, DEPVEN=0, PRESUP=0, ALBAVEN=0, FACTUVEN=0, TRASPASO=0, REGULARIZA=0, PEDICOM=0, FACTUCOM=0, ASIENTO=0, IVASOPOR=0," +
                            "TIPO_IVA='',TXTALBA1='', TXTALBA2='', TXTFACTU1='', TXTFACTU2='', EMAIL='', HTTP='', MOBIL='', REMESA=0, ORDEN=0, PEDICO1=''," +
                            "PEDICO2='', FACTUCOM1='', FACTUCOM2='', LETRA = " + DB.SQLString(lcLetra) + ", ALMFABRI='" + new string('0', _LenAlmacen) + "', REMESAPA=0, PASWORD='', PRECOM=0, ALBACOM=0, DEPCOM=0, COMUNICA=0, " + // Bug 109147
                            "TXTEFACTU1='', TXTEFACTU2='', IVA_ISP='',  " +
                            "REFUNDIRP=0, ALMACEN='" + new string('0', _LenAlmacen) + "', REFUNDIR=0, C_EMAIL=" + lnContEmail.ToString().Trim() + ", " + // Bug 109147
                            "CONTACT=0, CAPTURE=0, USER_ROL=0, PYG_BAL='', DASHBOARD=0 " + ", " + //Bug 136392
                            "PERIODOINI=" + DB.SQLString(_FechaIniEjerNuevo) + ",PERIODOFIN=" + DB.SQLString(_FechaFinEjerNuevo) + ", TPC='999.99', " +
                            "PRTAPLICAR=0, PRTBAJA=0, PRTPRC=0, PRTFECHA=null, PRTFECHADS=null, ACRONIMO = '', TARIFACF = " + DB.SQLString(lcTarifaCF) + " "  +
                            "WHERE CODIGO=" + DB.SQLString(_EmpresaGrNuevo);
                    DB.SQLExec(lcSql);
                    break;

                case "IDIOMA":
                    // Borramos los registros que no sean de la empresa
                    DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, tcTabla) + " WHERE EMPRESA!='" + _EmpresaGrNuevo + "'");

                    DataTable loDt = new DataTable();
                    String lcCodigoGrupo = _DbComunesGrNuevo.Replace("COMU", "");

                    lcSql = String.Format("SELECT * FROM {0} ", DB.SQLDatabaseReal(tcNombreBaseDatos, tcTabla));
                    DB.SQLExec(lcSql, ref loDt);

                    lcSql = "INSERT INTO {0} (ID, IDI_PLAN, EMPRESA, NOMBRE, FICHERO, PREDET, TIPO, OBSERVA, ID_PARENT, GRUPO ) VALUES ";
                    lcSql += "(1, '', '{1}', 'Presupuesto de venta', 'PRESUVEN', 1, 1, 'Plantilla de Presupuesto de venta generada automáticamente', 0, '{2}' ), ";
                    lcSql += "(2, '', '{1}', 'Pedido de venta', 'PEDIVEN', 1, 2, 'Plantilla de Pedido de venta generada automáticamente', 0 , '{2}'), ";
                    lcSql += "(3, '', '{1}', 'Albarán de venta', 'ALBAVEN', 1, 3, 'Plantilla de Albarán de venta generada automáticamente', 0 , '{2}'), ";
                    lcSql += "(4, '', '{1}', 'Factura de venta', 'FACTUVEN', 1, 4, 'Plantilla de Factura de venta generada automáticamente', 0 , '{2}'), ";
                    lcSql += "(5, '', '{1}', 'Depósito de venta', 'DEPOVEN', 1, 5, 'Plantilla de Depósito de venta generada automáticamente', 0 , '{2}'), ";
                    lcSql += "(6, '', '{1}', 'Ticket de venta', 'TICKET', 1, 6, 'Plantilla de Ticket de venta generada automáticamente', 0 , '{2}'), ";
                    lcSql += "(7, '', '{1}', 'Propuesta de compra', 'PRECOM', 1, 7, 'Plantilla de Propuesta de compra generada automáticamente', 0 , '{2}'), ";
                    lcSql += "(8, '', '{1}', 'Pedido de compra', 'PEDICOM', 1, 8, 'Plantilla de Pedido de compra generada automáticamente', 0 , '{2}'), ";
                    lcSql += "(9, '', '{1}', 'Albarán de compra', 'ALBACOM', 1, 9, 'Plantilla de Albarán de venta compra automáticamente', 0 , '{2}'), ";
                    lcSql += "(10, '', '{1}', 'Factura de compra', 'FACTUCOM', 1, 10, 'Plantilla de Factura de compra generada automáticamente', 0 , '{2}'), ";
                    lcSql += "(11, '', '{1}', 'Depósitos de compra', 'DEPOCOM', 1, 11, 'Plantilla de Depósito de compra generada automáticamente', 0 , '{2}'); ";

                    lcSql = String.Format(lcSql, DB.SQLDatabaseReal(_DbComunesGrNuevo, "REPLAN"), _EmpresaGrNuevo, lcCodigoGrupo);
                    DB.SQLExec(lcSql);

                    Int32 lnCodigo = 12;

                    foreach (DataRow ldRow in loDt.Rows)
                    {
                        lcSql = String.Format("INSERT INTO {0} (ID, EMPRESA, IDI_PLAN, NOMBRE, FICHERO, PREDET, TIPO, OBSERVA, ID_PARENT, GRUPO ) VALUES ", DB.SQLDatabaseReal(_DbComunesGrNuevo, "REPLAN"));
                        lcSql += String.Format("({2}, '{0}', '{1}', 'Presupuesto de venta', 'PRESUVEN', 1, 1, 'Plantilla de Presupuesto de venta generada automáticamente', 0 , '{3}' ), ", _EmpresaGrNuevo, ldRow["CODIGO"], lnCodigo++, lcCodigoGrupo);
                        lcSql += String.Format("({2}, '{0}', '{1}', 'Pedido de venta', 'PEDIVEN', 1, 2, 'Plantilla de Pedido de venta generada automáticamente', 0 , '{3}'), ", _EmpresaGrNuevo, ldRow["CODIGO"], lnCodigo++, lcCodigoGrupo);
                        lcSql += String.Format("({2}, '{0}', '{1}', 'Albarán de venta', 'ALBAVEN', 1, 3, 'Plantilla de Albarán de venta generada automáticamente', 0 , '{3}'), ", _EmpresaGrNuevo, ldRow["CODIGO"], lnCodigo++, lcCodigoGrupo);
                        lcSql += String.Format("({2}, '{0}', '{1}', 'Factura de venta', 'FACTUVEN', 1, 4, 'Plantilla de Factura de venta generada automáticamente', 0 , '{3}'), ", _EmpresaGrNuevo, ldRow["CODIGO"], lnCodigo++, lcCodigoGrupo);
                        lcSql += String.Format("({2}, '{0}', '{1}', 'Depósito de venta', 'DEPOVEN', 1, 5, 'Plantilla de Depósito de venta generada automáticamente', 0 , '{3}'), ", _EmpresaGrNuevo, ldRow["CODIGO"], lnCodigo++, lcCodigoGrupo);
                        lcSql += String.Format("({2}, '{0}', '{1}', 'Ticket de venta', 'TICKET', 1, 6, 'Plantilla de Ticket de venta generada automáticamente', 0 , '{3}'), ", _EmpresaGrNuevo, ldRow["CODIGO"], lnCodigo++, lcCodigoGrupo);
                        lcSql += String.Format("({2}, '{0}', '{1}', 'Propuesta de compra', 'PRECOM', 1, 7, 'Plantilla de Propuesta de compra generada automáticamente', 0 , '{3}'), ", _EmpresaGrNuevo, ldRow["CODIGO"], lnCodigo++, lcCodigoGrupo);
                        lcSql += String.Format("({2}, '{0}', '{1}', 'Pedido de compra', 'PEDICOM', 1, 8, 'Plantilla de Pedido de compra generada automáticamente', 0 , '{3}'), ", _EmpresaGrNuevo, ldRow["CODIGO"], lnCodigo++, lcCodigoGrupo);
                        lcSql += String.Format("({2}, '{0}', '{1}', 'Albarán de compra', 'ALBACOM', 1, 9, 'Plantilla de Albarán de venta compra automáticamente', 0 , '{3}'), ", _EmpresaGrNuevo, ldRow["CODIGO"], lnCodigo++, lcCodigoGrupo);
                        lcSql += String.Format("({2}, '{0}', '{1}', 'Factura de compra', 'FACTUCOM', 1, 10, 'Plantilla de Factura de compra generada automáticamente', 0 , '{3}'), ", _EmpresaGrNuevo, ldRow["CODIGO"], lnCodigo++, lcCodigoGrupo);
                        lcSql += String.Format("({2}, '{0}', '{1}', 'Depósitos de compra', 'DEPOCOM', 1, 11, 'Plantilla de Depósito de compra generada automáticamente', 0 , '{3}'); ", _EmpresaGrNuevo, ldRow["CODIGO"], lnCodigo++, lcCodigoGrupo);
                       
                        DB.SQLExec(lcSql);
                    }

                    break;


                case "ACTI_CLI":
                case "ACTIVI":
                case "AGENCIA":
                case "CIA_CRED":
                case "FPAG":
                case "RUTAS":
                case "TIPO_FAC":
                case "VENDEDOR":
                case "BANC_CLI":
                case "CONTLF_CLI":
                case "CONT_CLI":
                case "ENV_CLI":
                case "GIRO_CLI":
                case "TELF_CLI":
                case "VACA_CLI":
                case "CLIENTES":
                    // Si no conservamos clientes del grupo origen borramos su contenido
                    if (!_ConservarClientes)
                    {
                        lcSql = "DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, tcTabla);
                        DB.SQLExec(lcSql);

                        if (tcTabla == "VENDEDOR")
                        {
                            string lcCodVendedor = new string('0', _LenVendedor - 1) + "1";
                            // En el paso anterior se vació la tabla VENDEDOR, ahora dejamos el registro por defecto.
                            DB.SQLExec("INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "VENDEDOR") + " (CODIGO,NOMBRE) VALUES ('" + lcCodVendedor + "','VENDEDOR POR DEFECTO')");
                        }
                        else if (tcTabla == "CLIENTES")
                        {
                            // En el paso anterior se vació la tabla CLIENTES, ahora dejamos el registro por defecto.
                            DB.SQLExec("INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CLIENTES") + " (CODIGO,NOMBRE,COMUNITARI,CONTADO,PAIS,IDIOMA) " +
                                       "VALUES ('"+_PrefijoCli3+new string('0',_LenCuenta-4)+"1','CLIENTE CONTADO',1,1,'034','000')");
                        }

                    }

                    break;

                case "CUENTAS":
                    // El tratamiento del contenido final de la tabla cuentas se efectua en 2 pasos, primero aquí se vacia toda ella o se dejan los clientes unicamnete.
                    // En un segundo paso que se hace al final de todo (cuando se verifica si se han de hacer cambio de anchura de campos) se añaden unos cuantos registros de cuentas
                    // que son lo que se crean cuando se instala Sage50 a partir del CD.
                   AjustarTablaCuentas_Paso1();
                    break;

                case "ASINOM":

                    //CCR 159418 => No borramos plantillas, cambiamos los de cuentas contables concretas (8 ó más dígitos) por su nivel 1 (que es garantizable)
                    AjustarTablasPredefinidos(tcNombreBaseDatos);

                    break;

                case "ASIDEFIN":
                    // Realmente esta tabla se procesa en el momento que nos encontramos con ASINOM, ponemos
                    // su caso aquí de forma simbólica. Esta incluida en la lista de tablas con tratamiento especifico
                    // para que al crear grupo no se pase al nuevo grupo ni llena ni vacía. Debe tratarse, y esto se 
                    // hace cuando se encuentra la tabla "padre" de ella que es "ASIINOM". El tratamiento consiste en
                    // eliminar plantillas que contengan cuentas contables de 8 o más digitos pues al no pasarse las 
                    // cuentas contables al nuevo grupo éstas es muy probable que no existan.
                    //
                    // Ojo que las tablas ASINOM y ASIDEFIN estan tanto en COMUNES como en GESTION
                    //
                    break;
            }

            return true;
        }


        private static void AjustarTablaCuentas_Paso1()
        {
            string lcSql="";

            if (_ConservarClientes)
            {
                lcSql = "DELETE FROM " + DB.SQLDatabaseReal(_DbEjerGrNuevo, "CUENTAS") + " " +
                        "WHERE LEFT(CODIGO,3) != '" + GrupoempTools._PrefijoCli3 + "'";
            }
            else
            {
                lcSql = "TRUNCATE TABLE " + DB.SQLDatabaseReal(_DbEjerGrNuevo, "CUENTAS");
            }
            DB.SQLExec(lcSql);
        }


        private static void AjustarTablaCuentas_Paso2()
        {
            string lcSql = "";
            string lcZeros = new string('0', (GrupoempTools._LongitudesEstandar ? 8 : GrupoempTools._LenCuenta) - 8);    // Recordar que GrupoempTools._LenCuenta es la longitud del campo cuenta en el grupo origen.
            string lcTablaCuentas = DB.SQLDatabaseReal(_DbEjerGrNuevo, "CUENTAS");
            string lcTablaProveed = DB.SQLDatabaseReal(_DbEjerGrNuevo, "PROVEED");
            string lcTablaClientes = DB.SQLDatabaseReal(_DbEjerGrNuevo, "CLIENTES");
            string lcCodigo="",lcNombre="", lcSecundar="", lcDivisa="", lcCongasing="", lcConirpf="";

            for (int ln_i=0; ln_i<_CuentasCd.GetLength(0); ln_i++)
            {
                // Código cuenta contable a insertar.
                lcCodigo = _CuentasCd[ln_i,0].Substring(0,4)+lcZeros+_CuentasCd[ln_i,0].Substring(4,4);

                // Si la cuenta es de clientes (o deudor 440) y conservamos los clientes del grupo origen no insertarmos nada de clientes pues ya existirá y petaría.
                if (_ConservarClientes && (lcCodigo.Substring(0, 3) == _PrefijoCli3 || lcCodigo.Substring(0, 3) == _PrefijoDeudor3))
                {
                    continue;
                }
                    
                lcNombre = _CuentasCd[ln_i,1];
                lcSecundar = _CuentasCd[ln_i,2];
                lcDivisa = _CuentasCd[ln_i,3];
                lcCongasing = _CuentasCd[ln_i, 4];
                lcConirpf = _CuentasCd[ln_i, 5];
                lcSql += "insert into " + lcTablaCuentas + " (codigo, nombre, secundaria, divisa, congasing, conirpf) values ('"+lcCodigo+"' , '"+lcNombre+"' , '"+lcSecundar+"' , '"+lcDivisa+ "', '" + lcCongasing + "', '" + lcConirpf + "'); ";

                // Si la cuenta es de un proveedor o acreedor la inserto en la tabla de PROVEEDORES, ésta siempre estará vacía.
                if (lcCodigo.Substring(0, 3) == _PrefijoPro3 || lcCodigo.Substring(0, 3) == _PrefijoAcr3)
                {
                    lcSql += "insert into " + lcTablaProveed + " (codigo, nombre, idioma) values ('" + lcCodigo + "' , '" + lcNombre + "', '000'); ";
                }

                // Si la cuenta es de un deudor (440) la inserto en la tabla de CLIENTES.
                if (lcCodigo.Substring(0, 3) == _PrefijoDeudor3 )
                {
                    lcSql += "insert into " + lcTablaClientes + " (codigo, nombre, idioma) values ('" + lcCodigo + "' , '" + lcNombre + "', '000'); ";
                }
            }
            DB.SQLExec(lcSql);

            // Revisar cuentas contables de tipos de iva que es una tabla que se pasa entera con datos, podría tener cuentas de IVA no standar que no vengan en el CD.
            GrupoempTools.AjustarTablaCuentas_Paso2_TipoIva();

            // Revisar cuentas contables de tipos de retención que es una tabla que se pasa entera con datos, podría tener cuentas de RETENCION no standar que no vengan en el CD.
            GrupoempTools.AjustarTablaCuentas_Paso2_TipoRet();

            // Revisar cuentas de compras/ventas dolar que se guardan en EMPRESA, podría tener cuentas no standar que no vengan en el CD.
            GrupoempTools.AjustarTablaCuentas_Paso2_CuentasDolar();

            // Revisar cuentas de contrapartida declaradas en la ficha de cliente, podría tener cuentas no standar que no vengan en el CD.
            if (GrupoempTools._ConservarClientes)
                GrupoempTools.AjustarTablaCuentas_Paso2_Contrapar();
        }


        private static void AjustarTablaCuentas_Paso2_TipoIva()
        {
            DataTable ldtDatos = new DataTable();

            DB.SQLExec("select * from "+DB.SQLDatabaseReal(_DbEjerGrNuevo,"tipo_iva"), ref ldtDatos);

            foreach (DataRow loRow in ldtDatos.Rows)
            {
                GrupoempTools.AjustarTablaCuentas_Paso2_ActualizarCuenta(Convert.ToString(loRow["CTA_IV_SOP"]));
                GrupoempTools.AjustarTablaCuentas_Paso2_ActualizarCuenta(Convert.ToString(loRow["CTA_IV_REP"]));
                GrupoempTools.AjustarTablaCuentas_Paso2_ActualizarCuenta(Convert.ToString(loRow["CTA_RE_SOP"]));
                GrupoempTools.AjustarTablaCuentas_Paso2_ActualizarCuenta(Convert.ToString(loRow["CTA_RE_REP"]));

                GrupoempTools.AjustarTablaCuentas_Paso2_ActualizarCuenta(Convert.ToString(loRow["PENDEVREP"]));
                GrupoempTools.AjustarTablaCuentas_Paso2_ActualizarCuenta(Convert.ToString(loRow["PENDEDSOP"]));
                GrupoempTools.AjustarTablaCuentas_Paso2_ActualizarCuenta(Convert.ToString(loRow["RECSOPCDEV"]));
                GrupoempTools.AjustarTablaCuentas_Paso2_ActualizarCuenta(Convert.ToString(loRow["RECREPCDEV"]));

                GrupoempTools.AjustarTablaCuentas_Paso2_ActualizarCuenta(Convert.ToString(loRow["PRTIVSOPND"]));
                GrupoempTools.AjustarTablaCuentas_Paso2_ActualizarCuenta(Convert.ToString(loRow["PRTIVSNDPD"]));
            }
            return;
        }


        private static void AjustarTablaCuentas_Paso2_TipoRet()
        {
            DataTable ldtDatos = new DataTable();

            DB.SQLExec("select * from " + DB.SQLDatabaseReal(_DbEjerGrNuevo, "tipo_ret"), ref ldtDatos);

            foreach (DataRow loRow in ldtDatos.Rows)
            {
                GrupoempTools.AjustarTablaCuentas_Paso2_ActualizarCuenta(Convert.ToString(loRow["CTA_RE_SOP"]));
                GrupoempTools.AjustarTablaCuentas_Paso2_ActualizarCuenta(Convert.ToString(loRow["CTA_RE_REP"]));
            }
            return;
        }


        private static void AjustarTablaCuentas_Paso2_CuentasDolar()
        {
            DataTable ldtDatos = new DataTable();

            DB.SQLExec("select C_CTA_DOL, V_CTA_DOL from " + DB.SQLDatabaseReal(_DbEjerGrNuevo, "factucnf") + " where empresa='" + _EmpresaGrNuevo + "'", ref ldtDatos);

            if (ldtDatos.Rows.Count > 0)
            {
                GrupoempTools.AjustarTablaCuentas_Paso2_ActualizarCuenta(Convert.ToString(ldtDatos.Rows[0]["C_CTA_DOL"]));
                GrupoempTools.AjustarTablaCuentas_Paso2_ActualizarCuenta(Convert.ToString(ldtDatos.Rows[0]["V_CTA_DOL"]));
            }

            return;
        }


        private static void AjustarTablaCuentas_Paso2_Contrapar()
        {
            DataTable ldtDatos = new DataTable();

            DB.SQLExec("select distinct contrapar from " + DB.SQLDatabaseReal(_DbEjerGrNuevo, "clientes") + " where contrapar!=' '", ref ldtDatos);
           
            foreach (DataRow loRow in ldtDatos.Rows)
            {
                GrupoempTools.AjustarTablaCuentas_Paso2_ActualizarCuenta(Convert.ToString(loRow["contrapar"]));
            }

            return;
        }


        private static void AjustarTablaCuentas_Paso2_ActualizarCuenta(string tcCuenta)
        {
            if (string.IsNullOrWhiteSpace(tcCuenta))
                return;

            string lcZeros = new string('0', GrupoempTools._LenCuenta - 8);    // Recordar que GrupoempTools._LenCuenta es la longitud del campo cuenta en el grupo origen.

            // Cuenta en el grupo origen podria tener anchura diferente a la que hay en el grupo nuevo.
            string tcCuentaOrigen = tcCuenta.Substring(0,4)+lcZeros+tcCuenta.Substring(4,4);
            string lcNombre="";

            DataTable ldtDatos = new DataTable();

            bool llOk = DB.SQLExec("select codigo from " + DB.SQLDatabaseReal(_DbEjerGrNuevo, "cuentas") + " where codigo='" + tcCuenta + "'", ref ldtDatos);

            if (ldtDatos.Rows.Count == 0)
            {
                llOk = DB.SQLExec("select codigo,nombre from " + DB.SQLDatabaseReal(_DbEjerGrOrigen, "cuentas") + " where codigo='" + tcCuentaOrigen + "'", ref ldtDatos);
                if (ldtDatos.Rows.Count>0)
                    lcNombre = Convert.ToString(ldtDatos.Rows[0]["nombre"]);
                else
                    lcNombre = "CUENTA CONTABLE "+tcCuenta;

                llOk = DB.SQLExec("insert into " + DB.SQLDatabaseReal(_DbEjerGrNuevo, "cuentas") + " (codigo, nombre, secundaria) values ("+
                                  "'"+tcCuenta+"',"+                        
                                  "'"+lcNombre+"',"+
                                  "'N')");
            
            }

            return;
        }


        private static bool CrearGrupo_AjustarDatos_TablaAddon(string tcTabla, string tcNombreBaseDatos, string tcNombreAddon)
        {
            string lcSql = "", lcVarAuxi = "";
            DataTable ldtAuxiliar = new DataTable();


            switch (tcNombreAddon)
            {
                case "TPV":

                    //lstTablasEspeciales = new List<string>() {"CAJAS","CAJ_FCOB","CONFTICK","CONFTPV","CONFVAL","CONT_TPV",
                    //                                          "F_COBROS","OPCFLAG","OPCEMP"};

                    switch (tcTabla)
                    {
                        case "CAJAS":
                            // Vaciar tabla y dejar solo la caja 0001 como en la instalacion
                            DB.SQLExec("TRUNCATE TABLE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CAJAS"));

                            string lcCuentaCobro = "555" + new string('0', _LenCuenta - 3);
                            string lcCuentaPago = "555" + new string('0', _LenCuenta - 4) + "1";
                            string lcCuentaReposicion = "555" + new string('0', _LenCuenta - 4) + "2";
                            string lcCuentaRetirado = "555" + new string('0', _LenCuenta - 4) + "2";
                            string lcCuentaCliente = GrupoempTools._PrefijoCli3 + new string('0', _LenCuenta - 4) + "1";

                            // Crear registro para la caja 0001
                            lcSql = "INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CAJAS") + " " +
                                    "(CODIGO,NOMBRE, COBRO, PAGO, REPOSICION, RETIRADO, OPERARIO, VENDEDOR, CLIENTE, TIPO_DOC) VALUES " +
                                    "('0001','CAJA 0001','" + lcCuentaCobro + "','" + lcCuentaPago + "','" + lcCuentaReposicion + "','" + lcCuentaRetirado + "','01','01'," +
                                    "'" + lcCuentaCliente + "',1)";
                            DB.SQLExec(lcSql);

                            break;

                        case "CAJ_FCOB":

                            // Vaciar tabla y dejar solo la caja 0001 como en la instalacion
                            DB.SQLExec("TRUNCATE TABLE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CAJ_FCOB"));

                            // Crear registros para las formas de cobro
                            lcVarAuxi = _PrefijoCaj3 + new string('0', GrupoempTools._LenCuenta - 3);
                            lcSql = "INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CAJ_FCOB") + " " +
                                    "(EMPRESA,CAJA, FORMA_COB, CUENTA) VALUES " +
                                    "('" + _EmpresaGrNuevo + "','0001','01','" + lcVarAuxi + "')";
                            DB.SQLExec(lcSql);

                            lcVarAuxi = _PrefijoBan3 + new string('0', GrupoempTools._LenCuenta - 3);
                            lcSql = "INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CAJ_FCOB") + " " +
                                    "(EMPRESA,CAJA, FORMA_COB, CUENTA) VALUES " +
                                    "('" + _EmpresaGrNuevo + "','0001','02','" + lcVarAuxi + "')";
                            DB.SQLExec(lcSql);

                            lcVarAuxi = "414" + new string('0', GrupoempTools._LenCuenta - 3);
                            lcSql = "INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CAJ_FCOB") + " " +
                                    "(EMPRESA,CAJA, FORMA_COB, CUENTA) VALUES " +
                                    "('" + _EmpresaGrNuevo + "','0001','03','" + lcVarAuxi + "')";
                            DB.SQLExec(lcSql);

                            break;

                        case "CONFTICK":

                            // Borramos los registros que no sean de la empresa
                            DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONFTICK") + " WHERE EMPRESA!='" + _EmpresaGrNuevo + "'");

                            // Comrpobamos que exista el registro de la empresa que nos interesa, caso de no existir lo creamos.
                            DB.SQLExec("select empresa from " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONFTICK") + " where empresa='" + _EmpresaGrNuevo + "'", ref ldtAuxiliar);
                            if (ldtAuxiliar.Rows.Count == 0)
                                DB.SQLExec("insert into " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONFTICK") + " (empresa,cobro)  values ('" + _EmpresaGrNuevo + "',"+DB.SQLTrue()+")");

                            // Actualizamos campos
                            lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONFTICK") + " " +
                                    "SET TICKETS=0, ARQUEO=0, FACTICK=0, PEDINT=0 " +
                                    "WHERE EMPRESA='" + _EmpresaGrNuevo + "'";
                            DB.SQLExec(lcSql);
                            break;

                        case "CONFTPV":
                            // Borramos los registros que no sean de la empresa
                            DB.SQLExec("DELETE FROM " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONFTPV") + " WHERE EMPRESA!='" + _EmpresaGrNuevo + "'");

                            DB.SQLExec("select empresa from " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONFTPV") + " where empresa='" + _EmpresaGrNuevo + "'", ref ldtAuxiliar);
                            if (ldtAuxiliar.Rows.Count == 0)
                            {
                                DB.SQLExec("insert into " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONFTPV") + " " +
                                           "(empresa, cobcaja, abcaja, tickalb, vendedor, almacen, cantidad, precio, vale, hora_ini, hora_fin, credito, dev_efect) " +
                                           "values ('" + _EmpresaGrNuevo + "', " + DB.SQLTrue() + ", " + DB.SQLTrue() + ",'TRASPASO HACIA ALBARAN', " +
                                           DB.SQLTrue() + ", " + DB.SQLTrue() + ", " + DB.SQLTrue() + ", " + DB.SQLTrue() + ", '03', '09:00', '20:00', " +
                                           DB.SQLTrue() + ", " + DB.SQLTrue() + ")");
                            }

                            // Actualizamos campos
                            lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONFTPV") + " " +
                                    "SET ART_MENU='', ART_RESERVA='', FAM_POST='', TARIFASUP='', PL_SERVER=''  " +
                                    "WHERE EMPRESA='" + _EmpresaGrNuevo + "'";
                            DB.SQLExec(lcSql);
                            break;

                        case "CONFVAL":
                            // Borramos los registros que no sean de la empresa
                            DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONFVAL") + " WHERE EMPRESA!='" + _EmpresaGrNuevo + "'");

                            DB.SQLExec("select empresa from " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONFVAL") + " where empresa='" + _EmpresaGrNuevo + "'", ref ldtAuxiliar);
                            if (ldtAuxiliar.Rows.Count == 0)
                                DB.SQLExec("insert into " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONFVAL") + " (empresa)  values ('" + _EmpresaGrNuevo + "')");

                            // Actualizamos campos
                            lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONFVAL") + " " +
                                    "SET MENSAJE='', CADUCIDAD=0 " +
                                    "WHERE EMPRESA='" + _EmpresaGrNuevo + "'";
                            DB.SQLExec(lcSql);
                            break;

                        case "F_COBROS":

                            // Vaciar tabla y dejar solo la caja 0001 como en la instalacion
                            DB.SQLExec("TRUNCATE TABLE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "F_COBROS"));

                            // Crear registros para las formas de cobro
                            lcVarAuxi = _PrefijoCaj3 + new string('0', GrupoempTools._LenCuenta - 3);
                            lcSql = "INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "F_COBROS") + " " +
                                    "(CODIGO, NOMBRE, MONEDA, CUENTA, EFECTIVO ) VALUES " +
                                    "('01' , 'CONTADO' , '000' , '" + lcVarAuxi + "'," + DB.SQLTrue() + ")";
                            DB.SQLExec(lcSql);

                            lcVarAuxi = _PrefijoBan3 + new string('0', GrupoempTools._LenCuenta - 3);
                            lcSql = "INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "F_COBROS") + " " +
                                    "(CODIGO, NOMBRE, MONEDA, CUENTA, EFECTIVO) VALUES " +
                                    "('02' , 'TARJETAS' , '000' , '" + lcVarAuxi + "'," + DB.SQLFalse() + ")";
                            DB.SQLExec(lcSql);

                            lcVarAuxi = "414" + new string('0', GrupoempTools._LenCuenta - 3);
                            lcSql = "INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "F_COBROS") + " " +
                                    "(CODIGO, NOMBRE, MONEDA, CUENTA, EFECTIVO ) VALUES " +
                                    "('03', 'VALES' , '000' , '" + lcVarAuxi + "' ," + DB.SQLFalse() + ")";
                            DB.SQLExec(lcSql);
                            break;

                        case "OPCEMP":
                            // Borramos los registros que no sean de la empresa
                            DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, "OPCEMP") + " WHERE EMPRESA!='" + _EmpresaGrNuevo + "'");
                            break;

                    }
                    break;

                case "MAYORIST":
                case "AMORTIZA":

                    // En AMORTIZA y MAYORIST solo se respeta el contenido de las tablas de sistema que estan declaradas en la tabla TABSYS del propio módulo y se vacian el resto.
                    break;

                case "INFORAUT":

                    // lstTablasEspeciales = new List<string>() {"IAOPCEMP","LICENCIA","IACONFIG";
                    switch (tcTabla)
                    {
                        case "IAOPCEMP":
                            // Borramos los registros que no sean de la empresa
                            DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, "IAOPCEMP") + " WHERE EMPRESA!='" + _EmpresaGrNuevo + "'");

                            DB.SQLExec("select empresa from " + DB.SQLDatabaseReal(tcNombreBaseDatos, "IAOPCEMP") + " where empresa='" + _EmpresaGrNuevo + "'", ref ldtAuxiliar);
                            if (ldtAuxiliar.Rows.Count == 0)
                                DB.SQLExec("insert into " + DB.SQLDatabaseReal(tcNombreBaseDatos, "IAOPCEMP") + " (empresa)  values ('" + _EmpresaGrNuevo + "')");

                            break;

                        case "LICENCIA":
                            // No hacemos nada, dejamos la misma licencia que habia en el grupo origen del que viene el nuevo grupo que estamos creando.

                            // Actualizamos campos
                            lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "LICENCIA") + " " +
                                    "SET INSTAL=" + DB.SQLString(DateTime.Today.Date);
                            DB.SQLExec(lcSql);
                            break;

                        case "IACONFIG":
                            // Borramos los registros que no sean de la empresa
                            DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, "IACONFIG") + " WHERE EMPRESA!='" + _EmpresaGrNuevo + "'");

                            DB.SQLExec("select empresa from " + DB.SQLDatabaseReal(tcNombreBaseDatos, "IACONFIG") + " where empresa='" + _EmpresaGrNuevo + "'", ref ldtAuxiliar);
                            if (ldtAuxiliar.Rows.Count == 0)
                                DB.SQLExec("insert into " + DB.SQLDatabaseReal(tcNombreBaseDatos, "IACONFIG") + " (empresa)  values ('" + _EmpresaGrNuevo + "')");

                            lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "IACONFIG") + " " +
                                    "SET NOMBREMAIL='', MAIL='', SMTP='', USERMAIL='', CLAVEMAIL='',  IMPRESORA='', PUERTO='', TIEMPOLIS=15, TIEMPOPRO=240, SERVERPORT=0, CIFRADOSSL=" + DB.SQLFalse() + ", ESCRYPT=" + DB.SQLFalse() + " " +
                                    "WHERE EMPRESA='" + _EmpresaGrNuevo + "'";
                            DB.SQLExec(lcSql);
                            break;

                    }

                    break;

                case "LOTES":

                    // lstTablasEspeciales = new List<string>() {"CONFIGURA","CONTADOR","REVCONF","TIPOALM"};
                    switch (tcTabla)
                    {
                        case "CONFIGURA":
                            DB.SQLExec("TRUNCATE TABLE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONFIGURA"));

                            DB.SQLExec("insert into " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONFIGURA") + " " +
                                       " (empresa)  values ('" + _EmpresaGrNuevo + "')");

                            // Actualizamos campos
                            lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONFIGURA") + " " +
                                    "SET CONTADOR=0, TIPO_REG='', PRE_CONT='', CONSUMIR=" + DB.SQLTrue()+", " + 
                                    "STOCKS2=" + DB.SQLTrue() + ", SINCAD=" + DB.SQLTrue();
                            DB.SQLExec(lcSql);
                            break;

                        case "CONTADOR":
                            // Dejaremos solamente los registros de la empresa y serie SF
                            DB.SQLExec("TRUNCATE TABLE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "CONTADOR"));

                            string lcTabCont = DB.SQLDatabaseReal(tcNombreBaseDatos, "CONTADOR");

                            lcSql  = "INSERT INTO " + lcTabCont + " (EMPRESA,SERIE,TIPODOC) VALUES ('" + _EmpresaGrNuevo + "','SF',1);";
                            lcSql += "INSERT INTO " + lcTabCont + " (EMPRESA,SERIE,TIPODOC) VALUES ('" + _EmpresaGrNuevo + "','SF',2);";

                            DB.SQLExec(lcSql);
                            
                            break;

                        case "REVCONF":
                            DB.SQLExec("TRUNCATE TABLE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "REVCONF"));

                            DB.SQLExec("insert into " + DB.SQLDatabaseReal(tcNombreBaseDatos, "REVCONF") + " " +
                                       "(empresa, revpeso, revzona)  values ('" + _EmpresaGrNuevo + "', " + 
                                       DB.SQLTrue()+","+DB.SQLFalse()+")");

                            break;

                        case "TIPOALM":
                            // Borramos los registros que no sean de la empresa
                            DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, "TIPOALM") + " WHERE CODIGO!='" + _EmpresaGrNuevo + "'");

                            DB.SQLExec("select codigo from " + DB.SQLDatabaseReal(tcNombreBaseDatos, "TIPOALM") + " where codigo='" + _EmpresaGrNuevo + "'", ref ldtAuxiliar);
                            if (ldtAuxiliar.Rows.Count == 0)
                                DB.SQLExec("insert into " + DB.SQLDatabaseReal(tcNombreBaseDatos, "TIPOALM") + " (codigo)  values ('" + _EmpresaGrNuevo + "')");

                            break;

                    }
                    break;

                // Bug 152782
                case "IDATOS":

                    switch (tcTabla)
                    {
                        case "PLINTER_C":
                            DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, tcTabla) + " WHERE REGBASE50 = " + DB.SQLFalse() + "");
                            break;

                        case "PLINTER_D":
                            DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, tcTabla) + " WHERE REGBASE50 = " + DB.SQLFalse() + "");
                            break;

                        case "PLINTER_D1":
                            DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, tcTabla) + " WHERE REGBASE50 = " + DB.SQLFalse() + "");
                            break;

                        case "PLINTER_D2":
                            DB.SQLExec("DELETE FROM  " + DB.SQLDatabaseReal(tcNombreBaseDatos, tcTabla) + " WHERE REGBASE50 = " + DB.SQLFalse() + "");
                            break;

                    }
                    break;

            }

            return true;
        }

        private static List<string> CrearGrupoEjer_Tablas_Especiales(string tcTipoBd, string tcNombreAddon = "")
        {
            List<string> lstTablasEspeciales = null;

            switch (tcTipoBd)
            {
                case "COMUNES":
                    // COMUNES.ACCESOLIC en principio mantener lo que haya en el grupo origen puesto que la licencia no cambia, en esta tabla hay un registro para COMUNES y para cada addon instalado
                    // Como al nuevo grupo solo van a parar los addons estandar podria ser que quedase algun registro en ACCESOLIC del nuevo grupo correspondiente a un modulo que no tenga en COMUNES!MODULOS
                    // pero no deberia afectar pues al ser la misma licencia el MD5 estara calculado correctamente == > No borrar ACCESOLIC

                    lstTablasEspeciales = new List<string>() {"ACCESOLIC", "CODCOM", "EJERCICI","FORMULS", "LETRAS", "LICENCIA", "MODULOS","OPERARIO","OPC_USER", "OPCEMP", "OPCESPUS", 
                                                              "PERF_USERS","PRGS", "OPCINDICA","USRDESKTOP", "USRBROWSER", "USRWIDGET", "USUARIOS",
                                                              "ACCE_MON","COMPRCNF", "DATA_IV2", "DATA_RE2", "OTROSCFG","FPAG_GIR","VARIABLE", "ASINOM","ASIDEFIN", "PLSEPA_C", "PLSEPA_D"};
                    break;

                case "GESTION":
                    lstTablasEspeciales = new List<string>() {"ACCESOS","ALMACEN","CFGFACT","CODIGOS","CONTACNF","CONTADOR","COTIZA","DATA_IVA","DATA_RET","EMPRESA","FACTUCNF","FAMILIAS", "FLAGS",
                                                              "LLIS_PER","LLIS_RET","MARCAS","MENUS","MESES","PLTCOMU", "PROGRAMS", "SERIES","TIPO_RET",
                                                              "ACTI_CLI","ACTIVI", "AGENCIA", "BANC_CLI","CIA_CRED","CLIENTES","CONTLF_CLI","CONT_CLI","CUENTAS","ENV_CLI","FPAG","GIRO_CLI","IDIOMA","RUTAS", 
                                                              "TELF_CLI","TIPO_FAC","VACA_CLI","VENDEDOR","RET_EMP", "TARIFAS", "ASINOM", "ASIDEFIN"};
                    break;

                case "ADDON":
                    {
                        switch (tcNombreAddon)
                        {
                            case "TPV":
                                lstTablasEspeciales = new List<string>() {"CAJAS","CAJ_FCOB","CONFIGERP","CONFTICK","CONFTPV","CONFVAL","CONT_TPV",
                                                                          "F_COBROS","OPCEMP"};

                                break;
                            case "INFORAUT":
                                lstTablasEspeciales = new List<string>() { "IAOPCEMP", "LICENCIA", "IACONFIG" };
                                break;
                            case "MAYORIST":
                                lstTablasEspeciales = new List<string>() { };
                                break;
                            case "LOTES":
                                lstTablasEspeciales = new List<string>() { "CONFIGURA", "CONTADOR", "REVCONF", "TIPOALM" };
                                break;
                            // Bug 152782
                            case "IDATOS":
                                lstTablasEspeciales = new List<string>() { "PLINTER_C", "PLINTER_D", "PLINTER_D1", "PLINTER_D2" };
                                break;
                            // Bug 131839 - Para cualquier otro addon, crear la lista vacia        
                            default:
                                lstTablasEspeciales = new List<string>() { };
                                break;
                        }
                        break;
                    }
            }
            return lstTablasEspeciales;
        }

        private static bool AjustarDatos_Bd(string tcNombreBaseDatos, string tcTipoBaseDatos, string tcNombreAddon="")
        {
            string lcSql = "", lcTabla="";

            // En la tabla COMUNES!TABSYS guardamos las tablas de COMUNES y GESTION que son de sistema y no deben borrarse, por tanto en el nuevo grupo se respetará su contenido
            // En el caso de los Addons tambien existe la tabla TABSYS. De momento Sage50 instala 5 addons de forma predeterminada aunque no tienen por estar visibles (TPV, AMORTIZA, MAYORIST, LOTES, INFORAUT)

            // El proceso de ajuste de datos revisa todas las tablas de la base de datos y si la detectada en la lista de tabla que no deben borrarse la deja igual, y si detecta que está en la lista
            // de tablas a las que hay que aplicar algún proceso, la procesa.

            if (_Log)
                Guardar_Mensaje("INICIO PROCESO DE AJUSTE DE DATOS EN LA BASE DE DATOS DE " + tcTipoBaseDatos + " [" + tcNombreBaseDatos+"] "+tcNombreAddon+Environment.NewLine);
           
            


            // TABLAS DE SISTEMA QUE NO DEBEN BORRARSE, CONSULTAR TABSYS
            DataTable ldtTablasNoborr = new DataTable();
            lcSql = "select tabla from " + DB.SQLDatabaseReal( tcTipoBaseDatos == "COMUNES" || tcTipoBaseDatos == "GESTION" ? _DbComunesGrNuevo : tcNombreBaseDatos,"tabsys")+" "+
                      (tcTipoBaseDatos == "COMUNES" || tcTipoBaseDatos == "GESTION" ? "where basedatos='" + tcTipoBaseDatos + "'" : "");
            DB.SQLExec(lcSql, ref ldtTablasNoborr);
            List<string> lstTablasNoBorr = ldtTablasNoborr.AsEnumerable().Select(x => x[0].ToString().Trim().ToUpper()).ToList();

            if (_Log)
                Guardar_Mensaje("Detectadas " + lstTablasNoBorr.Count.ToString() + " tablas de sistema en la base de datos de " + tcTipoBaseDatos + " (" + tcNombreBaseDatos + ")" + tcNombreAddon + " cuyo contenido no debe borrarse.");
            



            // TABLAS CON ALGUN TRATAMIENTO ESPECIAL A REALIZAR
            
            // Tratamientos: eliminar registros de empresas sobrantes, eliminar registros de usuarios diferentes de SUPERVISOR, 
            // poner contadores a 0
            List<string> lstTablasEspeciales = null;

            lstTablasEspeciales = GrupoempTools.CrearGrupoEjer_Tablas_Especiales(tcTipoBaseDatos, tcNombreAddon);

            // Cualquier tabla que esté en cualquiera de las dos listas anteriores (lstTablasNoBorr, lstTablasEspeciales) no se borrará.

            // OBTENER TODAS LAS TABLAS DE LA BASE DE DATOS
            if (_Log)
                Guardar_Mensaje("Consultando tablas existentes en la base de datos  de "+tcTipoBaseDatos+" "+tcNombreAddon+" "+tcNombreBaseDatos);

            DataTable ldtTablasBd = new DataTable();
            try
            {
                lcSql = "SELECT table_name as tabla  " +
                        "FROM [" + tcNombreBaseDatos + "].INFORMATION_SCHEMA.TABLES " +
                        "ORDER BY table_name ";
                DB.SQLExec(lcSql, ref ldtTablasBd);
            }
            catch (Exception loEx)
            {
                if (_Log)
                {
                    Guardar_Mensaje("No se puedieron obtener las tablas existentes en la base de datos de " + tcTipoBaseDatos + " " + tcNombreBaseDatos);
                    Guardar_Mensaje(loEx.Message);
                }
            }

            // PROCESAR CADA UNA DE LAS TABLAS DE LA BASE DE DATOS

            // Nos recorremos las tablas de la base de datos y si la tabla en questión no está ni en la lista de tablas no borrables, 
            // ni está en la lista de tablas a la que realizar algún proceso, la vacíaremos.
            foreach (DataRow loRow in ldtTablasBd.Rows)
            { 
                lcTabla = Convert.ToString(loRow["tabla"]).Trim().ToUpper();
                
                if (!string.IsNullOrWhiteSpace(lcTabla) && !lstTablasNoBorr.Contains(lcTabla) && lstTablasEspeciales != null && !lstTablasEspeciales.Contains(lcTabla))
                {
                    // No está en la lista de tablas a respetar enteramente su contenido ni tampoco está en la lista de tablas 
                    // que hay que hacer algún proceso, por tanto borramos su contenido.
                    if (_Log)
                        Guardar_Mensaje("Eliminando contenido de la tabla " + tcNombreBaseDatos+"."+lcTabla);
                    DB.SQLExec("TRUNCATE TABLE  " + DB.SQLDatabaseReal(tcNombreBaseDatos, lcTabla));
                }
                else
                {
                    // La tabla está en la lista de tablas que hay que hacer algún proceso, por tanto, a procesarla.
                    if (lstTablasEspeciales.Contains(lcTabla))
                    {
                        if (_Log)
                            Guardar_Mensaje("Ajustando datos en la tabla de " + tcTipoBaseDatos + " " + tcNombreAddon + " " + tcNombreBaseDatos + "." + lcTabla);

                        try
                        {
                            switch (tcTipoBaseDatos)
                            {
                                case "COMUNES":
                                    GrupoempTools.CrearGrupo_AjustarDatos_TablaComunes(lcTabla, tcNombreBaseDatos);
                                    break;
                                case "GESTION":
                                    GrupoempTools.CrearGrupoEjer_AjustarDatos_TablaGestion(lcTabla, tcNombreBaseDatos);
                                    break;
                                case "ADDON":
                                    GrupoempTools.CrearGrupo_AjustarDatos_TablaAddon(lcTabla, tcNombreBaseDatos, tcNombreAddon);
                                    break;
                            }
                        }
                        catch (Exception loEx)
                        {
                            if (_Log)
                            {
                                Guardar_Mensaje("No se puedieron realizar los ajustes en la tabla de la base de datos de " + tcTipoBaseDatos + " " +  tcNombreAddon+" "+tcNombreBaseDatos+"."+lcTabla); 
                                Guardar_Mensaje(loEx.Message);
                            }                        
                        }
                    }

                    // Tabla con datos, recalcular los campos GUID_ID, CREATED, MODIFIED pues no pueden coincidir con los del grupo origen
                    // utilizado para la creación del grupo. En GUID_ID se pone NEWID() y en CREATED y MODIFIED se pone la fechahora actual con GETDATE()
                    GrupoempTools.Actualizar_CamposGuidId(tcNombreBaseDatos, lcTabla);
                }
            }

            if (_Log)
            {
                Guardar_Mensaje(Environment.NewLine);
                Guardar_Mensaje("FIN PROCESO DE AJUSTE DE DATOS EN LA BASE DE DATOS DE " + tcTipoBaseDatos + " [" + tcNombreBaseDatos + "] " + tcNombreAddon + Environment.NewLine);
            }

            return true;
        }

        private static bool Actualizar_CamposGuidId(string tcNombreBdReal, string tcTabla)
        {
            string lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBdReal, tcTabla) + " " +
                           "SET GUID_ID=NEWID(), CREATED=GETDATE(), MODIFIED=GETDATE() ";
            bool llOk = DB.SQLExec(lcSql);

            return llOk;
        }

        private static bool BorrarGrupo_Comprobaciones_Previas(string tcGrupo)
        {
            string lcSql = "";

            if (_Log)
                Guardar_Mensaje("Conexión activa antes de borrar el grupo: " + DB.DbComunes);

            // Comprobamos que pasen bien el código de grupo a crear.
            if (string.IsNullOrWhiteSpace(tcGrupo))
            {
                _Error_Message = "No se ha recibido el parámetro código de grupo a borrar.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }

            // Si no existe la tabla acabo, esto no debería ocurrir en ningún caso pero se comprueba para evitar la petada si fuera el caso.
            if (DB._SQLExisteTablaBBDD("EUROWINSYS", "GRUPOSEMP") == false)
            {
                _Error_Message = "No se ha detectado la tabla gruposemp, no se borrará el grupo " + tcGrupo;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }
            if (_Log)
                Guardar_Mensaje("Tabla GruposEmp: OK.");


            // Comprobar que el grupo exista en EUROWINSYS.GRUPOSEMP, sino ya no empezamos bien y cancelo.
            DataTable ldtGrupos = new DataTable();
            lcSql = "SELECT * FROM [EUROWINSYS].[dbo].[gruposemp] where codigo=" + DB.SQLString(tcGrupo);
            DB.SQLExec(lcSql, ref ldtGrupos);
            if (ldtGrupos.Rows.Count == 0)
            {
                _Error_Message = "No se ha detectado el grupo a eliminar en la tabla eurowinsys.gruposemp, no se eliminará el grupo.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                // Como estamos borrando el grupo, si no tiene el registro en gruposemp NO será motivo suficiente para no eliminar el grupo y continuaremos.
            }
            else
            {
                if (_Log)
                    Guardar_Mensaje("El grupo a eliminar " + tcGrupo + " existe en la tabla de grupos GruposEmp: OK.");
            }


            // Compruebo que no sea grupo origen. 
            // Si el intento del borrado del grupo se hace desde Sage50 desde el formulario de mantenimiento de grupos 
            // ya controla desde allí y no debería llegar aquí, en cambio,
            // si la llamada se hace externamente a Sage50 (p.e. desde otro software),  hay que hacer la comprobación.
            if (ldtGrupos.Rows.Count > 0)
            {
                bool llPripal = Convert.ToBoolean(ldtGrupos.Rows[0]["pripal"]);
                if (llPripal)
                {
                    _Error_Message = "El grupo que se pretende eliminar está marcado como grupo principal en la tabla de grupos GRUPOSEMP y no puede eliminarse.";
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }
                if (_Log)
                    Guardar_Mensaje("El grupo a eliminar " + tcGrupo + " no es grupo principal: OK.");
            }


            // Verificar que el grupo que se pretende eliminar no es el grupo activo.
            GrupoempTools._DbComunesGrBorrar = "COMU" + tcGrupo;
            if (_Log)
                Guardar_Mensaje("Base de datos de COMUNES del grupo a eliminar: "+_DbComunesGrBorrar);
            
            if (DB.DbComunes.ToUpper().Trim() == _DbComunesGrBorrar.ToUpper().Trim())
            {
                _Error_Message = "Para eliminar el grupo " + tcGrupo + " éste no debe ser el grupo activo de la conexión al servidor SQL, debe estar conectado a otro grupo.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }
            if (_Log)
                Guardar_Mensaje("El grupo a eliminar " + tcGrupo + " no es el grupo activo: OK.");


            // Comprobar que existe la base de COMUNES del grupo a eliminar.
            if (_Log)
                Guardar_Mensaje("Verificando existencia de base de datos " + GrupoempTools._DbComunesGrBorrar);
            if (DB._SQLExisteBBDD(_DbComunesGrBorrar))
            {
                if (_Log)
                    Guardar_Mensaje("Base de datos COMUNES " + GrupoempTools._DbComunesGrBorrar + " existe en el servidor: OK");
            }
            else
            {
                _Error_Message = "Base de datos COMUNES " + GrupoempTools._DbComunesGrBorrar + " no existe en el servidor.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }


            // Buscamos las bd de los ejercicios y las guardamos en un DataTable.
            GrupoempTools._dtBdEjerGrBorrar = new DataTable();
            if (_Log)
                Guardar_Mensaje("Obteniendo bases de datos de ejercicios de " + GrupoempTools._DbComunesGrBorrar);
            DB.SQLExec("select * from " + DB.SQLDatabaseReal(GrupoempTools._DbComunesGrBorrar, "ejercici"), ref _dtBdEjerGrBorrar);
            if (_Log)
            {
                Guardar_Mensaje("Detectados " + _dtBdEjerGrBorrar.Rows.Count.ToString() + " ejercicios.");
                if (_dtBdEjerGrBorrar.Rows.Count > 0)
                {
                    foreach (DataRow loRow in _dtBdEjerGrBorrar.Rows)
                        Guardar_Mensaje(Convert.ToString(loRow["conexion"]));
                }
            }


            // Buscamos las bd. de los Add-ons y las guardamos en un DataTable.
            GrupoempTools._dtBdAddonsGrBorrar = new DataTable();
            if (_Log)
                Guardar_Mensaje("Obteniendo bases de datos de Add-ons " + GrupoempTools._DbComunesGrBorrar);
            DB.SQLExec("select nom_conex,nombre from " + DB.SQLDatabaseReal(GrupoempTools._DbComunesGrBorrar, "modulos"), ref GrupoempTools._dtBdAddonsGrBorrar);
            if (_Log)
            {
                Guardar_Mensaje("Detectados " + GrupoempTools._dtBdAddonsGrBorrar.Rows.Count.ToString() + " Add-ons.");
                if (_dtBdAddonsGrBorrar.Rows.Count>0)
                {
                foreach (DataRow loRow in GrupoempTools._dtBdAddonsGrBorrar.Rows)
                    Guardar_Mensaje(Convert.ToString(loRow["nom_conex"]));
                }
            }

            return true;
        }


        private static bool CrearGrupo_Comprobar_TabSys(string tcTipoBd, string tcNombreBd, string tcComentario = "")
        {
            DataTable ldtAuxi = new DataTable();

            // Existencia de la tabla TABSYS en la base de datos
            if (!DB._SQLExisteTablaBBDD(tcNombreBd, "tabsys"))
            {
                _Error_Message = "No se ha detectado la existencia de la tabla TABSYS en la base de datos de "+tcTipoBd+" "+tcComentario.Trim() + 
                                 " ("+tcNombreBd+") del grupo origen "+_GrupoOrigen;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }

            // Se verifica que si existe la tabla, además tenga registros.
            DB.SQLExec("select * from " + DB.SQLDatabaseReal(tcNombreBd, "tabsys") + " where tabla!='' order by basedatos,tabla", ref ldtAuxi);
            if (ldtAuxi.Rows.Count == 0)
            {
                _Error_Message = "Se ha detectado la existencia de la tabla TABSYS en la base de datos " + tcTipoBd + " " + tcComentario.Trim() +
                                 " (" + tcNombreBd + ") del grupo origen " + _GrupoOrigen + ", pero ésta no tiene ningún registro y debería tener datos.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }

            return true;
        }


        private static int CrearGrupo_Obtener_LenCampo(string tcBd, string tcTabla, string tcComentLog, int tnAnchoMinimo)
        {
            DataTable ldtAuxiliar = new DataTable();
            int lnAncho = 0;

            DB.SQLExec("select top 1 codigo from " + DB.SQLDatabaseReal(tcBd, tcTabla) + " order by codigo desc", ref ldtAuxiliar);
            if (ldtAuxiliar.Rows.Count == 1)
            {
                lnAncho = Convert.ToString(ldtAuxiliar.Rows[0]["codigo"]).Length;
                if (lnAncho < tnAnchoMinimo )
                {
                    lnAncho = tnAnchoMinimo;
                    if (_Log)
                        Guardar_Mensaje("Núm. dígitos " + tcComentLog + " = " + lnAncho.ToString().Trim() + " obtenido de forma anómala.");

                }
                else
                {
                    if (_Log)
                        Guardar_Mensaje("Núm. dígitos " + tcComentLog + " = " + lnAncho.ToString().Trim());
                }
            }
            else
            {
                lnAncho = tnAnchoMinimo;
                if (_Log)
                    Guardar_Mensaje("Núm. dígitos " + tcComentLog + " = " + lnAncho.ToString().Trim() + " obtenido de forma anómala (2).");
            }

            return lnAncho;
        }


        private static bool CrearEjercicio_Comprobaciones_Previas(string tcGrupoOrigen, string tcEjerOrigen, string tcEjerNuevo)
        {
            DataTable ldtAuxiliar = new DataTable();

            if (_Log)
                Guardar_Mensaje("INICIO PROCESO COMPROBACIONES PREVIAS ANTES DE PROCEDER A LA CREACION DEL NUEVO EJERCICIO" + Environment.NewLine);

            // La correcta recepción de estos parámetros ya se ha realizado anteriormente en el metodo CrearEjercicio_Comprobaciones_Parametros


            // La base de datos de COMUNES del grupo origen debe existir.
            GrupoempTools._GrupoOrigen = tcGrupoOrigen;
            GrupoempTools._DbComunesGrOrigen = "COMU" + tcGrupoOrigen.Trim();
            GrupoempTools._DbComunesGrNuevo = GrupoempTools._DbComunesGrOrigen;
            if (!DB._SQLExisteBBDD(_DbComunesGrOrigen))
            {
                _Error_Message = "No se ha detectado en el servidor SQL la base de datos de COMUNES (" + _DbComunesGrOrigen + ") asociada al grupo origen  (" + _GrupoOrigen + "), no se creará el ejercicio " + tcEjerNuevo;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }
            if (_Log)
            {
                Guardar_Mensaje("Base de datos de COMUNES del grupo origen: " + _DbComunesGrOrigen);
                Guardar_Mensaje("Base de datos de COMUNES del grupo origen existe en el servidor SQL.");
            }




            // Buscamos las bd. de los Add-ons del grupo origen que reseguiremos después, en principio no hemos de hacer nada con ellas, pero ya las tendremos si surje alguna necesidad.
            if (_Log)
                Guardar_Mensaje("Obteniendo bases de datos de Add-ons de grupo origen " + GrupoempTools._GrupoOrigen + " (COMU" + _GrupoOrigen + ")");
            DB.SQLExec("select nom_conex,nombre from " + DB.SQLDatabaseReal(GrupoempTools._DbComunesGrOrigen, "modulos"), ref _dtBdAddonsGrOrigen);
            if (_Log)
            {
                Guardar_Mensaje("Detectados " + _dtBdAddonsGrOrigen.Rows.Count.ToString() + " Add-ons.");
                foreach (DataRow loRow in _dtBdAddonsGrOrigen.Rows)
                    Guardar_Mensaje(Convert.ToString(loRow["nom_conex"]));
            }




            // Buscamos la base de datos que corresponde al ejercicio origen que nos han pasado como parámetro.
            DataTable ldtBdEjer = new DataTable();
            GrupoempTools._DbEjerGrOrigen = "";
            if (_Log)
                Guardar_Mensaje("Obteniendo base de datos de ejercicio "+tcEjerOrigen+" de " + _DbComunesGrOrigen+".EJERCICI");
            DB.SQLExec("select * from " + DB.SQLDatabaseReal(GrupoempTools._DbComunesGrOrigen, "ejercici") + " where [any]='" + tcEjerOrigen.Trim()+"'", ref ldtBdEjer);
            if (ldtBdEjer.Rows.Count == 1)
            {
                GrupoempTools._DbEjerGrOrigen = Convert.ToString(ldtBdEjer.Rows[0]["conexion"]).Trim();
                if (_Log)
                    Guardar_Mensaje("Base de datos de EJERCICIO origen: " + GrupoempTools._DbEjerGrOrigen);
            }
            else
            {
                _Error_Message = "No se ha podido averiguar el nombre de la base de datos de ejercicio " + tcEjerOrigen + " en el grupo " + GrupoempTools._GrupoOrigen + ", imposible crear ejercicio " + tcEjerNuevo;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }




            // La base de datos de EJERCICIO origen debería existir en el servidor SQL
            if (!DB._SQLExisteBBDD(GrupoempTools._DbEjerGrOrigen))
            {
                _Error_Message = "La base de datos de EJERCICIO " + GrupoempTools._DbEjerGrOrigen + " que se utilizará como origen de la creación de ejercicio no existe en el servidor, imposible crear ejercicio.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }
            if (_Log)
                Guardar_Mensaje("La base de datos de ejercicio "+ GrupoempTools._DbEjerGrOrigen+" que se utilizará como origen para la creación del ejercicio existe en el servidor SQL: OK");





            // El ejercicio que se pretende crear no debería estar declarado en COMUNES.EJERCICI del grupo
            if (_Log)
                Guardar_Mensaje("Verificando la inexistencia del ejercicio " + tcEjerNuevo + " que se pretende crear "+tcEjerNuevo);
            DB.SQLExec("select * from " + DB.SQLDatabaseReal(GrupoempTools._DbComunesGrOrigen, "ejercici") + " where [any]='" + tcEjerNuevo.Trim()+"'", ref ldtBdEjer);
            if (ldtBdEjer.Rows.Count >= 1)
            {
                _Error_Message = "El ejercicio que se pretende crear " + tcEjerNuevo + " ya existe en la tabla de ejercicios del grupo "+_GrupoOrigen+",  imposible crear ejercicio " + tcEjerNuevo;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }





            // Obtener base de datos del nuevo ejercicio que se va a crear a partir del ejercicio origen, será concatenar el ejercicio + los 2 carácteres de la derecha existentes en la bd del ejercicio origen
            GrupoempTools._SufiBdEjerGrNuevo = GrupoempTools._DbEjerGrOrigen.Substring(4, 2);
            // Si el sufijo no está bien, paro.
            if (GrupoempTools._SufiBdEjerGrNuevo.Trim().Length != 2)
            {
                _Error_Message = "El sufijo del nombre de la base de datos del ejercicio origen "+_DbEjerGrOrigen+" no tiene el formato, debería tener 2 carácteres: "+GrupoempTools._SufiBdEjerGrNuevo;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }




            GrupoempTools._DbEjerGrNuevo = tcEjerNuevo.Trim() + _SufiBdEjerGrNuevo.Trim();
            if (string.IsNullOrWhiteSpace(GrupoempTools._DbEjerGrNuevo))
            {
                _Error_Message = "No se ha podido obtener el nombre de la base de datos de ejercicio a crear,  imposible crear ejercicio " + tcEjerNuevo;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }
            if (_Log)
                Guardar_Mensaje("Asignado nombre a base de datos de EJERCICIO a crear: " + GrupoempTools._DbEjerGrNuevo);

 


            // La base de datos de EJERCICIO a crear no debería existir en el servidor SQL
            if (DB._SQLExisteBBDD(GrupoempTools._DbEjerGrNuevo))
            {
                _Error_Message = "La base de datos " + _DbEjerGrNuevo + " correspondiente al ejercicio nuevo a crear en el grupo (" + tcGrupoOrigen + ") ya existe en el servidor, imposible crear ejercicio.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }
            if (_Log)
                Guardar_Mensaje("La base de datos de EJERCICIO " + GrupoempTools._DbEjerGrNuevo + " que se creará para el nuevo ejercicio no existe en el servidor SQL: OK");



            // tcCarpetaBackupServidorSql = lcCarpetaDataServidorSql.ToLower().Replace("\\data", "\\backup");
            GrupoempTools._CarpetaBackupServidorSql = DB._SQLRutaBackup();
            if (string.IsNullOrWhiteSpace(_CarpetaBackupServidorSql))
            {
                _Error_Message = "No se ha podido averiguar la carpeta de Backup del servidor SQL.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }

            if (_Log)
                Guardar_Mensaje("Obtenida ruta de Backup en el servidor SQL " + _CarpetaBackupServidorSql + ": OK");




            // Obtener nº de dígitos de la cuenta contable, marca, familia, vendedor, etc. en el grupo, se utilizará en el ajuste de datos que se realiza una vez creadas las bases de datos del nuevo grupo.
            if (_Log)
                Guardar_Mensaje("Obteniendo nº de dígitos anchura de campos CUENTA, MARCA, FAMILIA, VENDEDOR, ALMACEN según base de datos de ejercicio origen."); // Bug 109147

            GrupoempTools._LenCuenta = GrupoempTools.CrearGrupo_Obtener_LenCampo(_DbEjerGrOrigen, "cuentas", "cuenta contable", 8);
            GrupoempTools._LenMarca = GrupoempTools.CrearGrupo_Obtener_LenCampo(_DbEjerGrOrigen, "marcas", "marca", 2);
            GrupoempTools._LenFamilia = GrupoempTools.CrearGrupo_Obtener_LenCampo(_DbEjerGrOrigen, "familias", "familia", 2);
            GrupoempTools._LenVendedor = GrupoempTools.CrearGrupo_Obtener_LenCampo(_DbEjerGrOrigen, "vendedor", "vendedor", 2);
            GrupoempTools._LenAlmacen = GrupoempTools.CrearGrupo_Obtener_LenCampo(_DbEjerGrOrigen, "almacen", "almacén", 2); // Bug 109147

            
            // Detectando fechas de ejercicio origen.
            if (_Log)
                Guardar_Mensaje("Detectando ejercicio predeterminado en grupo origen.");

            DB.SQLExec("select * from " + DB.SQLDatabaseReal(_DbComunesGrOrigen, "ejercici") + " where [any]='"+tcEjerOrigen+"'", ref ldtAuxiliar);
            if (ldtAuxiliar.Rows.Count == 0)
            {
                _Error_Message = "No se ha detectado ejercicio origen en la tabla de ejercicios del grupo " + _GrupoOrigen;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }
            else
            {
                GrupoempTools._FechaIniEjerOrigen = Convert.ToDateTime(ldtAuxiliar.Rows[0]["periodoini"]);
                GrupoempTools._FechaFinEjerOrigen = Convert.ToDateTime(ldtAuxiliar.Rows[0]["periodofin"]);
            }




            // Averiguar prifijo de 3 dígitos con la que comienzan los clientes, proveedores, acreedores contables, bancos, cuentas compras, cuentas ventas.
            DB.SQLExec("select * from " + DB.SQLDatabaseReal(_DbComunesGrOrigen, "codcom"), ref ldtAuxiliar);
            if (ldtAuxiliar.Rows.Count > 0)
            {
                GrupoempTools._PrefijoCli3 = Convert.ToString(ldtAuxiliar.Rows[0]["cliente"]).Substring(0, 3);
                GrupoempTools._PrefijoPro3 = Convert.ToString(ldtAuxiliar.Rows[0]["proveed"]).Substring(0, 3);
                GrupoempTools._PrefijoAcr3 = Convert.ToString(ldtAuxiliar.Rows[0]["acreed"]).Substring(0, 3);
                GrupoempTools._PrefijoBan3 = Convert.ToString(ldtAuxiliar.Rows[0]["banco"]).Substring(0, 3);
                GrupoempTools._PrefijoCaj3 = Convert.ToString(ldtAuxiliar.Rows[0]["caja"]).Substring(0, 3);
                GrupoempTools._PrefijoCom3 = Convert.ToString(ldtAuxiliar.Rows[0]["compra"]).Substring(0, 3);
                GrupoempTools._PrefijoVen3 = Convert.ToString(ldtAuxiliar.Rows[0]["venta"]).Substring(0, 3);
                GrupoempTools._PrefijoDeudor3 = Convert.ToString(ldtAuxiliar.Rows[0]["deudor"]).Substring(0, 3);

                if (string.IsNullOrWhiteSpace(GrupoempTools._PrefijoCli3) || string.IsNullOrWhiteSpace(GrupoempTools._PrefijoPro3) ||
                    string.IsNullOrWhiteSpace(GrupoempTools._PrefijoAcr3) || string.IsNullOrWhiteSpace(GrupoempTools._PrefijoBan3) ||
                    string.IsNullOrWhiteSpace(GrupoempTools._PrefijoCom3) || string.IsNullOrWhiteSpace(GrupoempTools._PrefijoVen3) ||
                    string.IsNullOrWhiteSpace(GrupoempTools._PrefijoCaj3) || string.IsNullOrWhiteSpace(GrupoempTools._PrefijoDeudor3))
                {
                    _Error_Message = "No se ha podido detectar los prefijos de 3 dígitos para alguna de las cuentas contables de clientes, deudores, proveedores, acreedores, bancos, compras o ventas en el grupo origen " + _GrupoOrigen + ", alguno de ellos está vacío.";
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }
            }
            else
            {
                _Error_Message = "No se ha podido detectar los prefijos de 3 dígitos para alguna de las cuentas contables de clientes, deudores, proveedores, acreedores, bancos, compras o ventas. No hay registros en COMUNES.CODCOM en el grupo origen " + _GrupoOrigen;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }


            // Detectamos con qué empresa trabajaremos, en condiciones normales será la '01' que será la que instala Sage50 de base, pero podrían haberla borrado en el grupo origen
            // y trabajar con otras, en este caso cogeremos la primera por orden.
            DB.SQLExec("select codigo, nombre, cif from " + DB.SQLDatabaseReal(_DbEjerGrOrigen, "empresa") + " where codigo='01'", ref ldtAuxiliar);
            if (ldtAuxiliar.Rows.Count == 1 && Convert.ToString(ldtAuxiliar.Rows[0]["codigo"]) == "01")
                GrupoempTools._EmpresaGrNuevo = "01";
            else
            {
                DB.SQLExec("select codigo,nombre,cif from " + DB.SQLDatabaseReal(_DbEjerGrOrigen, "empresa") + " order by codigo", ref ldtAuxiliar);
                if (ldtAuxiliar.Rows.Count == 0)
                {
                    _Error_Message = "No se ha detectado ningún registro en la tabla EMPRESA de la base de datos de ejercicio " + _DbEjerGrOrigen + " del grupo origen  " + _GrupoOrigen + ", no se creará el ejercicio.";
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }
                else
                {
                    GrupoempTools._EmpresaGrNuevo = Convert.ToString(ldtAuxiliar.Rows[0]["codigo"]);
                }
            }
            // Captamos ya el nombre de la empresa y el cif
            GrupoempTools._NombreEmpresa = Convert.ToString(ldtAuxiliar.Rows[0]["nombre"]);
            GrupoempTools._CifEmpresa = Convert.ToString(ldtAuxiliar.Rows[0]["cif"]);


            // Si no han declarado el usuario propietario de las nuevas bases de datos que se creen lo ponemos nosotros
            if (string.IsNullOrWhiteSpace(GrupoempTools._UserPropBdGrNuevo))
                GrupoempTools._UserPropBdGrNuevo = "Sage50";


            // Compruebo que todas las propiedades anteriores tengan valor, en teoria si se ha llegado hasta aquí todas ellas deberían estar informadas.
            string lcPropiedadNoInfo = "";
            if (string.IsNullOrWhiteSpace(_GrupoOrigen))
                lcPropiedadNoInfo += "_GrupoOrigen ";
            if (string.IsNullOrWhiteSpace(_DbComunesGrOrigen))
                lcPropiedadNoInfo += "_DbComunesGrOrigen ";
            if (string.IsNullOrWhiteSpace(_DbComunesGrNuevo))
                lcPropiedadNoInfo += "_DbComunesGrNuevo ";
            if (string.IsNullOrWhiteSpace(_DbEjerGrOrigen))
                lcPropiedadNoInfo += "_DbEjerGrOrigen ";
            if (string.IsNullOrWhiteSpace(_DbEjerGrNuevo))
                lcPropiedadNoInfo += "_DbEjerGrNuevo ";
            if (string.IsNullOrWhiteSpace(_CarpetaBackupServidorSql))
                lcPropiedadNoInfo += "_CarpetaBackupServidorSql ";
            if (string.IsNullOrWhiteSpace(_EmpresaGrNuevo))
                lcPropiedadNoInfo += "_EmpresaGrNuevo ";
            if (string.IsNullOrWhiteSpace(_SufiBdEjerGrNuevo))
                lcPropiedadNoInfo += "_SufiBdEjerGrNuevo ";

            if (!string.IsNullOrWhiteSpace(lcPropiedadNoInfo))
            {
                _Error_Message = "Al finalizar las comprobaciones previas a la creación del ejercicio se han detectado propiedades internas sin valor: " + lcPropiedadNoInfo;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }

            if (_DbComunesGrOrigen != _DbComunesGrNuevo)
            {
                _Error_Message = "Al finalizar las comprobaciones previas a la creación del ejercicio se ha detectado diferente valor para los nombres de la base de datos de COMUNES de grupo origen y destino que para la creación de un nuevo ejercicio deberían coincidir: " + _DbComunesGrOrigen + " " + _DbComunesGrNuevo;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }


            if (_DbEjerGrOrigen == _DbEjerGrNuevo)
            {
                _Error_Message = "Al finalizar las comprobaciones previas a la creación del ejercicio se ha detectado identico valor en los nombres de bases de datos de EJERCICIO del ejercicio origen y del ejercicio nuevo a crear: " + _DbEjerGrNuevo;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }



            // VERIFICAR EXISTENCIA DE LA TABLA TABSYS CON DATOS, EN COMUNES
            if (_Log)
                Guardar_Mensaje("Verificando la existencia de la tabla TABSYS en las bases de datos COMUNES y ADDOns del grupo origen.");

            bool llOK = GrupoempTools.CrearGrupo_Comprobar_TabSys("COMUNES", _DbComunesGrOrigen);
            if (!llOK)
                return false;

            if (_Log)
                Guardar_Mensaje("Existe la tabla TABSYS en la bases de datos COMUNES (" + _DbComunesGrOrigen.Trim()+ ") del grupo origen para la creación de nuevo ejercicio: OK.");

            if (_Log)
            {
                Guardar_Mensaje("Comprobaciones previas a la creación del ejercicio satisfactorias: OK."+Environment.NewLine);
                Guardar_Mensaje("FIN PROCESO COMPROBACIONES PREVIAS ANTES DE PROCEDER A LA CREACION DEL NUEVO EJERCICIO" + Environment.NewLine);
            }

            return true;
        }

        private static bool CrearGrupo_Comprobaciones_Previas(string tcGrupo, string tcGrOrigen)
        {
            string lcSql = "";
            DataTable ldtAuxiliar = new DataTable();



            if (_Log)
                Guardar_Mensaje("INICIO COMPROBACIONES PREVIAS"+Environment.NewLine);

            // Comprobamos que pasen bien el código de grupo a crear.
            // Se deberá obtener antes de llamar a este método, mediante llamada a otro método de la
            // DB:    DB._GrupoEmpresa_Obtener_Codigo_Nuevo_Grupo()
            if (string.IsNullOrWhiteSpace(tcGrupo))
            {
                _Error_Message = "No se ha recibido el parámetro código de grupo a crear.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }



            // Si no existe la tabla acabo, esto no debería ocurrir en ningún caso pues si no existe se crea cuando se conecta, pero se comprueba para evitar la petada si fuera el caso.
            if (DB._SQLExisteTablaBBDD("EUROWINSYS", "GRUPOSEMP") == false)
            {
                _Error_Message = "No se ha detectado la tabla eurowinsys.gruposemp, no se creará el grupo " + tcGrupo;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }
            if (_Log)
                Guardar_Mensaje("Existe la tabla GruposEmp: OK.");




            // ESTO DE MOMENTO NO LO CONTROLO POR QUE AL CREAR UN GRUPO POR FORMULARIO COMIENZA GUARDANDOLO SIEMPRE Y ES AL HACER CANCELAR QUE LO BORRA, SEGUN ESTO, ESTA COMPROBACION QUE SIGUE
            // DARA SIEMPRE POSITIVO POR QUE EXISTIRA SIEMPRE EL CODIGO Y NO DEJARIA CREAR NINGUN GRUPO. DE MOMENTO COMENTO.

            DataTable ldtGrupos = new DataTable();
            //lcSql = "SELECT * FROM [EUROWINSYS].[dbo].[gruposemp] where codigo=" + DB.SQLString(tcGrupo);
            //DB.SQLExec(lcSql, ref ldtGrupos);
            //if (ldtGrupos.Rows.Count == 1)
            //{
            //    _Error_Message = "Se ha detectado la existencia ya del grupo " + tcGrupo + " en la tabla eurowinsys.gruposemp, no se creará el grupo " + tcGrupo;
            //    if (_Log)
            //        Guardar_Mensaje(_Error_Message);
            //    return false;
            //}
            //if (_Log)
            //    Guardar_Mensaje("El grupo a crear "+tcGrupo+" no existe en EurowinSys.GruposEmp: OK.");

            // Miramos si tenemos el grupo origen definido en la tabla EUROWINSYS!GRUPOSEMP pues será el origen de la
            // creación del nuevo grupo, es necesario que exista.
            
            // Grupo al que estamos conectados en el instante de la creación del nuevo grupo
            string lcCodGrupoActual = DB.DbComunes.Trim().Substring(4, 4);
            if (_Log)
                Guardar_Mensaje("Conexión origen: grupo "+lcCodGrupoActual+" con base de datos de COMUNES ("+DB.DbComunes+")");
            
            // Obtengo el grupo origen correspondiente al grupo en que estoy.
            string lcCodGrupoPripal = GrupoempTools._Obtener_CodGrupoPripal(lcCodGrupoActual);

            ldtGrupos.Clear();
            lcSql = "SELECT * FROM [EUROWINSYS].[dbo].[gruposemp] where codigo=" + DB.SQLString(lcCodGrupoPripal) + " and pripal=" + DB.SQLTrue();
            DB.SQLExec(lcSql, ref ldtGrupos);
            if (ldtGrupos.Rows.Count != 1)
            {
                _Error_Message = "No se ha detectado el grupo principal de la instalación en la tabla eurowinsys.gruposemp para el grupo activo " + lcCodGrupoActual + ", no se creará el grupo " + tcGrupo;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }
            if (_Log)
                Guardar_Mensaje("Grupo principal asociado al grupo actual: " + Convert.ToString((ldtGrupos.Rows[0]["codigo"])) );
            GrupoempTools._GrupoPrincipal = Convert.ToString(ldtGrupos.Rows[0]["codigo"]);

            
            // Determino el grupo origen de la creación de nuevo grupo, si me passan por parámetro lo utilizo, sino utilizo el grupo principal
            if (!string.IsNullOrWhiteSpace(tcGrOrigen))
            {
                ldtGrupos.Clear();
                lcSql = "SELECT * FROM [EUROWINSYS].[dbo].[gruposemp] where codigo=" + DB.SQLString(tcGrOrigen);
                DB.SQLExec(lcSql, ref ldtGrupos);
                if (ldtGrupos.Rows.Count != 1)
                {
                    _Error_Message = "No se ha detectado el grupo origen " + tcGrOrigen + " en la tabla de grupos, no se creará el grupo " + tcGrupo;
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }
                if (_Log)
                    Guardar_Mensaje("Grupo origen de la creación de grupo: " + tcGrOrigen);
                
                GrupoempTools._GrupoOrigen = tcGrOrigen;
            }
            else
                GrupoempTools._GrupoOrigen = _GrupoPrincipal;

            if (_Log)
            {
                Guardar_Mensaje("Grupo origen que se utilizará para la creación del nuevo grupo: " + GrupoempTools._GrupoOrigen);
                Guardar_Mensaje("Grupo a crear: " + tcGrupo);
            }

            // Miramos que exista la base de datos de COMUNES del grupo origen
            GrupoempTools._DbComunesGrOrigen = "COMU" + _GrupoOrigen.Trim();
            if (!DB._SQLExisteBBDD(_DbComunesGrOrigen))
            {
                _Error_Message = "No se ha detectado en el servidor SQL la base de datos de COMUNES (" + _DbComunesGrOrigen + ") asociada al grupo (" + _GrupoOrigen + ") " +
                                 "que se pretende utilizar para la creación del nuevo grupo, no se creará el grupo " + tcGrupo;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }
            if (_Log)
            {
                Guardar_Mensaje("Base de datos de COMUNES del grupo origen: " + _DbComunesGrOrigen);
                Guardar_Mensaje("Base de datos de COMUNES del grupo origen existe en el servidor SQL.");
            }



            // La base de datos de COMUNES del nuevo grupo a crear no debería existir en el servidor SQL
            GrupoempTools._DbComunesGrNuevo = "COMU" + tcGrupo.Trim();
            if (DB._SQLExisteBBDD(GrupoempTools._DbComunesGrNuevo))
            {
                _Error_Message = "La base de datos " + _DbComunesGrNuevo + " correspondiente al nuevo grupo a crear (" + tcGrupo + ") ya existe en el servidor. Imposible crear grupo.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }
            if (_Log)
            {
                Guardar_Mensaje("Base de datos de COMUNES del grupo a crear " + tcGrupo + ": " + GrupoempTools._DbComunesGrNuevo);
                Guardar_Mensaje("Base de datos de COMUNES del grupo a crear no existe en el servidor SQL.");
            }


            if (_Log)
                Guardar_Mensaje("Obteniendo los Add-ons base");
            GrupoempTools.ObtenerAddonsBase();  //Bug 131839


            // Buscamos las bd. de los Add-ons del grupo origen que reseguiremos después.
            if (_Log)
                Guardar_Mensaje("Obteniendo bases de datos de Add-ons de grupo origen " + GrupoempTools._GrupoOrigen + " (COMU" + _GrupoOrigen + ")");

            DB.SQLExec("select nom_conex,nombre from " + DB.SQLDatabaseReal(GrupoempTools._DbComunesGrOrigen, "modulos"), ref _dtBdAddonsGrOrigen);
            if (_Log)
            {
                Guardar_Mensaje("Detectados " + _dtBdAddonsGrOrigen.Rows.Count.ToString() + " Add-ons.");
                foreach (DataRow loRow in _dtBdAddonsGrOrigen.Rows)
                    Guardar_Mensaje(Convert.ToString(loRow["nom_conex"]));
            }

            // Buscamos la bd del ejercicio PREDET y las guardamos en un DataTable.
            GrupoempTools._DbEjerGrOrigen = "";
            if (_Log)
                Guardar_Mensaje("Obteniendo base de datos de ejercicio predeterminado de " + _DbComunesGrOrigen);
            DB.SQLExec("select * from " + DB.SQLDatabaseReal(GrupoempTools._DbComunesGrOrigen, "ejercici") + " where predet=" + DB.SQLTrue(), ref ldtAuxiliar);
            if (ldtAuxiliar.Rows.Count == 1)
            {
                GrupoempTools._DbEjerGrOrigen = Convert.ToString(ldtAuxiliar.Rows[0]["conexion"]).Trim();
                GrupoempTools._EjerOrigen = Convert.ToString(ldtAuxiliar.Rows[0]["any"]).Trim();
                GrupoempTools._FechaIniEjerOrigen = Convert.ToDateTime(ldtAuxiliar.Rows[0]["periodoini"]);
                GrupoempTools._FechaFinEjerOrigen = Convert.ToDateTime(ldtAuxiliar.Rows[0]["periodofin"]);
                if (_Log)
                {
                    Guardar_Mensaje("Base de datos de EJERCICIO predeterminado de grupo origen: " + GrupoempTools._DbEjerGrOrigen);
                    Guardar_Mensaje("Ejercicio predeterminado en grupo origen: " + GrupoempTools._EjerOrigen);
                }
            }
            else
            {
                _Error_Message = "No se ha detectado la base de datos de ejercicio predeterminado en el grupo origen " + GrupoempTools._GrupoOrigen + ", imposible crear grupo " + tcGrupo;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }

            // La base de datos de EJERCICIO del grupo origen debería existir en el servidor SQL
            if (!DB._SQLExisteBBDD(GrupoempTools._DbEjerGrOrigen))
            {
                _Error_Message = "La base de datos de EJERCICIO " + GrupoempTools._DbEjerGrOrigen + " correspondiente al nuevo grupo a crear (" + tcGrupo + ") no existe en el servidor, imposible crear grupo.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }
            if (_Log)
                Guardar_Mensaje("La base de datos de ejercicio predeterminado del grupo origen " + GrupoempTools._GrupoOrigen + " " + GrupoempTools._DbEjerGrOrigen + " existe en el servidor SQL: OK");


            // Obtener base de datos de ejercicio para el nuevo grupo a crear y su sufijo.
            // Iterar hasta que no exista ninguna de las bases de datos que se crearan para el nuevo grupo con el sufijo (ejercicio y addons). Si detecta que alguna
            // de ellas ya existe, obtendrá otro sufijo y volvera a verificar hasta que ninguna de las bds. existan.
            bool llExisteAlgunaBdNew = false;

            DataTable ldtBdsExcluir = new DataTable();
            ldtBdsExcluir.Columns.Add(new DataColumn("name", typeof(string)));

            do
            {
                // En ldtBdsExcluir (inicialmente vacio al comenzar a iterar) iremos acumulando cualquier bd de gestion que aunque no exista (lo cual la haría candidata
                // a poder ser utilizada), no pueda ser utilizada por existir algun addon con el mismo sufijo u otro ejercicio 
                // con el mismo sufijo.
                //
                GrupoempTools._DbEjerGrNuevo = DB._Obtener_NuevaDb_Gestion(_EjerNuevo, 6, ldtBdsExcluir);
                if (string.IsNullOrWhiteSpace(GrupoempTools._DbEjerGrNuevo))
                {
                    _Error_Message = "No se ha podido obtener el nombre de la base de datos de ejercicio a crear para el nuevo grupo,  imposible crear grupo " + tcGrupo;
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }
                if (_Log)
                    Guardar_Mensaje("Asignado nombre a base de datos de EJERCICIO de nuevo grupo: " + GrupoempTools._DbEjerGrNuevo);

                GrupoempTools._SufiBdEjerGrNuevo = GrupoempTools._DbEjerGrNuevo.Substring(4, 2);

                // Si el sufijo no está bien, paro.
                if (GrupoempTools._SufiBdEjerGrNuevo.Trim().Length != 2)
                {
                    _Error_Message = "El sufijo del nombre de la base de datos de EJERCICIO origen " + _DbEjerGrOrigen + " no tiene el formato correcto, debería tener 2 carácteres: " + GrupoempTools._SufiBdEjerGrNuevo;
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }
                else
                {
                    if (_Log)
                        Guardar_Mensaje("Sufijo para las bases de datos del nuevo grupo: " + GrupoempTools._SufiBdEjerGrNuevo);
                }
                
                // Si existe alguna posible base de datos de addon a crear ya existente con el mismo sufijo o alguna bd de ejercicio, anterio
                // o posterior, al que se pretende crear, con el mismo sufijo, pasaremos de este sufijo y iremos a obtener otro nuevo
                //
                llExisteAlgunaBdNew = GrupoempTools.CrearGrupo_Comprobar_Existencia_BdNuevas(GrupoempTools._EjerNuevo, GrupoempTools._SufiBdEjerGrNuevo);
                if (llExisteAlgunaBdNew)
                {
                    if (_Log)
                        Guardar_Mensaje("Alguna de las nuevas bases de datos a crear en el nuevo grupo con el sufijo " + _SufiBdEjerGrNuevo+" ya existe, se reintenta la generación de nombres de bds. con nuevo sufijo.");

                    // En ldtBdsExcluir iremos acumulando cualquier bd de gestion que aunque no exista (lo cual la haría candidata
                    // a poder ser utilizada), no pueda ser utilizada por existir algun addon con el mismo sufijo u otro ejercicio 
                    // con el mismo sufijo.
                    //

                    DataRow loRow = ldtBdsExcluir.NewRow();
                    loRow["name"] = GrupoempTools._DbEjerGrNuevo.Trim();
                    ldtBdsExcluir.Rows.Add(loRow);
                }
            }
            while (llExisteAlgunaBdNew);


            // La base de datos de EJERCICIO del nuevo grupo a crear no debería existir en el servidor SQL
            if (DB._SQLExisteBBDD(GrupoempTools._DbEjerGrNuevo))
            {
                _Error_Message = "La base de datos " + _DbEjerGrNuevo + " correspondiente al ejercicio del nuevo grupo a crear (" + tcGrupo + ") ya existe en el servidor, imposible crear grupo.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }
            if (_Log)
                Guardar_Mensaje("La base de datos de EJERCICIO " + GrupoempTools._DbEjerGrNuevo + " que se creará para el nuevo grupo no existe en el servidor SQL: OK");




            // En el nuevo grupo solo se ponen los ADDONS que se instalan inicialmente en Sage50: TPV, LOTES, AMORTIZA, MAYORIST, INFORAUT, por tanto
            // eliminaremos del DataTable ldtBdModulosGrOrigen los Add-ons que no estan entre estos (SERVEIS, FIDELIZA, EDI_DOC) pues no se crearan en el nuevo grupo
            bool llHayCambios = false;
            string lcNombreAddon = "";
            for (int i = GrupoempTools._dtBdAddonsGrOrigen.Rows.Count - 1; i >= 0; i--)
            {
                lcNombreAddon = Convert.ToString(GrupoempTools._dtBdAddonsGrOrigen.Rows[i]["nombre"]).Trim().ToUpper();
                if (!GrupoempTools._AddonsInstal.Contains(lcNombreAddon))
                {
                    llHayCambios = true;
                    DataRow dr = GrupoempTools._dtBdAddonsGrOrigen.Rows[i];
                    dr.Delete();
                }
            }
            if (llHayCambios)
                GrupoempTools._dtBdAddonsGrOrigen.AcceptChanges();


            // Las base de datos de los ADDONS que se crearan en el nuevo grupo tampoco deberían existir.
            string lcNewBdAddon = "";

            // Clonamos ya el DataTable de Addons del grupo origen para averiguar las bases de datos de Addons que tendran en el nuevo grupo.
            GrupoempTools._dtBdAddonsGrNuevo = GrupoempTools._dtBdAddonsGrOrigen.Clone();
            GrupoempTools._dtBdAddonsGrNuevo.Clear();


            foreach (DataRow loRow in GrupoempTools._dtBdAddonsGrOrigen.Rows)
            {
                lcNewBdAddon = Convert.ToString(loRow["nom_conex"]).Trim();
                lcNewBdAddon = lcNewBdAddon.Substring(0, lcNewBdAddon.Length - 2);
                lcNewBdAddon = lcNewBdAddon + GrupoempTools._SufiBdEjerGrNuevo;

                lcNombreAddon = Convert.ToString(loRow["nombre"]).Trim().ToUpper();

                // La base de datos de los Addons nuevos a crear no deberían existir en el servidor SQL
                if (DB._SQLExisteBBDD(lcNewBdAddon))
                {
                    _Error_Message = "La base de datos " + lcNewBdAddon + " correspondiente al nuevo grupo a crear (" + tcGrupo + ") ya existe en el servidor, imposible crear grupo.";
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }
                else
                {
                    // Agrego la nueva bd del Addons al DataTable
                    DataRow loRow2 = GrupoempTools._dtBdAddonsGrNuevo.NewRow();
                    loRow2["nombre"] = loRow["nombre"];
                    loRow2["nom_conex"] = lcNewBdAddon;
                    GrupoempTools._dtBdAddonsGrNuevo.Rows.Add(loRow2);

                    if (_Log)
                        Guardar_Mensaje("La base de datos del Add-On " + lcNombreAddon + " " + lcNewBdAddon + " correspondiente al nuevo grupo a crear (" + tcGrupo + ") no existe en el servidor: OK");
                }
            }


            // tcCarpetaBackupServidorSql = lcCarpetaDataServidorSql.ToLower().Replace("\\data", "\\backup");
            GrupoempTools._CarpetaBackupServidorSql = DB._SQLRutaBackup();
            if (string.IsNullOrWhiteSpace(_CarpetaBackupServidorSql))
            {
                _Error_Message = "No se ha podido averiguar la carpeta de Backup del servidor SQL.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }

            if (_Log)
                Guardar_Mensaje("Obtenida ruta de Backup en el servidor SQL " + _CarpetaBackupServidorSql + ": OK");



            
            // Obtener nº de dígitos de la cuenta contable, marca, familia, vendedor, etc.,  en el grupo origen, se utilizará en el ajuste de datos que se realiza una vez creadas las bases de datos del nuevo grupo
            if (_Log)
                Guardar_Mensaje("Obteniendo nº de dígitos anchura de campos CUENTA, MARCA, FAMILIA, VENDEDOR según base de datos de ejercicio en grupo origen.");

            // Si no creamos el grupo con las longitudes estándar, entonces cogemos las longitudes del grupo origen
            if (!GrupoempTools._LongitudesEstandar)
            {
                GrupoempTools._LenCuenta = GrupoempTools.CrearGrupo_Obtener_LenCampo(_DbEjerGrOrigen, "cuentas", "cuenta contable", 8);
                GrupoempTools._LenMarca = GrupoempTools.CrearGrupo_Obtener_LenCampo(_DbEjerGrOrigen, "marcas", "marca", 2);
                GrupoempTools._LenFamilia = GrupoempTools.CrearGrupo_Obtener_LenCampo(_DbEjerGrOrigen, "familias", "familia", 2);
                GrupoempTools._LenVendedor = GrupoempTools.CrearGrupo_Obtener_LenCampo(_DbEjerGrOrigen, "vendedor", "vendedor", 2);
                GrupoempTools._LenAlmacen = GrupoempTools.CrearGrupo_Obtener_LenCampo(_DbEjerGrOrigen, "almacen", "almacén", 2); // Bug 109147
            }
            else
            {
                // Crear el grupo con las longitudes estándar, definimos las longitudes estándar
                GrupoempTools._LenCuenta = 8;
                GrupoempTools._LenMarca = 2;
                GrupoempTools._LenFamilia = 2;
                GrupoempTools._LenVendedor = 2;
                GrupoempTools._LenAlmacen = 2; // Bug 109147
            }

            // Averiguar prefijo de 3 dígitos con la que comienzan los clientes, proveedores y acreedores contables.
            DB.SQLExec("select * from " + DB.SQLDatabaseReal(_DbComunesGrOrigen, "codcom"), ref ldtAuxiliar);
            if (ldtAuxiliar.Rows.Count > 0)
            {
                GrupoempTools._PrefijoCli3 = Convert.ToString(ldtAuxiliar.Rows[0]["cliente"]).Substring(0, 3);
                GrupoempTools._PrefijoPro3 = Convert.ToString(ldtAuxiliar.Rows[0]["proveed"]).Substring(0, 3);
                GrupoempTools._PrefijoAcr3 = Convert.ToString(ldtAuxiliar.Rows[0]["acreed"]).Substring(0, 3);
                GrupoempTools._PrefijoBan3 = Convert.ToString(ldtAuxiliar.Rows[0]["banco"]).Substring(0, 3);
                GrupoempTools._PrefijoCaj3 = Convert.ToString(ldtAuxiliar.Rows[0]["caja"]).Substring(0, 3);
                GrupoempTools._PrefijoCom3 = Convert.ToString(ldtAuxiliar.Rows[0]["compra"]).Substring(0, 3);
                GrupoempTools._PrefijoVen3 = Convert.ToString(ldtAuxiliar.Rows[0]["venta"]).Substring(0, 3);
                GrupoempTools._PrefijoDeudor3 = Convert.ToString(ldtAuxiliar.Rows[0]["deudor"]).Substring(0, 3);

                if (string.IsNullOrWhiteSpace(GrupoempTools._PrefijoCli3) || string.IsNullOrWhiteSpace(GrupoempTools._PrefijoPro3) ||
                    string.IsNullOrWhiteSpace(GrupoempTools._PrefijoAcr3) || string.IsNullOrWhiteSpace(GrupoempTools._PrefijoBan3) ||
                    string.IsNullOrWhiteSpace(GrupoempTools._PrefijoCom3) || string.IsNullOrWhiteSpace(GrupoempTools._PrefijoVen3) ||
                    string.IsNullOrWhiteSpace(GrupoempTools._PrefijoCaj3) || string.IsNullOrWhiteSpace(GrupoempTools._PrefijoDeudor3) )
                {
                    _Error_Message = "No se ha podido detectar los prefijos de 3 dígitos para alguna de las cuentas contables de clientes, deudores, proveedores, acreedores, bancos, compras o ventas en el grupo origen " + _GrupoOrigen+", alguno de ellos está vacío.";
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }
            }
            else
            {
                _Error_Message = "No se ha podido detectar los prefijos de 3 dígitos para alguna de las cuentas contables de clientes, deudores, proveedores, acreedores, bancos, compras o ventas. No hay registros en COMUNES.CODCOM en el grupo origen " + _GrupoOrigen;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }


            // Detectamos con qué empresa trabajaremos, en condiciones normales será la '01' que será la que instala Sage50 de base, pero podrían haberla borrado en el grupo origen
            // y trabajar con otras, en este caso cogeremos la primera por orden.
            DB.SQLExec("select codigo from " + DB.SQLDatabaseReal(_DbEjerGrOrigen, "empresa") + " where codigo='01'", ref ldtAuxiliar);
            if (ldtAuxiliar.Rows.Count == 1 && Convert.ToString(ldtAuxiliar.Rows[0]["codigo"]) == "01")
                GrupoempTools._EmpresaGrNuevo = "01";
            else
            {
                DB.SQLExec("select codigo from " + DB.SQLDatabaseReal(_DbEjerGrOrigen, "empresa") + " order by codigo", ref ldtAuxiliar);
                if (ldtAuxiliar.Rows.Count == 0)
                {
                    _Error_Message = "No se ha detectado ningún registro en la tabla EMPRESA de la base de datos de ejercicio "+_DbEjerGrOrigen+" del grupo origen  " + _GrupoOrigen+", no se creará el grupo.";
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;                
                }
                else
                {
                    GrupoempTools._EmpresaGrNuevo = Convert.ToString(ldtAuxiliar.Rows[0]["codigo"]);
                }
            }


            // Compruebo que todas las propiedades anteriores tengan valor, en teoria si se ha llegado hasta aquí todas ellas deberían estar informadas.
            string lcPropiedadNoInfo = "";
            if (string.IsNullOrWhiteSpace(_GrupoPrincipal))
                lcPropiedadNoInfo += "_GrupoPrincipal ";
            if (string.IsNullOrWhiteSpace(_GrupoOrigen))
                lcPropiedadNoInfo += "_GrupoOrigen ";
            if (string.IsNullOrWhiteSpace(_DbComunesGrOrigen))
                lcPropiedadNoInfo += "_DbComunesGrOrigen ";
            if (string.IsNullOrWhiteSpace(_DbEjerGrOrigen))
                lcPropiedadNoInfo += "_DbEjerGrOrigen ";
            if (string.IsNullOrWhiteSpace(_DbComunesGrNuevo))
                lcPropiedadNoInfo += "_DbComunesGrNuevo ";
            if (string.IsNullOrWhiteSpace(_DbEjerGrNuevo))
                lcPropiedadNoInfo += "_DbEjerGrNuevo ";
            if (string.IsNullOrWhiteSpace(_CarpetaBackupServidorSql))
                lcPropiedadNoInfo += "_CarpetaBackupServidorSql ";
            if (string.IsNullOrWhiteSpace(_EmpresaGrNuevo))
                lcPropiedadNoInfo += "_EmpresaGrNuevo ";
            if (string.IsNullOrWhiteSpace(_SufiBdEjerGrNuevo))
                lcPropiedadNoInfo += "_SufiBdEjerGrNuevo ";
            if (string.IsNullOrWhiteSpace(_EjerOrigen))
                lcPropiedadNoInfo += "_EjerOrigen ";
            if (_FechaIniEjerOrigen == null)
                lcPropiedadNoInfo += "_FechaIniEjerOrigen ";
            if (_FechaFinEjerOrigen == null)
                lcPropiedadNoInfo += "_FechaFinEjerOrigen ";


            if (!string.IsNullOrWhiteSpace(lcPropiedadNoInfo))
            {
                _Error_Message = "Al finalizar las comprobaciones previas a la creación del grupo se han detectado propiedades internas sin valor: "+lcPropiedadNoInfo;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }

            if (_DbComunesGrOrigen == _DbComunesGrNuevo)
            {
                _Error_Message = "Al finalizar las comprobaciones previas a la creación del nuevo grupo se han detectado identico valor en los nombres de bases de datos de COMUNES del grupo origen y del grupo nuevo a crear: "+_DbComunesGrOrigen;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;            
            }

            if ( _DbEjerGrOrigen == _DbEjerGrNuevo)
            {
                _Error_Message = "Al finalizar las comprobaciones previas a la creación del nuevo grupo se han detectado identico valor en los nombres de bases de datos de EJERCICIO del grupo origen y del grupo nuevo a crear: "+_DbEjerGrOrigen; 
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;            
            }


            
            // VERIFICAR EXISTENCIA DE LA TABLA TABSYS CON DATOS, EN COMUNES Y EN LOS ADDONS DEL grupo origen
            if (_Log)
                Guardar_Mensaje("Verificando la existencia de la tabla TABSYS en las bases de datos COMUNES y ADDOns del grupo origen.");

            bool llOK = GrupoempTools.CrearGrupo_Comprobar_TabSys("COMUNES",_DbComunesGrOrigen);
            if (!llOK)
                return false;

            if (_Log)
                Guardar_Mensaje("Existe la tabla TABSYS en todas las bases de datos COMUNES y ADDONS del grupo origen: OK.");
           
            string lcBdAddon="";
            foreach (DataRow loRow in _dtBdAddonsGrOrigen.Rows)
            {
                lcNombreAddon = Convert.ToString(loRow["nombre"]).Trim();
                lcBdAddon = Convert.ToString(loRow["nom_conex"]).Trim().ToUpper();
                llOK = GrupoempTools.CrearGrupo_Comprobar_TabSys("ADDON", lcBdAddon, lcNombreAddon);
                if (!llOK)
                    return false;
            }


            if (_Log)
            {
                Guardar_Mensaje("Comprobaciones previas a la creación del grupo satisfactorias: OK."+Environment.NewLine);
                Guardar_Mensaje("FIN COMPROBACIONES PREVIAS"+Environment.NewLine);
            }

            return true;
        }

        private static bool Backup_Bd(string tcDb, string tcMensajeLog = "")
        {
            bool llOk = false;

            if (GrupoempTools._Log)
                Guardar_Mensaje("Realizando copia base de datos " + tcDb);

            llOk = DB._DbBackup(tcDb, GrupoempTools._CarpetaBackupServidorSql);


            if (llOk)
            {
                if (GrupoempTools._Log)
                    Guardar_Mensaje("La copia de seguridad de la base de datos de " + tcMensajeLog + " " + tcDb + " se ha realizado correctamente: OK");
            }
            else
            {
                _Error_Message = "La copia de seguridad de la base de datos de " + tcMensajeLog + " " + tcDb + " NO se ha realizado correctamente.";
                if (GrupoempTools._Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }

            return true;
        }


        private static bool Restore_Bd(string tcDbNombreViejo, string tcDbNombreNuevo,  string tcMensalog = "")
        {
            bool llOk = false;

            if (_Log)
                Guardar_Mensaje("Realizando restauración de la copia de la base de datos de " + tcMensalog + " del grupo origen " + tcDbNombreViejo + " con nuevo nombre " + tcDbNombreNuevo);
            DB.Error_Message = "";
            llOk = DB._DbRestore(tcDbNombreViejo, tcDbNombreNuevo, GrupoempTools._CarpetaBackupServidorSql, GrupoempTools._UserPropBdGrNuevo);
            if (llOk)
            {
                if (_Log)
                    Guardar_Mensaje("La creación de la nueva base de datos de " + tcMensalog + " " + tcDbNombreNuevo + " se ha realizado correctamente: OK");
            }
            else
            {
                // CCR 191787
                // Si no funcionó el RESTORE probablemente sea debido al problema de que no ha poddio cambiar el usuario a la
                // base de datos por estar todo con usuario Eurowin y debido a que el DTS no pudo hacer el cambio a usuario Sage50
                // al pasar el DTS.
                //
                // Miramos si tenemos contraseña de sa (solo la tendremos si la creación del grupo fue en visual, se pide si no se
                // puede detectar automáticamente, si la creación del grupo fue desde DTS no se pide y estará vacia)
                // 
                // Si no tenemos contraseña de sa acabamos devolviendo false.
                // Si tenemos contraseña de sa intentaremos conectar con usuario sa y volver a intentar el RESTORE
                //
                if (string.IsNullOrWhiteSpace(GrupoempTools._CrearGrupoP))
                {
                    _Error_Message = "NO se ha podido restaurar la copia de seguridad de la base de datos de " + tcMensalog + " " + tcDbNombreViejo + " como " + tcDbNombreNuevo + ", imposible crear grupo. Error: " + DB.Error_Message;
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }

                // Si se ha producido un error, borrar la base de datos si existe, pues si el error fue al cambiar el usuario de la bd
                // la bd. estará ya creada, y si a continuación se vuelve a intentar el RESTORE con usuario sa la bd no debería
                // existir, sino no podrá hacer el RESTORE tampoco.
                //
                borrarBaseDatos(tcDbNombreNuevo);

                if (_Log)
                {
                    Guardar_Mensaje("NO se ha podido restaurar la copia de seguridad de la base de datos de " + tcMensalog + " " + tcDbNombreViejo + " como " + tcDbNombreNuevo + ". Error: " + DB.Error_Message);
                    Guardar_Mensaje("Intentando restaurar la base de datos con el usuario 'sa'");
                }

                // Vamos a intentar restaurar la base de datos conectando primero con sa
                //
                
                //Obtener usuario y contraseña actual de la conexión
                string lcUsuarioActual = string.Empty;
                string lcPassActual = string.Empty;
                datosConexionActual(out lcUsuarioActual, out lcPassActual);

                // Conectar con el usuario "sa" y restaurar base de datos
                string lcMsgError = string.Empty;
                llOk = restoreUsuario(tcDbNombreViejo, tcDbNombreNuevo, lcUsuarioActual, out lcMsgError, tcMensalog);

                //Restauramos la conexión del usuario anterior
                conectarUsuario(lcUsuarioActual, lcPassActual);

                if (!llOk)
                {
                    _Error_Message = lcMsgError;
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);

                    return false;
                }
            }

            
            return llOk;
        }

        private static bool Restore_Indices_ValoresDefecto(string tcDbNombreViejo, string tcDbNombreNuevo)
        {
            // Solamente lo utilizamos cuando creamos un grupo con copia y restauración
            if (GrupoempTools._TipoOperativaCreacionGrupoEjer != GrupoempTools.TipoOperativaCreacion.PorCopiaRestauracionBd)
                return true;
            
            if (_Log)
                Guardar_Mensaje("Revisando índices y valores por defecto de la base de datos " + tcDbNombreNuevo);

            // Obtener en un DataTable los valores por defecto de las tablas de la base de datos origen
            DataTable ldtIndices = new DataTable();
            if (ObtenerIndicesDb(tcDbNombreNuevo, ref ldtIndices))
            {
                // Actualizar los indices de la base de datos
                if (!CrearGrupoEjer_Actualizar_Indices(tcDbNombreViejo, tcDbNombreNuevo, "", ldtIndices))
                    return false;
            }

            // Obtener en un DataTable los valores por defecto de las tablas de la base de datos origen
            DataTable ldtValsDefecto = new DataTable();
            if (ObtenerValoresDefectoDb(tcDbNombreNuevo, ref ldtValsDefecto))
            {
                // Actualizar los valores por defecto de la base de datos
                if (!CrearGrupoEjer_Actualizar_ValoresDefecto(tcDbNombreViejo, tcDbNombreNuevo, "", ldtValsDefecto))
                    return false;
            }

            if (_Log)
                Guardar_Mensaje("Se han revisado los índices y valores por defecto de la base de datos " + tcDbNombreNuevo);

            return true;
            
        }


        private static bool ObtenerIndicesDb(string tcDb, ref DataTable dtIndices)
        {
            bool llOk = false;

            // Obtener en un DataTable los indices de la base de datos
            dtIndices = new DataTable();
            llOk = DB._DbIndicesCampos(tcDb, ref dtIndices);
            if (!llOk)
            {
                _Error_Message = "No se pudieron obtener los índices de las tablas de la base de datos " + tcDb;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }

            return true;
        }

        private static bool ObtenerValoresDefectoDb(string tcDb, ref DataTable dtValoresDefecto)
        {
            bool llOk = false;

            // Obtener en un DataTable los valores por defecto de las tablas de la base de datos
            dtValoresDefecto = new DataTable();
            llOk = DB._DbValoresDefectoCampos(tcDb, ref dtValoresDefecto);
            if (!llOk)
            {
                _Error_Message = "No se pudieron obtener los valores por defecto de las tablas de la base de datos " + tcDb;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }

            return true;
        }

        private static bool BorrarGrupo_Remove_Bd(string tcDb, string tcMensajeLog = "")
        {
            bool llOk = true;
            string lcComando = "";

            if (!DB._SQLExisteBBDD(tcDb))
            {
                if (_Log)
                    Guardar_Mensaje("Se pretendía eliminar la base de datos " + tcMensajeLog + " " + tcDb + " pero no se ha detectado su existencia en el servidor de datos SQL.");
            }
            else
            {
                lcComando = "DROP DATABASE [" + tcDb + "]";
                if (_Log)
                    Guardar_Mensaje("Eliminación de la base " + tcMensajeLog + " " + tcDb);

                llOk = DB.SQLExec(lcComando);

                if (_Log)
                {
                    Guardar_Mensaje("Resultado de " + lcComando + ": " + (llOk ? "OK" : "KO"));
                    if (!llOk && !string.IsNullOrWhiteSpace(DB.Error_Message))
                        Guardar_Mensaje("Motivo : " + DB.Error_Message);
                    Guardar_Mensaje("Verificando existencia da la base de datos " + tcDb + " tras borrado.");
                }

                if (DB._SQLExisteBBDD(tcDb))
                {
                    llOk = false;
                    if (_Log)
                        Guardar_Mensaje("La base de datos " + tcDb + " aún existe en el servidor SQL, no quedó eliminada.");
                }
                else
                {
                    if (_Log)
                        Guardar_Mensaje("La base de datos " + tcDb + " fue correctamente eliminada y ya no existe en el servidor SQL: OK");
                }
            }

            return llOk;
        }

        private static bool RevisarBaseDatosEnUso()
        {
            string lcMensaje = string.Empty;
            bool llOk = true;
            Dictionary<String, String> dicBds = new Dictionary<string, string> { };
            string lcBds = string.Empty;

            // BASES DE DATOS DE LOS ADD-ONS
            foreach (DataRow loRow in GrupoempTools._dtBdAddonsGrBorrar.Rows)
                dicBds.Add(Convert.ToString(loRow["nom_conex"]).Trim(), Convert.ToString(loRow["nombre"]).Trim());

            // BASES DE DATOS DE LOS EJERCICIOS
            foreach (DataRow loRow in GrupoempTools._dtBdEjerGrBorrar.Rows)
                dicBds.Add(Convert.ToString(loRow["conexion"]).Trim(), Convert.ToString(loRow["any"]).Trim());

            // BASES DE DATOS DE COMUNES
            dicBds.Add(GrupoempTools._DbComunesGrBorrar, "COMUNES");

            // Revisar si alguna de las bases de datos está en uso
            foreach (KeyValuePair<String, String> loBd in dicBds)
            {
                lcMensaje = "";
                if (!RevisarEnuso(loBd.Key, ref lcMensaje))
                {
                    lcBds = lcBds + (!string.IsNullOrWhiteSpace(lcBds) ? ", " : " ") + loBd.Key;
                    llOk = false;
                    if (_Log)
                        Guardar_Mensaje(lcMensaje);
                }
                else
                {
                    if (_Log)
                        Guardar_Mensaje("La base de datos "+ loBd+" se han cerrado todas las conexiones pendientes.");
                }
            }

            if (!llOk)
                _Error_Message = "Las siguientes bases de datos se encuentran en uso: " + lcBds;

            return llOk;
        }



        private static bool RevisarEnuso(string tcDb, ref string tcMensajeLog)
        {
            string lcSql = string.Empty;
            bool llOk = false;

            // Si no existe base de datos no hacer nada
            if (!DB._SQLExisteBBDD(tcDb))
                return true;

            lcSql = "USE master; ";
            llOk = DB.SQLExec(lcSql);

            lcSql = "ALTER DATABASE [" + tcDb + "] " +
                     "SET SINGLE_USER " +
                     "WITH ROLLBACK IMMEDIATE; " +
                     "ALTER DATABASE [" + tcDb + "] " +
                     "SET MULTI_USER; ";
            llOk = DB.SQLExec(lcSql);

            if (!llOk)
                tcMensajeLog = string.IsNullOrWhiteSpace(DB.Error_Message) ? "En la base de datos " + tcDb + " no se han podido cerrar las conexiones." : DB.Error_Message;

            return llOk;
        }


        private static void Guardar_Mensaje(string tcTexto="")
        {
            string lcTime;
            lcTime = Convert.ToString(DateTime.Now);

            _cCadenaLog.Append((tcTexto != Environment.NewLine ? lcTime + " " + tcTexto : "") + Environment.NewLine);
        }

        private static void CopiarStringLog_Fichero(string tcFichero)
        {
            File.WriteAllText(tcFichero, Convert.ToString(_cCadenaLog), Encoding.UTF8);
        }


        
        private static void CrearGrupo_AnadirGrupo_Gruposemp(string tcGrupo, string tcNombreGrupo)
        {
            DataTable ldtAuxiliar = new DataTable();
            string lcIdSage50 = "";

            tcNombreGrupo = !string.IsNullOrWhiteSpace(tcNombreGrupo) ? tcNombreGrupo : "NOMBRE GRUPO";                       

            DB.SQLExec("select idsage50 from " + DB.SQLDatabaseReal("eurowinsys", "gruposemp") + " " +
                           "where codigo = " + DB.SQLString(GrupoempTools._GrupoPrincipal), ref ldtAuxiliar);
            if (ldtAuxiliar != null && ldtAuxiliar.Rows.Count > 0)
                lcIdSage50 = Convert.ToString(ldtAuxiliar.Rows[0]["idsage50"]);

            ldtAuxiliar = new DataTable();            
            DB.SQLExec("select codigo from " + DB.SQLDatabaseReal("eurowinsys", "gruposemp") + " " +
                           "where codigo=" + DB.SQLString(tcGrupo), ref ldtAuxiliar);
            if (ldtAuxiliar.Rows.Count == 0)
            {
                if (_Log)
                    Guardar_Mensaje("Creando registro de grupo en la tabla de grupos.");

                DB.SQLExec("insert into " + DB.SQLDatabaseReal("eurowinsys", "gruposemp") + " (codigo,nombre,codpripal,idsage50) " +
                           "values (" + DB.SQLString(tcGrupo) + ", " + DB.SQLString(tcNombreGrupo) + ", " + DB.SQLString(GrupoempTools._GrupoPrincipal) + ", " + DB.SQLString(lcIdSage50) + ")");
            }
            else
            {
                DB.SQLExec("update " + DB.SQLDatabaseReal("eurowinsys", "gruposemp") + " set nombre = " + DB.SQLString(tcNombreGrupo) + ", idsage50 = " + DB.SQLString(lcIdSage50) + 
                           " where codigo=" + DB.SQLString(tcGrupo));            
            }

        }


        private static bool CrearGrupo_AnadirGrupo_CfgCliSrv()
        {

            string lcEuroserv = GrupoempTools._Euroserv.Trim();
            if (string.IsNullOrWhiteSpace(lcEuroserv))
            {
                _Error_Message = "No se ha podido añadir la conexión a COMUNES del nuevo grupo al fichero cfgclisrv.xml, no se ha detectado la ruta hacia el servidor (euroserv).";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;            
            }

            // Comprobar si existe cfgclisrv.xml
            string lcCfgCliSrvXml = Path.Combine(lcEuroserv, "cfgclisrv.xml");
            if (!File.Exists(lcCfgCliSrvXml))
            {
                _Error_Message = "No se ha podido añadir la conexión a COMUNES del nuevo grupo al fichero " + lcCfgCliSrvXml + ", no existe el fichero en dicha ruta.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }
    

            
            
            
            // PASO 1/2 AÑADIR EL NUEVO GRUPO RECIEN CREADO AL CFGCLISRV.XML EN EUROSERV

            // Cargamos el cfgclisrv.xml en memoria
            XmlDocument xmlCfgCliSrv = new XmlDocument();
            xmlCfgCliSrv.Load(lcCfgCliSrvXml);
            

            // Recorremos el XML en busca del registro de la base de datos de COMUNES del grupo origen que se empleó para la creación del nuevo grupo por que cogeremos
            // los datos de usuario, password, servidor, de ese registro.
            XmlNode VFPDataNode = xmlCfgCliSrv["VFPData"];
            string lcUser="", lcPassword="", lcIp="";
            bool llConexionFound=false;

            foreach (XmlNode cfgclisrvNode in VFPDataNode.ChildNodes)
            {
                if (cfgclisrvNode.Name.ToLower().Trim() == "cfgclisrv")
                {
                    if (cfgclisrvNode["comunes"].InnerText.Trim().ToLower() == _DbComunesGrOrigen.Trim().ToLower())
                    {
                        // Get values nodes
                        lcUser = cfgclisrvNode["user"].InnerText;
                        lcPassword = cfgclisrvNode["password"].InnerText;
                        lcIp = cfgclisrvNode["ip"].InnerText;
                        llConexionFound = true;
                        break;
                    }
                }
            }

            // Si no se encontró el registro del COMUNES del grupo origen avisamos de ello y salimos.
            if (!llConexionFound)
            {
                _Error_Message = "No se ha detectado el registro correspondiente a la base de datos de COMUNES "+ _DbComunesGrOrigen+" en "+lcCfgCliSrvXml;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }


            // Creo el nuevo nodo con los datos de la conexión al nuevo grupo.
            try
            {

                XmlNode loNodeCfgCliSrv = xmlCfgCliSrv.CreateElement("cfgclisrv");

                XmlNode loNodeUser = xmlCfgCliSrv.CreateElement("user");
                loNodeUser.InnerText = lcUser.Trim();
                loNodeCfgCliSrv.AppendChild(loNodeUser);

                XmlNode loNodePassword = xmlCfgCliSrv.CreateElement("password");
                loNodePassword.InnerText = lcPassword;
                loNodeCfgCliSrv.AppendChild(loNodePassword);

                XmlNode loNodeIp = xmlCfgCliSrv.CreateElement("ip");
                loNodeIp.InnerText = lcIp.Trim();
                loNodeCfgCliSrv.AppendChild(loNodeIp);

                XmlNode loNodePort = xmlCfgCliSrv.CreateElement("port");
                loNodePort.InnerText = "0";
                loNodeCfgCliSrv.AppendChild(loNodePort);

                XmlNode loNodeComunes = xmlCfgCliSrv.CreateElement("comunes");
                loNodeComunes.InnerText = _DbComunesGrNuevo.Trim(); ;
                loNodeCfgCliSrv.AppendChild(loNodeComunes);

                XmlNode loNodeServer = xmlCfgCliSrv.CreateElement("server");
                loNodeServer.InnerText = "SQLSERVER";
                loNodeCfgCliSrv.AppendChild(loNodeServer);

                XmlNode loNodeAutWin = xmlCfgCliSrv.CreateElement("autwin");
                loNodeAutWin.InnerText = "false";
                loNodeCfgCliSrv.AppendChild(loNodeAutWin);

                XmlNode loNodeOdbc = xmlCfgCliSrv.CreateElement("odbc");
                loNodeOdbc.InnerText = "SQL Server Native Client 11.0";
                loNodeCfgCliSrv.AppendChild(loNodeOdbc);

                VFPDataNode.AppendChild(loNodeCfgCliSrv);

                xmlCfgCliSrv.Save(lcCfgCliSrvXml);
            }
            catch (Exception loEx)
            {
                _Error_Message = "Ha habido un problema al añadir la base de datos de COMUNES del nuevo grupo " + _DbComunesGrNuevo + " al fichero cfgclisrv.xml en euroserv. Mensaje de error: " + loEx.Message;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }



            // PASO 2/2 AÑADIR LA BASE DE DATOS DE COMUNES DEL GRUPO RECIEN CREADO A CFGCLISRV.DBF
            try
            {
                // Comprobar si existe cfgclisrv.dbf
                string lcCfgCliSrvDbf = Path.Combine(lcEuroserv, "cfgclisrv.dbf");

                // Bug 172594 - Solamente actualizar el cfgclisrv.dbf si existe.
                //              El proceso de instalación en .NET no crea el fichero cfgclisrv.dbf y daba error al crear un grupo de empresa en el DTS.
                if (File.Exists(lcCfgCliSrvDbf))
                {
                    DataTable dtDbf = new DataTable();
                    OdbcConnection loConn = new OdbcConnection();
                    OdbcCommand loCmd = loConn.CreateCommand();

                    loConn.ConnectionString = @"Driver={Microsoft Visual FoxPro Driver};SourceType=DBF;SourceDB=" + lcEuroserv + ";";

                    if (!lcEuroserv.Trim().EndsWith("\\"))
                        lcEuroserv = lcEuroserv.Trim() + "\\";

                    loConn.Open();

                    loCmd.CommandText = @"SELECT * FROM " + lcEuroserv + "CFGCLISRV.DBF WHERE !deleted() and comunes = '" + _DbComunesGrNuevo.Trim() + "' and ip='"+ lcIp.Trim()+"'";  
                    dtDbf.Load(loCmd.ExecuteReader());

                    // Miro si existen en CFGCLISRV.DBF las columnas AUTWIN y ODBC, y caso de que existen las relleno con los valores
                    // correspondientes.
                    //
                    bool llColumnaAutWin = dtDbf.Columns.Contains("autwin");
                    string lcNombreColumnas = "", lcValoresColumnas = "";
                    if (llColumnaAutWin)
                    {
                        lcNombreColumnas = " , autwin";
                        lcValoresColumnas = " , "+DB.SQLFalse();
                    }

                    bool llColumnaOdbc = dtDbf.Columns.Contains("odbc");
                    if (llColumnaOdbc)
                    {
                        lcNombreColumnas += ", odbc";
                        lcValoresColumnas += ", "+DB.SQLString("SQL Server Native Client 11.0");
                    }

                    // PE-90892 - Controlar que exista un registro
                    if (dtDbf.Rows.Count == 0)
                    {
                        loCmd.CommandText = "INSERT INTO cfgclisrv (user, password, ip, port, comunes, server "+ lcNombreColumnas + ") "+
                                            "VALUES ('" + lcUser.Trim() + "','" + lcPassword.Trim() + "','" + lcIp.Trim() + "',0,'" + _DbComunesGrNuevo + "','SQLSERVER'"+lcValoresColumnas+")";
                        loCmd.ExecuteNonQuery();
                    }

                    loConn.Close();

                    dtDbf.Dispose();
                }
            }
            catch (Exception loEx)
            { 
                // _Error_Message = "Ha habido un problema al añadir la base de datos de COMUNES del nuevo grupo "+_DbComunesGrNuevo+" al fichero cfgclisrv.dbf en euroserv. Mensaje de error: "+loEx.Message;
                if (_Log)
                    Guardar_Mensaje("Ha habido un problema al añadir la base de datos de COMUNES del nuevo grupo " + _DbComunesGrNuevo + " al fichero cfgclisrv.dbf en euroserv. Mensaje de error: " + loEx.Message);
                // ATENCION !!!
                // Contrariamente al caso del XML aqui si algo no va bien no cancelo la creación del grupo por que podria ser que en este terminal no hubiera el driver de FOXPRO y no funcionaria pero no por eso
                // hemos de dar por fallo el proceso, no podrá entrar en el nuevo grupo con el UTILCS.EXE por que a dia de hoy no se mira el CFGCLISRV.XML sino el DBF, pero a Sage50 con el nuevo grupo si que podrá
                // entrar por que Sage50 sí mira el XML y no el DBF.   
            }
            



            return true;
        }

        public static bool _BorrarGrupo_QuitarGrupo_CfgCliSrv(string tcGrupo)
        {

            // Se puede llamar también desde frmGruporEmp si se borra un grupo en modo desvinculación (no borrado), de ahí que sea publica.
            string lcEuroserv = GrupoempTools._Euroserv.Trim();

            if (string.IsNullOrWhiteSpace(lcEuroserv))
            {
                _Error_Message = "No se ha podido borrar la conexión a COMUNES del grupo del fichero cfgclisrv.xml y dbf, no se ha detectado la ruta hacia el servidor (euroserv).";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }

            // Comprobar si existe cfgclisrv.xml
            string lcCfgCliSrvXml = Path.Combine(lcEuroserv, "cfgclisrv.xml");
            if (!File.Exists(lcCfgCliSrvXml))
            {
                _Error_Message = "No se ha podido borrar la conexión a COMUNES del grupo del fichero " + lcCfgCliSrvXml + ", no existe el fichero en dicha ruta.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }




            // QUITAR EL GRUPO DE CFGCLISRV.XML EN EUROSERV

            // Cargamos el cfgclisrv.xml en memoria
            XmlDocument xmlCfgCliSrv = new XmlDocument();
            xmlCfgCliSrv.Load(lcCfgCliSrvXml);


            // Recorremos el XML en busca del registro de la base de datos de COMUNES del grupo que se pretende borrar.
            XmlNode VFPDataNode = xmlCfgCliSrv["VFPData"];
            bool llConexionFound = false;

            // Conexion a COMUNES del grupo que se borra.
            string lcDbComunes = "COMU" + tcGrupo;

            XmlNode loNodoConex = null;

            foreach (XmlNode cfgclisrvNode in VFPDataNode.ChildNodes)
            {
                if (cfgclisrvNode.Name.ToLower().Trim() == "cfgclisrv")
                {
                    if (cfgclisrvNode["comunes"].InnerText.Trim().ToLower() == lcDbComunes.Trim().ToLower())
                    {
                        loNodoConex = cfgclisrvNode;

                        llConexionFound = true;
                        break;
                    }
                }
            }

            // Si no se encontró el registro del COMUNES del grupo avisamos de ello pero no damos error pues es justamente lo que se pretende, que no exista el registro.
            if (!llConexionFound)
            {
                _Error_Message = "No se ha detectado el registro correspondiente a la base de datos de COMUNES " + lcDbComunes + " en " + lcCfgCliSrvXml;
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
            }
            else
            {
                // Quito el nodo con los datos de la conexión del grupo.
                try
                {

                    VFPDataNode.RemoveChild(loNodoConex);

                    xmlCfgCliSrv.Save(lcCfgCliSrvXml);
                }
                catch (Exception loEx)
                {
                    _Error_Message = "Ha habido un problema al borrar la base de datos de COMUNES del grupo " + tcGrupo + " del fichero cfgclisrv.xml en euroserv. Mensaje de error: " + loEx.Message;
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    //  No por esto vamos a devolver false, pues si ha llegado hasta aquí, el grupo ya ha sido borrado.
                }
            }


            // QUITAR EL GRUPO DE CFGCLISRV.DBF EN EUROSERV
            try
            {
                DataTable dtDbf = new DataTable();
                OdbcConnection loConn = new OdbcConnection();
                OdbcCommand loCmd = loConn.CreateCommand();

                // Comprobar si existe cfgclisrv.dbf
                string lcCfgCliSrvDbf = Path.Combine(lcEuroserv, "cfgclisrv.dbf");
                if (!File.Exists(lcCfgCliSrvDbf))
                {
                    _Error_Message = "No se ha podido actualizar el fichero " + lcCfgCliSrvDbf + ", no existe el fichero en dicha ruta.";
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return true;
                    //  No por esto vamos a devolver false, pues si ha llegado hasta aquí, el grupo ya ha sido borrado
                }

                loConn.ConnectionString = @"Driver={Microsoft Visual FoxPro Driver};SourceType=DBF;SourceDB=" + lcEuroserv + ";";

                if (!lcEuroserv.Trim().EndsWith("\\"))
                    lcEuroserv = lcEuroserv.Trim() + "\\";

                loConn.Open();

                loCmd.CommandText = @"SELECT * FROM " + lcEuroserv + "CFGCLISRV.DBF WHERE !deleted() and comunes = '" + lcDbComunes.Trim().ToUpper() + "' ";
                dtDbf.Load(loCmd.ExecuteReader());

                if (dtDbf.Rows.Count > 0)
                {
                    loCmd.CommandText = "DELETE FROM cfgclisrv WHERE !deleted() and comunes = '" + lcDbComunes.Trim().ToUpper() + "'";
                    loCmd.ExecuteNonQuery();
                }

                loConn.Close();

                dtDbf.Dispose();
            }
            catch (Exception loEx)
            {
                if (_Log)
                    Guardar_Mensaje("Ha habido un problema al eliminar el registro del grupo " + lcDbComunes + " del fichero cfgclisrv.dbf en euroserv. Mensaje de error: " + loEx.Message);
                //  No por esto vamos a devolver false, pues si ha llegado hasta aquí, el grupo ya ha sido borrado.
            }
          


            return true;

        }

        private static void CrearGrupo_AsignarPropiedades(Dictionary<string, object> loDicParametros)
        { 
            // DAMOS VALOR A LAS PROPIEDADES SEGUN LOS PARAMETROS RECIBIDOS
            // Si no han declarado el usuario propietario de las nuevas bases de datos que se creen lo ponemos nosotros
            if (string.IsNullOrWhiteSpace(_UserPropBdGrNuevo))
                GrupoempTools._UserPropBdGrNuevo = "Sage50";

            string tcEjercicio = Convert.ToString(loDicParametros["tcejercicio"]);
            bool tlEjerPartido = Convert.ToBoolean(loDicParametros["tlejerpartido"]);

            DateTime? tdEjerPartiFIni=null, tdEjerPartiFFin=null;
            if (loDicParametros["tdejerpartifini"] != null)
                tdEjerPartiFIni = Convert.ToDateTime(loDicParametros["tdejerpartifini"]);
            if (loDicParametros["tdejerpartiffin"] != null)
                tdEjerPartiFFin = Convert.ToDateTime(loDicParametros["tdejerpartiffin"]);

            bool tlConservarClientes = Convert.ToBoolean(loDicParametros["tlconservarclientes"]);
            bool tlConservarUsuarios = Convert.ToBoolean(loDicParametros["tlconservarusuarios"]);
            string tcNombreEmpresa = Convert.ToString(loDicParametros["tcnombreempresa"]);
            string tcCifEmpresa = Convert.ToString(loDicParametros["tccifempresa"]);
            

            // Estas propiedades ya las captamos de la llamada
            GrupoempTools._EjerNuevo = tcEjercicio;
            GrupoempTools._CfgEjerPartiGrNuevo = tlEjerPartido;
            if (tlEjerPartido)
            {
                // Fechas periodo para ejercicio partido
                GrupoempTools._FechaIniEjerNuevo = tdEjerPartiFIni;
                GrupoempTools._FechaFinEjerNuevo = tdEjerPartiFFin;
            }
            else
            {
                // Fechas periodo para ejercicio natural
                GrupoempTools._FechaIniEjerNuevo = Convert.ToDateTime("01/01/" + tcEjercicio);
                GrupoempTools._FechaFinEjerNuevo = Convert.ToDateTime("31/12/" + tcEjercicio); 
            }
            GrupoempTools._ConservarClientes = tlConservarClientes;
            GrupoempTools._ConservarUsuarios = tlConservarUsuarios;
            GrupoempTools._NombreEmpresa = !string.IsNullOrWhiteSpace(tcNombreEmpresa) ? tcNombreEmpresa : "NOMBRE EMPRESA";
            GrupoempTools._CifEmpresa = tcCifEmpresa;
            
            // El ejercicio que se crea en el nuevo grupo siempre quedará marcado como predeterminado en COMUNES!EJERCICI
            GrupoempTools._EjerNuevoMarcarPredet = true;

            // Asignar propiedad de creación con longitudes estandar
            GrupoempTools._LongitudesEstandar = Convert.ToBoolean(loDicParametros["tlLongitudesEstandar"]);
        }

        


        private static bool CrearEjercicio_Comprobar_Parametros(Dictionary<string, object> loDicParametros)
        {

            // Si no hay conexión a una instancia de servidor SQL no hay nada que hacer.
            _Error_Message = "";
            if (string.IsNullOrWhiteSpace(DB.Conexion) || string.IsNullOrWhiteSpace(DB.DbComunes))
            {
                _Error_Message = "No se ha detectado conexión al servidor SQL, no se creará el grupo.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }


            // Código de grupo origen para la creación del nuevo ejercicio.
            string tcGrupoOrigen = Convert.ToString(loDicParametros["tcgrupoorigen"]);
            if (string.IsNullOrWhiteSpace(tcGrupoOrigen))
            {
                _Error_Message = "Error en los parámetros de entrada. No se ha especificado el parámetro 'Código de grupo origen' (tcGrupoOrigen)";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }
            else
            {
                // Código de grupo origen si se pasa ha de tener 4 dígitos.
                if (tcGrupoOrigen.Trim().Length != 4)
                {
                    _Error_Message = "Error en los parámetros de entrada. El parámetro 'Código de grupo origen' (tcGrupoOrigen) debe tener 4 dígitos.";
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }

            }


            // Código de ejercicio origen a utilizar en la creación del nuevo ejercicio.
            string tcEjerOrigen = Convert.ToString(loDicParametros["tcejerorigen"]);
            if (string.IsNullOrWhiteSpace(tcEjerOrigen))
            {
                _Error_Message = "Error en los parámetros de entrada. No se ha especificado el parámetro 'Ejercicio origen' (tcEjerOrigen).";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }
            else
            {
                // Código de ejercicio origen ha de tener 4 dígitos.
                if (tcEjerOrigen.Trim().Length != 4)
                {
                    _Error_Message = "Error en los parámetros de entrada. El parámetro 'Código de ejercicio origen' (tcEjerOrigen) debe tener 4 dígitos.";
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }
                else
                {
                    int lnEjerOrigen = Convert.ToInt32(tcEjerOrigen);
                    if (lnEjerOrigen == 0 || lnEjerOrigen < 1980)  // 1980 por poner algo
                    {
                        _Error_Message = "Error en los parámetros de entrada. El parámetro 'Código de ejercicio origen' (tcEjerOrigen) no tiene el formato correcto, debe tener 4 dígitos: "+tcEjerOrigen;
                        if (_Log)
                            Guardar_Mensaje(_Error_Message);
                        return false;                    
                    }
                }
            }




            // Código de ejercicio a crear en el grupo ha de estar informado.
            string tcEjerNuevo = Convert.ToString(loDicParametros["tcejernuevo"]);
            if (string.IsNullOrWhiteSpace(tcEjerNuevo))
            {
                _Error_Message = "Error en los parámetros de entrada. No se ha especificado el parámetro 'Ejercicio a crear' (tcEjerNuevo).";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }
            else
            {
                // Código de ejercicio a crear ha de tener 4 dígitos.
                if (tcEjerNuevo.Trim().Length != 4)
                {
                    _Error_Message = "Error en los parámetros de entrada. El parámetro 'Código de ejercicio a creear' (tcEjerNuevo) debe tener 4 dígitos.";
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }
                else
                {
                    int lnEjerNuevo = Convert.ToInt32(tcEjerNuevo);
                    if (lnEjerNuevo == 0 || lnEjerNuevo < 1980)  // 1980 por poner algo
                    {
                        _Error_Message = "Error en los parámetros de entrada. El parámetro 'Código de ejercicio a crear' (tcEjerNuevo) no tiene el formato correcto, debe tener 4 dígitos: " + tcEjerNuevo;
                        if (_Log)
                            Guardar_Mensaje(_Error_Message);
                        return false;
                    }
                }
            }


            // Código de ejercicio a crear ha de ser diferente del codigo de ejercicio origen
            if (!string.IsNullOrWhiteSpace(tcEjerOrigen) && !string.IsNullOrWhiteSpace(tcEjerNuevo) && tcEjerNuevo == tcEjerOrigen)
            {
                _Error_Message = "Error en los parámetros de entrada. Ejercicio origen (tcEjerOrigen) y ejercicio a crear (tcEjerNuevo) no pueden ser iguales.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }

            // Comprobar que las fechas esten correctamente introducidas
            DateTime tdFIniEjerNuevo = Convert.ToDateTime(loDicParametros["tdfiniejernuevo"]);
            DateTime tdFFinEjerNuevo = Convert.ToDateTime(loDicParametros["tdffinejernuevo"]);

            if (tdFIniEjerNuevo == null || tdFFinEjerNuevo == null)
            {
                _Error_Message = "Error en los parámetros de entrada. No se ha declarado alguna de las fechas del ejercicio.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;            
            }

            if (tdFIniEjerNuevo.Year < 1980 || tdFFinEjerNuevo.Year < 1980)
            {
                _Error_Message = "Error en los parámetros de entrada. La fecha de inicio de ejercicio o la fecha fin de ejercicio no parecen ser correctas.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }

            if (tdFIniEjerNuevo >= tdFFinEjerNuevo)
            {
                _Error_Message = "Error en los parámetros de entrada. La fecha final del nuevo ejercicio no puede ser inferior a la fecha inicial.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }
            return true;
        }



        private static bool CrearGrupo_Comprobar_Parametros(Dictionary<string,object> loDicParametros)
        {
            // Si no hay conexión a una instancia de servidor SQL no hay nada que hacer.
            _Error_Message = "";
            if (string.IsNullOrWhiteSpace(DB.Conexion) || string.IsNullOrWhiteSpace(DB.DbComunes))
            {
                _Error_Message = "No se ha detectado conexión al servidor SQL, no se creará el grupo.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }

            // Verificar que tenemos la dirección de EUROSERV pues al acabar la creación hay que actualizar CFGCLISRV.XML en EUROSERV
            if (string.IsNullOrWhiteSpace(GrupoempTools._Euroserv))
            {
                _Error_Message = "No se ha dado valor a la propiedad _Euroserv de la clase GrupoempTools y es necesaria para la creación del grupo, no se creará el grupo.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }



            // CONTROL DE RECEPCION DE PARAMETROS MINIMOS

            // Código de grupo a crear ha de estar informado.
            string tcGrupo = Convert.ToString(loDicParametros["tcgrupo"]);
            if (string.IsNullOrWhiteSpace(tcGrupo))
            {
                _Error_Message = "Error en los parámetros de entrada. No se ha especificado el parámetro 'Código de grupo a crear'.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }



            // Si se pasa código de grupo origen hay que validar cosas.
            string tcGrOrigen = Convert.ToString(loDicParametros["tcgrorigen"]);
            if (!string.IsNullOrWhiteSpace(tcGrOrigen))
            {
                // Código de grupo origen si se pasa ha de tener 4 dígitos.
                if (tcGrOrigen.Trim().Length != 4)
                {
                    _Error_Message = "Error en los parámetros de entrada. El parámetro tcGrOrigen (grupo origen es opcional pero caso de pasarse debe tener 4 dígitos";
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }
                else if (tcGrupo == tcGrOrigen)
                {
                    // Código de grupo origen ha de ser diferente código de grupo si se pasa ha de tener 4 dígitos.
                    _Error_Message = "Error en los parámetros de entrada. El parámetro tcGrOrigen (grupo origen) es opcional pero caso de pasarse debe ser diferente al código de grupo a crear.";
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }
            }

            // Código de ejercicio a crear en el nuevo grupo ha de estar informado.
            string tcEjercicio = Convert.ToString(loDicParametros["tcejercicio"]);
            if (string.IsNullOrWhiteSpace(tcEjercicio))
            {
                _Error_Message = "Error en los parámetros de entrada. No se ha especificado el parámetro 'Ejercicio' en el nuevo grupo.";
                if (_Log)
                    Guardar_Mensaje(_Error_Message);
                return false;
            }
            else
            {
                // Código de ejercicio a crear ha de tener 4 dígitos.
                if (tcEjercicio.Trim().Length != 4)
                {
                    _Error_Message = "Error en los parámetros de entrada. El parámetro 'Ejercicio' debe tener 4 dígitos: " + tcEjercicio;
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }
                else
                {
                    int lnEjercicio = Convert.ToInt32(tcEjercicio);
                    if (lnEjercicio == 0 || lnEjercicio < 1980)  // 1980 por poner algo
                    {
                        _Error_Message = "Error en los parámetros de entrada. El parámetro 'Ejercicio' no tiene el formato correcto, debe tener 4 dígitos: " + tcEjercicio;
                        if (_Log)
                            Guardar_Mensaje(_Error_Message);
                        return false;
                    }
                }
            }


            // Caso de especificar trabajar con ejercicio partido se tienen que especificar las fechas inicio y fin de ejercicio.
            bool tlEjerPartido = Convert.ToBoolean(loDicParametros["tlejerpartido"]);
            if (tlEjerPartido)
            {
                DateTime? tdEjerPartiFIni = null, tdEjerPartiFFin = null;
                if (loDicParametros["tdejerpartifini"] != null)
                    tdEjerPartiFIni = Convert.ToDateTime(loDicParametros["tdejerpartifini"]);
                if (loDicParametros["tdejerpartiffin"] != null)
                    tdEjerPartiFFin = Convert.ToDateTime(loDicParametros["tdejerpartiffin"]);

                if (tdEjerPartiFIni == null || tdEjerPartiFFin == null)
                {
                    _Error_Message = "Error en los parámetros de entrada. Se ha recibido el parámetro para la configuración de modo de trabajo " +
                                     "con ejercicio partido en el nuevo grupo, pero no se han especificado los parámetros de fecha inicial y final del ejercicio.";
                    if (_Log)
                        Guardar_Mensaje(_Error_Message);
                    return false;
                }
            }

            return true;
        }


        private static bool CrearEjercicio_BackupBd()
        {
            bool llOk = false;

            if (_Log)
                Guardar_Mensaje("INICIO PROCESO DE COPIA DE BASE DE DATOS DE EJERCICIO"+Environment.NewLine);


            // COPIA BASE DE DATOS DE EJERCICIO DEL grupo origen
            llOk = GrupoempTools.Backup_Bd(GrupoempTools._DbEjerGrOrigen, "EJERCICIO");
            if (!llOk)
                return false;

            if (_Log)
            {
                Guardar_Mensaje(Environment.NewLine);
                Guardar_Mensaje("PROCESO DE COPIA DE BASE DE DATOS DE EJERCICIO FINALIZADO CORRECTAMENTE." + Environment.NewLine);
            }

            return true;
        }


        private static bool CrearEjercicio_RestoreBd()
        {
            bool llOk = false;

            if (_Log)
                Guardar_Mensaje("INICIO PROCESO DE RESTAURACIÓN DE BASE DE DATOS DE EJERCICIO." + Environment.NewLine);

            // RESTAURACION BD EJERCICIO CON NUEVO NOMBRE
            llOk = GrupoempTools.Restore_Bd(GrupoempTools._DbEjerGrOrigen, GrupoempTools._DbEjerGrNuevo, "EJERCICIO");
            if (!llOk)
                return false;

            if (_Log)
            {
                Guardar_Mensaje(Environment.NewLine);
                Guardar_Mensaje("PROCESO DE RESTAURACIÓN DE BASE DE DATOS FINALIZADO CORRECTAMENTE." + Environment.NewLine);
            }

            return true;
        }


        private static bool CrearEjercicio_AjustarDatosBd()
        {
            bool llOk = false;
            string lcSql = "";
            string lcAnyoAnterior = "";

            // AJUSTES EN LA BASE DE DATOS EJERCICIO RECIEN CREADA DEL GRUPO
            llOk = GrupoempTools.AjustarDatos_Bd(_DbEjerGrNuevo, "GESTION");
            if (!llOk)
                return false;

            // Ahora hay obtener el año anterior al que estamos creando para actualizar el campo ANTERIOR del registro que acabamos de añadir
            DataTable ldtAuxiliar = new DataTable();
            DB.SQLExec("select top 1 * from " + DB.SQLDatabaseReal(_DbComunesGrOrigen, "EJERCICI") + " where [any]<" + _EjerNuevo + " order by [any] desc", ref ldtAuxiliar);
            if (ldtAuxiliar.Rows.Count > 1)
                lcAnyoAnterior = Convert.ToString(ldtAuxiliar.Rows[0]["any"]);


            // Agrego el registro del ejercicio recien creado a COMUNES!EJERCICI marcando PREDET o  no según hayan escogido
            lcSql = "INSERT INTO " + DB.SQLDatabaseReal(_DbComunesGrOrigen, "EJERCICI") + " ([ANY], RUTA, RUTASER, CONEXION, PERIODOINI, PERIODOFIN, PREDET, ANTERIOR) VALUES (" +
                    "'" + _EjerNuevo + "', " +
                    "'" + _DbEjerGrNuevo + "', " +
                    "'" + _DbEjerGrNuevo + "', " +
                    "'" + _DbEjerGrNuevo + "', " +
                    DB.SQLString(_FechaIniEjerNuevo) + ", " +
                    DB.SQLString(_FechaFinEjerNuevo) + ", " +
                    (GrupoempTools._EjerNuevoMarcarPredet ? DB.SQLTrue() : DB.SQLFalse()) + " , " +
                    "'" + lcAnyoAnterior + "')";
            DB.SQLExec(lcSql);

            // Caso de que hayan escogido marcar como predeterminado el ejercicio nuevo que se ha creado, hay que quitar la marca de PREDET al ejercicio que pudiera tenerla
            if (GrupoempTools._EjerNuevoMarcarPredet)
            {
                lcSql = "UPDATE " + DB.SQLDatabaseReal(_DbComunesGrOrigen, "EJERCICI") + " SET PREDET=" + DB.SQLFalse() +
                        "WHERE [ANY] != '" + _EjerNuevo + "'";
                DB.SQLExec(lcSql);
            }

            // Añadir las cuentas contables básicas a la tabla CUENTAS del nuevo grupo
            AjustarTablaCuentas_Paso2();

            return true;
        }

        private static bool CrearGrupo_Longitudes()
        {
            // Copiar los diccionarios de la DB
            CopiaDiccionarios(true);

            // Cargar las bases de datos del comunes del nuevo grupo
            DB._Cargar_Alias_DB(_DbComunesGrNuevo);

            // Añadir los módulos al diccionario
            CargarBDs_modulos();

            bool llOk = CrearGrupo_Longitudes_Grupo();

            // Restaurar los diccionarios de la DB
            CopiaDiccionarios(false);

            return llOk;
        }


        private static bool CrearGrupo_Longitudes_Grupo()
        {
            bool llOk = false;
            string lcClave = String.Empty;
            int lnPos = 0;
            int lnLong = 0;
            string lcRelleno = String.Empty;

            // Inicio proceso
            if (_Log)
                Guardar_Mensaje("INICIO PROCESO AJUSTE LONGITUDES ESTÁNDAR EN EL NUEVO GRUPO." + Environment.NewLine);


            Dictionary<string, int> dicCamposAmplia = new Dictionary<string, int>();

            // Obtener los campos clave que tienen una longitud diferente de estándar
            llOk = DB._ObtenerCamposAmpliados(ref dicCamposAmplia);
            if (!llOk)
                return false;

            // Si no hay campos ampliados, no hacer nada
            if (dicCamposAmplia.Count() == 0)
            {
                if (_Log)
                    Guardar_Mensaje("NO SE HAN DETECTADO CAMPOS AMPLIADOS." + Environment.NewLine);
                return true;
            }

            llOk = true;

            // Realizar adaptaciones antes de cambiar longitud
            CrearGrupo_Longitudes_Antes(dicCamposAmplia);

            // Recorrer el diccionario de campos ampliados y cambiar la longitud
            foreach (KeyValuePair<string, int> campo in dicCamposAmplia)
            {
                lcClave = campo.Key;
                lnLong = campo.Value;
                lnPos = 0;
                if (lcClave.Trim().ToUpper() == "CUENTAS")
                    lnPos = 4;

                if (_Log)
                    Guardar_Mensaje("CAMBIAR LA LONGITUD CLAVE " + lcClave + " A " + lnLong + " DÍGITOS.");

                // Cambiar longitud campo de una clave
                llOk = DB._CambiarLongitudCampo(lcClave, lnLong, lcRelleno, lnPos, 1);
                if (!llOk)
                {
                    if (_Log)
                        Guardar_Mensaje("Error al cambiar longitud de la clave " + lcClave + ": " + DB.Error_Message + Environment.NewLine);
                    break;
                }
                else
                {
                    if (_Log)
                        Guardar_Mensaje("CAMBIADA CORRECTAMENTE LA LONGITUD CLAVE " + lcClave + " A " + lnLong + " DÍGITOS." + Environment.NewLine);
                }
            }

            if (_Log)
                Guardar_Mensaje("FIN PROCESO AJUSTE AJUSTE LONGITUDES ESTÁNDAR EN EL NUEVO GRUPO." + Environment.NewLine);

            return llOk;
        }


        public static void CargarBDs_modulos()
        {
            DataTable loBds = new DataTable();
            String lcNombre = string.Empty;
            String lcConex = string.Empty;

            DB.SQLExec("SELECT nombre, nombre2, nom_conex, activo, visible, instalado " +
                       " FROM " + DB.SQLDatabase("COMUNES", "MODULOS") +
                       " WHERE nombre != 'EWTOOLS' " +
                       " Order by nombre ", ref loBds);

            foreach (DataRow loRow in loBds.Rows)
            {
                lcNombre = loRow["nombre"].ToString().ToUpper().Trim();
                lcConex  = loRow["nom_conex"].ToString().ToLower().Trim();

                if (!string.IsNullOrEmpty(lcConex))
                {
                    lcConex = "[" + lcConex + "].dbo.";
                    DB._oAliasDB.Add(lcNombre, lcConex);
                }
            }

        }


        private static void CopiaDiccionarios(Boolean tlCopia)
        {
            if (tlCopia)
            {
                _oAliasDBCopia = new Dictionary<string, string>(DB._oAliasDB);
                _oAliasDBEjerCopia = new Dictionary<string, string>(DB._oAliasDBEjer);
                _dicCacheSchemaCopia = new Dictionary<string, DB._TableInformationSchema>(DB._dicCacheSchema);
            }
            else
            {
                DB._oAliasDB.Clear();
                DB._oAliasDBEjer.Clear();
                DB._dicCacheSchema.Clear();

                DB._oAliasDB = new Dictionary<string, string>(_oAliasDBCopia);
                DB._oAliasDBEjer = new Dictionary<string, string>(_oAliasDBEjerCopia);
                DB._dicCacheSchema = new Dictionary<string, DB._TableInformationSchema>(_dicCacheSchemaCopia);
            }

        }

        private static void CrearGrupo_Longitudes_Antes(Dictionary<string, int> _dicCamposAmplia)
        {
            if (_dicCamposAmplia.ContainsKey("CUENTAS"))
                DB.SQLExec("TRUNCATE TABLE  " + DB.SQLDatabaseReal(_DbEjerGrNuevo, "CUENTAS"));
        }


        private static void ObtenerAddonsBase()
        {
            // Mirar si existe el campo BASE en la tabla MODULOS
            if (!DB.SQLExisteCampo("COMUNES", "MODULOS", "BASE")) 
                return;

            DataTable loBds = new DataTable();

            DB.SQLExec("SELECT nombre " +
                       " FROM " + DB.SQLDatabaseReal(GrupoempTools._DbComunesGrOrigen, "modulos") +
                       " WHERE nombre != 'EWTOOLS' and (base = " + DB.SQLTrue() + " or (visible = " + DB.SQLTrue() + " and instalado = "+DB.SQLTrue()+")) " +  //Bug 155134
                       " Order by nombre ", ref loBds);

            if (loBds == null || loBds.Rows.Count == 0)
                return;

            // Pasar los addons a la lista de addons
            _AddonsInstal = loBds.Rows.OfType<DataRow>()
                            .Select(dr => dr.Field<string>("nombre").Trim()).ToList();

            // En el caso, que exista algún error, ponemos los addons directamente
            if (_AddonsInstal.Count == 0)
                _AddonsInstal = new List<string>() { "TPV", "LOTES", "AMORTIZA", "MAYORIST", "INFORAUT" };

        }


        private static bool AddonGrupoOrigen(string tcAddon)
        {
            // Si en el diccionario ya existe el addon, devolvemos su valor
            if (_oAddonsOrigen.ContainsKey(tcAddon))
                return _oAddonsOrigen[tcAddon];

            switch (tcAddon.ToLower())
            {
                case "conceptosfacturables":
                    DataTable ldtAuxiliar = new DataTable();
                    DB.SQLExec("select valor from " + DB.SQLDatabaseReal(_DbComunesGrOrigen, "VARIABLE") + " " +
                               "where variable = " + DB.SQLString("wl_ConceptosFacturables") + "", ref ldtAuxiliar);

                    bool llActivo = ldtAuxiliar != null && ldtAuxiliar.Rows.Count == 1 && Convert.ToString(ldtAuxiliar.Rows[0]["valor"]).Trim().ToUpper() == ".T.";
                    _oAddonsOrigen.Add(tcAddon, llActivo);
                    return llActivo;
            }

            return false;

        }

        private static void ActivarOpcflag(string tcNombreBaseDatos, int tnOpcflag, bool tlValor)
        {
            DataTable ldtAuxiliar = new DataTable();
            String lcSql = string.Empty;

            // Buscamos el opcemp en el grupo destino, si no existe el registro lo creamos, sino lo updatamos, siempre con el valor del opcflag hallado en el grupo origen.
            DB.SQLExec("select empresa from " + DB.SQLDatabaseReal(tcNombreBaseDatos, "OPCEMP") + " " +
                        "where empresa=" + DB.SQLString(_EmpresaGrNuevo) + " and tipo_opc="+tnOpcflag+"", ref ldtAuxiliar);
            if (ldtAuxiliar.Rows.Count == 0)
            {
                DB.SQLExec("INSERT INTO " + DB.SQLDatabaseReal(tcNombreBaseDatos, "OPCEMP") + " (EMPRESA,TIPO_OPC,ESTADO) " +
                            "VALUES (" + DB.SQLString(_EmpresaGrNuevo) + ", "+ tnOpcflag+", " + (tlValor ? DB.SQLTrue() : DB.SQLFalse()) + ")");
            }
            else
            {

                lcSql = "UPDATE " + DB.SQLDatabaseReal(tcNombreBaseDatos, "OPCEMP") + " " +
                        "SET ESTADO = " + (tlValor ? DB.SQLTrue() : DB.SQLFalse()) + " " +
                        "WHERE EMPRESA = " + DB.SQLString(_EmpresaGrNuevo) + " AND TIPO_OPC=" + tnOpcflag + "";
                DB.SQLExec(lcSql);
            }

        }

        private static string ObtenerTarifaDefecto(string tcTarifaDef)
        {
            DataTable ldTarifas = new DataTable();
            DB.SQLExec("select * from " + DB.SQLDatabase("GESTION", "TARIFAS") + " order by codigo", ref ldTarifas);
            if (ldTarifas != null && ldTarifas.Rows.Count > 0)
            {
                int lnTarifas = ldTarifas.Select("codigo = '" + tcTarifaDef + "'").Length;
                if (lnTarifas == 0)
                    tcTarifaDef = Convert.ToString(ldTarifas.Rows[0]["codigo"]);
            }

            return tcTarifaDef;
        }

        #endregion METODOS PRIVADOS



        // CONSULTAR LAS CONSTRAINTS DE VALORES POR DEFECTOS DE TODAS LAS TABLAS
        // use [2017VO];
        // SELECT 
        //    TableName = t.Name,
        //    ColumnName = c.Name,
        //    dc.Name,
        //    dc.definition
        // FROM sys.tables t
        // INNER JOIN sys.default_constraints dc ON t.object_id = dc.parent_object_id
        // INNER JOIN sys.columns c ON dc.parent_object_id = c.object_id AND c.column_id = dc.parent_column_id
        // ORDER BY t.Name



        // AVERIGUAR LOS INDICES DE LAS TABLAS DE UNA BASE DE DATOS, INDICE PRIMARIO Y RESTO DE INDICES (SIN LOS CAMPOS QUE LOS COMPONEN)
        // 
        //
        // SELECT schema_name(t.schema_id), t.name as nombre_tabla,  i.name as nombre_indice, i.type_desc as tipo_indice, i.is_primary_key as indice_primario
        // FROM [2007NA].sys.indexes i
        // INNER JOIN [2007NA].sys.tables t ON t.object_id= i.object_id
        // WHERE i.type>0 and t.is_ms_shipped=0  order by t.name




        // OBTENER TODOS LOS INDICES (PRIMARIO Y RESTO DE INDICES DE TODAS LAS TABLAS DE UNA BASE DE DATOS), TENEMOS LA COLUMNA IS_PRIMARY_KEY QUE INDICE SI EL INDICES ES PRIMARIO
        //
        //
        // USE [2016YR];
        //GO
        //SELECT 
        //     TableName = t.name,
        //     IndexName = ind.name,
        //     IndexId = ind.index_id,
        //     ColumnId = ic.index_column_id,
        //     ColumnName = col.name,
        //     ind.*,
        //     ic.*,
        //     col.* 
        //FROM 
        //     sys.indexes ind 
        //INNER JOIN 
        //     sys.index_columns ic ON  ind.object_id = ic.object_id and ind.index_id = ic.index_id 
        //INNER JOIN 
        //     sys.columns col ON ic.object_id = col.object_id and ic.column_id = col.column_id 
        //INNER JOIN 
        //     sys.tables t ON ind.object_id = t.object_id 
        //ORDER BY 
        //     t.name, ind.is_primary_key desc, ind.name, ind.index_id, ic.index_column_id;


        // CONSULTAR LAS CONSTRAINTS DE VALORES POR DEFECTO
        //
        //
        // select * from [nombrebd].sys.default_constraints;


        // CONSULTAR LAS CONSTRAINTS DE CLAVE PRIMARIA
        //
        //
        // select * from [nombrebd].sys.key_constraints;


        // CONSULTAR LAS CONSTRAINTS DE VALORES POR DEFECTOS DE TODAS LAS TABLAS DE UNA BASE DE DATOS
        //
        //
        // use [2017VO];
        // SELECT 
        //    TableName = t.Name,
        //    ColumnName = c.Name,
        //    dc.Name,
        //    dc.definition
        // FROM sys.tables t
        // INNER JOIN sys.default_constraints dc ON t.object_id = dc.parent_object_id
        // INNER JOIN sys.columns c ON dc.parent_object_id = c.object_id AND c.column_id = dc.parent_column_id
        // ORDER BY t.Name




        // GENERAR LA CLAVE PRIMARIA, AUTOMATICAMENTE APARECERA TAMBIEN UN INDICE COMO ESTE
        //
        //
        // ALTER TABLE [2007NA].[dbo].[C_ALBVEN] ADD CONSTRAINT [pk__2006na__c_albven__empnumlet]
        // PRIMARY KEY CLUSTERED ( [EMPRESA] ASC, [NUMERO] ASC, [LETRA] ASC) 
        // WITH ( STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) 
        // ON [eurowind]



        // GENERAR EL RESTO DE INDICES QUE NO SON CLAVE PRIMARIA
        //
        //
        // CREATE NONCLUSTERED INDEX [empcli] ON [2007NA].[DBO].[C_ALBVEN] 
        // ([EMPRESA] ASC,  [CLIENTE] ASC,  [NUMERO] ASC,   [LETRA] ASC) 
        // WITH (STATISTICS_NORECOMPUTE  = OFF, SORT_IN_TEMPDB = OFF, DROP_EXISTING = OFF, IGNORE_DUP_KEY = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [eurowini]



        // GENERAR CONSTRAINT DE VALOR POR DEFECTO DE CAMPO
        // ALTER TABLE [2017VO].dbo].[c_comuni] ADD  CONSTRAINT [df__2017vo__c_comuni__empresa]  DEFAULT ("") FOR [EMPRESA]

        //
        // OJO QUE SI SE CREAN LAS TABLAS MEDIANTE SELECT * INTO [newbd].dboi.tabla from [actbd].dbo.tabla la crea en el gurpo de archivo PRIMARY y no en [eurowind], ver que trascendencia podria tener.



    }
}