OfflineUploader.cs

using sage.ew.db;
using sage.ew.ewbase;
using sage.ew.ewbase.Clases;
using sage.ew.global;
using sage.ew.global.DependencyInjection;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Text;
using sage.addons.offline.Negocio.Listados;
using sage.addons.offline.DataAccess.Repository;
using sage.addons.offline.DataAccess.UnitOfWork;
using sage.addons.offline.DataAccess.Dto;
using System.Data.SqlClient;
using sage.ew.functions;

namespace sage.addons.offline.Negocio.Clases
{
    internal class OfflineUploader : OfflineUpAndDown
    {
        #region Métodos para el Asistente de Configuración

        internal static bool Upload_Control_Files(int nTipoCom, bool isCentral, int tnIdConf)
        {
            _Porcen_Progreso_Async -= OfflineUploader__Porcen_Progreso_Async;
            _Mostrar_Progreso_Async -= OfflineUploader__Mostrar_Progreso_Async;

            _Mostrar_Progreso_Async += OfflineUploader__Mostrar_Progreso_Async;
            _Porcen_Progreso_Async += OfflineUploader__Porcen_Progreso_Async;

            OfflineDatosComunicaciones datos = new OfflineDatosComunicaciones();

            if (!Directory.Exists(TempFolderName))
            {
                Directory.CreateDirectory(TempFolderName);
            }

            ComprobacionesPrevias(tnIdConf);

            _cIdLog = _offlineConfig.GenerarRandomId();
            
            datos._Log_ComoffID = _cIdLog;
            datos._IdConf = tnIdConf;
            datos._MultConf = DB.SQLValor("MULTCONF", "IDCONF", tnIdConf.ToString(), "CODIGO", "OFFLINE").ToString();
            datos._Usuario = sage.ew.global.EW_GLOBAL._GetVariable("wc_usuario").ToString();
            datos._BdOffline = clsOfflineUtils.ObtenerNombreBdReal("OFFLINE");
            datos._Sucursal = string.Empty;
            datos._PathFolderInicial = TempFolderName;
            datos._IniServidor = DB._GetVariable("wc_iniservidor").ToString().ToLower();
            datos._EnvioArticulos = false;
            datos._FechaInicial = Convert.ToDateTime(EW_GLOBAL._GetVariable("wd_periodoini"));
            datos._FechaFinal = Convert.ToDateTime(EW_GLOBAL._GetVariable("wd_periodofin"));
            datos._TipoCom = nTipoCom;
            datos._IsCentral = isCentral;

            //•    Sucursales->Configuración de todas las sucursales, datos en tablas SUCURSALES, SUCURALM, SUCURCONF y SUCURLET.Ver punto 17.1.1.
            DataTable tablaDatos = new DataTable();
            string lcSql = "SELECT * FROM " + DB.SQLDatabase("OFFLINE", "SUCURSALES");
            DB.SQLExec(lcSql, ref tablaDatos);
            ConvertIndividualFile(tablaDatos, TempFolderName, "SUCURSALES", FormatoExportacion.XML);

            tablaDatos = new DataTable();
            lcSql = "SELECT * FROM " + DB.SQLDatabase("OFFLINE", "SUCURALM");
            DB.SQLExec(lcSql, ref tablaDatos);
            ConvertIndividualFile(tablaDatos, TempFolderName, "SUCURALM", FormatoExportacion.XML);

            tablaDatos = new DataTable();
            lcSql = "SELECT * FROM " + DB.SQLDatabase("OFFLINE", "SUCURLET");
            DB.SQLExec(lcSql, ref tablaDatos);
            ConvertIndividualFile(tablaDatos, TempFolderName, "SUCURLET", FormatoExportacion.XML);

            tablaDatos = new DataTable();
            lcSql = "SELECT * FROM " + DB.SQLDatabase("OFFLINE", "SUCURCAJA");
            DB.SQLExec(lcSql, ref tablaDatos);
            ConvertIndividualFile(tablaDatos, TempFolderName, "SUCURCAJA", FormatoExportacion.XML);

            tablaDatos = new DataTable();
            lcSql = "SELECT * FROM " + DB.SQLDatabase("OFFLINE", "SUCURCONF");
            DB.SQLExec(lcSql, ref tablaDatos);
            ConvertIndividualFile(tablaDatos, TempFolderName, "SUCURCONF", FormatoExportacion.XML);

            tablaDatos = new DataTable();
            lcSql = "SELECT * FROM " + DB.SQLDatabase("GESTION", "ALMACEN");
            DB.SQLExec(lcSql, ref tablaDatos);
            ConvertIndividualFile(tablaDatos, TempFolderName, "ALMACEN", FormatoExportacion.XML);

            tablaDatos = new DataTable();
            lcSql = "SELECT * FROM " + DB.SQLDatabase("COMUNES", "LETRAS");
            DB.SQLExec(lcSql, ref tablaDatos);
            ConvertIndividualFile(tablaDatos, TempFolderName, "LETRAS", FormatoExportacion.XML);

            tablaDatos = new DataTable();
            lcSql = "SELECT * FROM " + DB.SQLDatabase("OFFLINE", "VARIABLES") + " WHERE VARIABLE = 'ULTIMOLOG' ";
            DB.SQLExec(lcSql, ref tablaDatos);
            ConvertIndividualFile(tablaDatos, TempFolderName, "VARIABLES", FormatoExportacion.XML);

            tablaDatos = new DataTable();
            lcSql = "SELECT * FROM " + DB.SQLDatabase("OFFLINE", "MULTCONF");
            DB.SQLExec(lcSql, ref tablaDatos);
            ConvertIndividualFile(tablaDatos, TempFolderName, "MULTCONF", FormatoExportacion.XML);

            tablaDatos = new DataTable();
            lcSql = "SELECT * FROM " + DB.SQLDatabase("OFFLINE", "TABNETCONF");
            DB.SQLExec(lcSql, ref tablaDatos);
            ConvertIndividualFile(tablaDatos, TempFolderName, "TABNETCONF", FormatoExportacion.XML);

            tablaDatos = new DataTable();
            lcSql = "SELECT * FROM " + DB.SQLDatabase("OFFLINE", "PRIORIDAD");
            DB.SQLExec(lcSql, ref tablaDatos);
            ConvertIndividualFile(tablaDatos, TempFolderName, "PRIORIDAD", FormatoExportacion.XML);

            IOfflineUnitOfWork offlineUnitOfWork = DependencyInjector.Instance.Retrieve<IOfflineUnitOfWork>();
            ILog_comoffRepository logRepository = offlineUnitOfWork.Log_comoffRepository;

            if (datos._IsCentral)
            {
                _TextStepDetalle = "Generando fichero configura_offline.xml";
                _TextStepProgreso = _TextStepDetalle;
                _PorcenProgreso = IncrementarBarraProgreso();

                Subir_Fichero_Configuracion(datos, logRepository);
            }

            Eliminar_Carpetas_Temporales(datos, logRepository);

            offlineUnitOfWork.SaveChanges();
            offlineUnitOfWork.Dispose();

            _Porcen_Progreso_Async -= OfflineUploader__Porcen_Progreso_Async;
            _Mostrar_Progreso_Async -= OfflineUploader__Mostrar_Progreso_Async;

            return true;
        }


        internal static bool Upload_Offline_Files(clsOfflineUtils.ReportProgress progressReporter, DateTime tdFechaConf, DateTime tdFechaMin, DateTime tdFechaMax, string tcSucursal, bool tlImagenes, bool tlAnterior, bool isCentral, int idConf, bool tlInicial = false, Dictionary<int, bool> prioridades = null)
        {
            _Mostrar_Progreso_Async -= OfflineUploader__Mostrar_Progreso_Async;
            _Porcen_Progreso_Async -= OfflineUploader__Porcen_Progreso_Async;

            _Mostrar_Progreso_Async += OfflineUploader__Mostrar_Progreso_Async;
            _Porcen_Progreso_Async += OfflineUploader__Porcen_Progreso_Async;

            _cTempFolderName = string.Empty;
            _cTempFileName = clsOfflineUtils.CrearNombreFicheroDatos(tcSucursal, idConf);

            if (!Directory.Exists(TempFolderName))
            {
                Directory.CreateDirectory(TempFolderName);
            }

            ReestablecerInfoConfig();
            Generar_Configuracion(progressReporter, tdFechaConf, tdFechaMin, tdFechaMax, isCentral, (tlInicial ? "i" : "e"), prioridades, tcSucursal);

            // i -> Carga Inicial    
            // e -> Envío de datos
            bool llOk = GenerarDatosEnvio(tcSucursal, tlImagenes, tdFechaConf, tdFechaMin, tdFechaMax, isCentral, idConf, (tlInicial ? "i" : "e"), prioridades);

            if (!tlInicial)
            {
                AsistenteOffEnvioDatosBizRule negocioOffline = new AsistenteOffEnvioDatosBizRule();

                if (negocioOffline.ValidacionEjercicioPredet())
                {
                    string lcEjercicioPredeterminado = negocioOffline.GetEjercicioPredeterminado();

                    DataTable ldtEjercicios = negocioOffline.GetEjerciciosOffline();

                    DataRow[] rows = ldtEjercicios.Select("tipooff = " + DB.SQLString(isCentral ? "CENTRAL" : tcSucursal));

                    foreach (DataRow item in rows)
                    {
                        if (item.Field<DateTime?>("traspejer") == null || item.Field<DateTime>("traspejer") < tdFechaMin || item.Field<DateTime>("traspejer") > tdFechaMax)
                        {
                            continue;
                        }

                        GenerarDatosEnvioEjercicioPosterior(progressReporter, tdFechaConf, tdFechaMin, tdFechaMax, tcSucursal, tlImagenes, isCentral, idConf, tlInicial, prioridades, lcEjercicioPredeterminado, item);

                        GenerarDatosEnvioEjercicioAnterior(progressReporter, tdFechaConf, tdFechaMin, tdFechaMax, tcSucursal, tlImagenes, isCentral, idConf, tlInicial, prioridades, lcEjercicioPredeterminado, item);
                    }
                }
            }

            _Mostrar_Progreso_Async -= OfflineUploader__Mostrar_Progreso_Async;
            _Porcen_Progreso_Async -= OfflineUploader__Porcen_Progreso_Async;

            return llOk;
        }

        private static void GenerarDatosEnvioEjercicioAnterior(clsOfflineUtils.ReportProgress progressReporter, DateTime tdFechaConf, DateTime tdFechaMin, DateTime tdFechaMax, string tcSucursal, bool tlImagenes, bool isCentral, int idConf, bool tlInicial, Dictionary<int, bool> prioridades, string lcEjercicioPredeterminado, DataRow item)
        {
            // Comprobar si existe un ejercicio anterior al predeterminado
            string lcEjercicioAnterior = item.Field<string>("EJERCICIO");

            if (!string.IsNullOrWhiteSpace(lcEjercicioAnterior) && Convert.ToInt16(lcEjercicioAnterior) < Convert.ToInt16(lcEjercicioPredeterminado))
            {
                if (lcEjercicioAnterior != lcEjercicioPredeterminado)
                {
                    // Cambiar al ejercicio 
                    FUNCTIONS.CambiarEjercicio(lcEjercicioPredeterminado, lcEjercicioAnterior);

                    _cTempFolderName = string.Empty;
                    _cTempFileName = clsOfflineUtils.CrearNombreFicheroDatos(tcSucursal, idConf);

                    if (!Directory.Exists(TempFolderName))
                    {
                        Directory.CreateDirectory(TempFolderName);
                    }

                    ReestablecerInfoConfig();
                    Generar_Configuracion(progressReporter, tdFechaConf, tdFechaMin, tdFechaMax, isCentral, (tlInicial ? "i" : "e"), prioridades, tcSucursal);
                    GenerarDatosEnvio(tcSucursal, tlImagenes, tdFechaConf, tdFechaMin, tdFechaMax, isCentral, idConf, (tlInicial ? "i" : "e"), prioridades);

                    // Restaurar al ejercicio 
                    FUNCTIONS.CambiarEjercicio(lcEjercicioAnterior, lcEjercicioPredeterminado);
                }
            }
        }

        private static void GenerarDatosEnvioEjercicioPosterior(clsOfflineUtils.ReportProgress progressReporter, DateTime tdFechaConf, DateTime tdFechaMin, DateTime tdFechaMax, string tcSucursal, bool tlImagenes, bool isCentral, int idConf, bool tlInicial, Dictionary<int, bool> prioridades, string lcEjercicioPredeterminado, DataRow item)
        {
            // Comprobar si existe un ejercicio posterior al predeterminado
            string lcEjercicioPosterior = item.Field<string>("EJERCICIO");

            if (!string.IsNullOrWhiteSpace(lcEjercicioPosterior) && Convert.ToInt16(lcEjercicioPosterior) > Convert.ToInt16(lcEjercicioPredeterminado))
            {
                if (lcEjercicioPosterior != lcEjercicioPredeterminado)
                {
                    // Cambiar al ejercicio 
                    FUNCTIONS.CambiarEjercicio(lcEjercicioPredeterminado, lcEjercicioPosterior);

                    _cTempFolderName = string.Empty;
                    _cTempFileName = clsOfflineUtils.CrearNombreFicheroDatos(tcSucursal, idConf);

                    if (!Directory.Exists(TempFolderName))
                    {
                        Directory.CreateDirectory(TempFolderName);
                    }

                    ReestablecerInfoConfig();
                    Generar_Configuracion(progressReporter, tdFechaConf, tdFechaMin, tdFechaMax, isCentral, (tlInicial ? "i" : "e"), prioridades, tcSucursal);
                    GenerarDatosEnvio(tcSucursal, tlImagenes, tdFechaConf, tdFechaMin, tdFechaMax, isCentral, idConf, (tlInicial ? "i" : "e"), prioridades);

                    // Restaurar al ejercicio 
                    FUNCTIONS.CambiarEjercicio(lcEjercicioPosterior, lcEjercicioPredeterminado);
                }
            }
        }

        private static void OfflineUploader__Mostrar_Progreso_Async(string message)
        {
            try
            {
                if(_offBase != null)
                    _offBase._TextStepDetalle = message;
            }
            catch (Exception) { }
        }

        private static void OfflineUploader__Porcen_Progreso_Async(decimal porcen, string message)
        {
            try
            {
                if (_offBase != null)
                {
                    _offBase._TextStepProgreso = message;
                    _offBase._PorcenProgreso = porcen;
                }
            }
            catch (Exception) { }
        }

        private static void Generar_Configuracion(clsOfflineUtils.ReportProgress progressReporter, DateTime tdFechaConf, DateTime tdFechaMin, DateTime tdFechaMax, bool isCentral, string cTipoEnvio, Dictionary<int, bool> prioridades, string tcSucursal)
        {
            // Los datos que se incluirán en los ficheros de configuración cuando la central realice un envío de datos o carga inicial serán los siguientes:
            // •   Versión de Sage 50 
            // •   Año y Fecha inicial y final de ejercicio desde el cual se ejecuta envío. 
            // •   Add - ons instalados(que exista base de datos) y Add-ons activos(mismo control que en formulario de aplicaciones y servicios conectados) en el grupo de empresa de Sage 50->Registrar únicamente estado de los siguientes Add-ons: Sage TPV Extra, Series, Trazabilidad, Tallas y colores, Tu eFideliza y Fabricación. 
            // •   Prioridades definidas para los datos a traspasar->Ver punto 17.1.2.

            InicializarBarraProgreso();
            _TextStepDetalle = "Generando fichero InfoConfig.xml";
            _TextStepProgreso = _TextStepDetalle;
            _PorcenProgreso = IncrementarBarraProgreso();

            PrioridadesBizRule rnPrioridades = DependencyInjector.Instance.Retrieve<PrioridadesBizRule>();//new PrioridadesBizRule();
            List<int> lstPrioridades = new List<int>();

            InfoConfig._PrioridadesCentral.Clear();
            InfoConfig._PrioridadesSucursal.Clear();

            foreach (KeyValuePair<int, bool> valuePair in prioridades)
            {
                lstPrioridades.Clear();
                rnPrioridades.AddPrioridadesDependientes(valuePair.Key, ref lstPrioridades);
                foreach (int item in lstPrioridades)
                {
                    if (valuePair.Value)
                    {
                        InfoConfig._PrioridadesCentral.Add(item);
                    }
                    else
                    {
                        InfoConfig._PrioridadesSucursal.Add(item);
                    }
                }
            }

            // •   Fecha inicial y final de los datos que contiene el fichero->Según tipo de envío las fechas serán diferentes.
            //      –  Carga inicial: Fecha inicial o final definida por el usuario en el asistente de Carga inicial.
            //      –  Envío de datos automático: Serán las mismas fechas que se usarán para seleccionar datos a enviar de las diferentes tablas. Fecha inicial será la fecha y hora del último envío de datos según valor de campo SUCURSALES.ULTFECENV(Tener en cuenta que para cada sucursal la fecha podrá ser diferente) y fecha final será la fecha y hora del sistema en el momento de ejecutar envío de datos. 
            //      –  Envío de datos personalizado: Fecha inicial o final definida por el usuario en el asistente de Carga inicial o Envío de datos.

            InfoConfig._FechaEnvioInicial = tdFechaMin;
            InfoConfig._FechaEnvioFinal = tdFechaMax;


            string lcInfoConfig = _SerializeOfflineInfoConfig(InfoConfig);
            byte[] bytes = Encoding.UTF8.GetBytes(lcInfoConfig);

            string lcPath = Path.Combine(TempFolderName, "InfoConfig.xml");

            if (!File.Exists(lcPath))
            {
                FileStream loStream = File.Create(lcPath);

                loStream.Write(bytes, 0, bytes.Length);

                loStream.Close();
            }
            
            if (isCentral)
            {
                //•    Tamaño de campos en la instalación Central->Se incluirá la longitud que tienen todos los campos ampliables de Sage 50.

                //Crear fichero CONFIG.DBF
                _TextStepDetalle = "Generando fichero Config.xml";
                _TextStepProgreso = _TextStepDetalle;
                _PorcenProgreso = IncrementarBarraProgreso();
                clsOfflineUtils.GenerarAmplitudCampos(TempFolderName);
            
                //•    Sucursales->Configuración de todas las sucursales, datos en tablas SUCURSALES, SUCURALM, SUCURCONF y SUCURLET.Ver punto 17.1.1.
                TratarConfiguracion("SUCURSALES", tdFechaConf, DateTime.MaxValue);
                TratarConfiguracion("SUCURALM", tdFechaConf, DateTime.MaxValue);
                TratarConfiguracion("SUCURLET", tdFechaConf, DateTime.MaxValue);
                TratarConfiguracion("SUCURART", tdFechaConf, DateTime.MaxValue);
                TratarConfiguracion("SUCURCAJA", tdFechaConf, DateTime.MaxValue);

                //•    Configuración de comunicaciones->Tablas MULTCONF y TABNETCONF, PRIORIDAD.Ver punto 17.1.3.
                TratarConfiguracion("MULTCONF", tdFechaConf, DateTime.MaxValue);
                TratarConfiguracion("SUCURCONF", tdFechaConf, DateTime.MaxValue);
                TratarConfiguracion("TABNETCONF", tdFechaConf, DateTime.MaxValue);

                if (cTipoEnvio == "i")
                {
                    TratarConfiguracion("VARIABLES", tdFechaConf, DateTime.MaxValue, " VARIABLE = 'ULTIMOLOG' ");
                }

                TratarConfiguracion("EJERCICIOS", tdFechaConf, DateTime.MaxValue, " TIPOOFF = 'CENTRAL' ");

                DataTable ldtPrioridades = obtenerDatosEnvio(prioridades, cTipoEnvio);
                TratarConfiguracion("PRIORIDAD", tdFechaConf, DateTime.MaxValue, TabTmp: ldtPrioridades);
            }
            else
            {
                // Comentado con Nestor y cuando hacemos envío de datos de sucursal a central sólo debemos mandar la sucursal desde la que enviamos.
                TratarConfiguracion("SUCURSALES", tdFechaMin, tdFechaMax, " CODIGO = " + DB.SQLString(tcSucursal));

                TratarConfiguracion("EJERCICIOS", tdFechaConf, DateTime.MaxValue, " TIPOOFF = '" + tcSucursal + "' ");
            }
        }

        private static void TratarConfiguracion(string nombreTabla, DateTime tdFechaMin, DateTime tdFechaMax, string tcWhere = " 1 = 1 ", DataTable TabTmp = null)
        {
            DataTable tablaDatos = new DataTable();
            string lcSql = string.Empty;
            string lcWhere = string.Empty;

            _TextStepDetalle = "Generando fichero " + nombreTabla + ".xml";
            _TextStepProgreso = _TextStepDetalle;
            _PorcenProgreso = IncrementarBarraProgreso();

            lcSql += "SELECT * FROM " + DB.SQLDatabase("OFFLINE", nombreTabla.ToUpper()) +
                     " WHERE " + tcWhere + " AND MODIFIED >= " + DB.SQLString(tdFechaMin) + " AND MODIFIED <= " + DB.SQLString(tdFechaMax) +
                     " AND (CREATED < " + DB.SQLString(tdFechaMin) + " OR CREATED > " + DB.SQLString(tdFechaMax) + " ) ";

            lcSql += " UNION ALL ";

            lcSql += "SELECT * FROM " + DB.SQLDatabase("OFFLINE", nombreTabla.ToUpper()) +
                     " WHERE " + tcWhere + " AND CREATED >= " + DB.SQLString(tdFechaMin) + " AND CREATED <= " + DB.SQLString(tdFechaMax);

            DB.SQLExec(lcSql, ref tablaDatos);

            if (tablaDatos.Rows.Count > 0)
            {
                switch (nombreTabla.ToUpper())
                {
                    case "PRIORIDAD":

                        foreach (DataRow item in tablaDatos.Rows)
                        {
                            // Actualizar la tabla segun las prioridades seleccionadas
                            DataRow[] r = TabTmp.Select("id = " + item["idtabrel"].ToString());

                            if (r.Length > 0)
                            {
                                if (Convert.ToBoolean(r[0]["prioridad"]))
                                {
                                    item["prio_datos"] = 1;
                                }
                                else
                                {
                                    item["prio_datos"] = 2;
                                }
                            }
                        }

                        break;

                    default:

                        break;
                }

                ConvertIndividualFile(tablaDatos, TempFolderName, nombreTabla.ToUpper(), FormatoExportacion.XML);
            }
        }

        private static bool GenerarDatosEnvio(string tcSucursal, bool tlImagenes, DateTime tdFechaConf, DateTime tdFechaMin, DateTime tdFechaMax, bool isCentral, int idConf, string cTipoEnvio, Dictionary<int, bool> prioridades = null)
        {
            IOfflineUnitOfWork offlineUnitOfWork = DependencyInjector.Instance.Retrieve<IOfflineUnitOfWork>();
            ILog_comoffRepository logRepository = offlineUnitOfWork.Log_comoffRepository;

            _cRaizDataBaseTemporal = ObtenerDataBaseName(tcSucursal);

            Dictionary<string, object> tablaSucursales = DB.SQLREGValor("SUCURSALES", "CODIGO", tcSucursal, "OFFLINE");

            string lcBdTabla = string.Empty;
            string lcPrincipal = string.Empty;
            string lcBd = string.Empty;
            string lcTabla = string.Empty;
            string lcClave = string.Empty;
            string lcVisicond = string.Empty;
            string lcCondEnv = string.Empty;
            string lcTitulo = string.Empty;

            string lcBdReal = string.Empty;
            string lcBdAnt = string.Empty;
            string lcTablaControl = string.Empty;
            string lcTipoDato = string.Empty;

            bool llOk = true;
            string lcSql = string.Empty;
            DataTable tablaDatosNuevos = new DataTable();
            DataTable tablaDatosModi = new DataTable();
            DataTable ldtImagenes = new DataTable();

            // Obtenemos datos en la tabla dependiendo del tipo de envío:
            // i -> Carga Inicial    
            // e -> Envío de datos
            string lcTipoEnvio = (cTipoEnvio == "i" ? "la carga inicial" : "envío");
            OfflineDatosComunicaciones datos = EstablecerConfiguracion(tcSucursal, tdFechaConf, tdFechaMin, tdFechaMax, isCentral, idConf, cTipoEnvio, logRepository);

            Log_comoffDto logDto = logRepository.GetDto(datos);
            logDto.TipoDato = "01";
            logDto.Resultado = 1;
            logDto.Detalle = "Iniciando " + lcTipoEnvio + " de datos para la sucursal " + tcSucursal + ".";
            logRepository.Insert(logDto);


            logDto.Detalle = "Obtener configuración de " + lcTipoEnvio + " de datos para la sucursal " + tcSucursal + ".";
            logRepository.Insert(logDto);

            DataTable TabTmp = obtenerDatosEnvio(prioridades, cTipoEnvio);

            Dictionary<string, bool> dicTablas = new Dictionary<string, bool>();
            foreach (DataRow row in TabTmp.Rows)
            {
                if (!dicTablas.ContainsKey(row[0].ToString()))
                    dicTablas.Add(row[0].ToString(), false);
            }

            VaciarUltimoLog(datos, logRepository);

            // Crear un directorio para la carga inicial/envío de datos
            if (!Directory.Exists(datos._PathFolderInicial))
            {
                Directory.CreateDirectory(datos._PathFolderInicial);

                logDto.Detalle = "Se ha creado la carpeta temporal " + datos._PathFolderInicial + ".";
                logRepository.Insert(logDto);
            }

            #region Crear_Tablas_temporales

            // Tablas temporales
            Dictionary<string, DataTable> dicDt = CrearTablasTemporales();
            

            #endregion Crear_Tablas_temporales

            #region Gestionar Tablas

            decimal nCociente = (TabTmp != null ? TabTmp.Rows.Count : 99.0M);

            nCociente = (nCociente == 0 ? 100 : nCociente);
            InicializarBarraProgreso(Convert.ToInt32(nCociente));
            bool prioridadUsuarios = false;

            //Crear les bases de dades temporals a s amb les taules de la càrrega inicial
            foreach (DataRow itemRow in TabTmp.Rows)
            {
                // comprovo si tinc el módul INSTAL·LAT
                if (!clsOfflineUtils.EvaluarCondicion(itemRow.Field<string>("visicond").TrimEnd().ToLower()))
                {
                    continue;
                }

                if (itemRow.Field<string>("nombre").TrimEnd() == "COMUNES!HISSERIE")
                {
                    continue;
                }

                RegistroTabRel registro = ComprobarFicheros(itemRow);

                TratarTablasEnvio(itemRow, datos, registro, tcSucursal, tlImagenes, dicTablas, dicDt, ref ldtImagenes, logRepository);

                // Per la següent iteració
                lcBdAnt = lcBd;

                if (itemRow.Field<string>("nombre").TrimEnd() == "EUROWINSYS!UNIUSERS")
                {
                    prioridadUsuarios = itemRow.Field<bool>("prioridad");
                }
            }

            // Tratamiento especial de tablas
            foreach (DataRow itemRow in TabTmp.Rows)
            {
                // comprovo si tinc el módul INSTAL·LAT
                if (!clsOfflineUtils.EvaluarCondicion(itemRow.Field<string>("visicond").TrimEnd().ToLower()))
                {
                    continue;
                }

                if (itemRow.Field<string>("nombre").TrimEnd() == "COMUNES!HISSERIE")
                {
                    RegistroTabRel registro = ComprobarFicheros(itemRow);

                    TratarTablasEnvioEspecial(itemRow, datos, registro, tcSucursal, tlImagenes, dicTablas, dicDt, logRepository);
                }

                // Per la següent iteració
                lcBdAnt = lcBd;
            }

            InicializarBarraProgreso();

            TratamientoFinal_Fabricacion(datos);

            GenerarRiesgoCliente(datos);

            GenerarDeletesDeConfiguracion(datos, dicDt, prioridadUsuarios);

            // Generar fichero XML Series cuando sea envío de datos desde sucursal
            GenerarFicherosXML_Series(datos, logRepository);

            // Generar ficheros XML de datos
            GenerarFicherosXML(datos);

            #endregion Gestionar Tablas

            foreach (KeyValuePair<string, bool> entry in dicTablas)
            {
                if (!entry.Value)
                {
                    logDto.Resultado = 2;
                    logDto.TipoDato = clsOfflineUtils.ObtenerTipoDato(entry.Key.ToString().Trim());
                    logDto.Detalle = "No se ha incluido modificaciones de " + entry.Key.ToString().Trim() + " en el fichero, no se ha detectado datos nuevos o modificados.";
                    logRepository.Insert(logDto);
                }
            }

            GestionarXML_TablasTemporales(dicDt, datos, lcBd, logRepository);

            Procesar_Imagenes_Envio(lcBdTabla, datos, ldtImagenes, logRepository);

            llOk = Subir_Fichero_DatosEnvio(datos, cTipoEnvio == "e" ? (isCentral ? "c" : "s") : cTipoEnvio, logRepository);

            Actualizar_Fecha_Envio_Sucursales(datos, cTipoEnvio, logRepository);

            if (datos._TipoCom == 2)   // Envío de datos
            {
                Actualizar_Fecha_Envio_Multiconf(datos);

                string lcBaseFicheroZip = _cTempFileName + (cTipoEnvio == "e" ? (isCentral ? "c" : "s") : cTipoEnvio);

                offlineUnitOfWork.SaveChanges();

                EnvioEmailNotificacion(lcBaseFicheroZip, datos, logRepository);
            }

            Eliminar_Carpetas_Temporales(datos, logRepository);

            // Eliminar base de datos temporal
            EliminarDataBaseTemporal();

            offlineUnitOfWork.SaveChanges();
            offlineUnitOfWork.Dispose();

            return llOk;
        }

        private static Dictionary<string, DataTable> CrearTablasTemporales()
        {
            Dictionary<string, DataTable> dicDt = new Dictionary<string, DataTable>();
            DataTable dtAuxiliar = new DataTable();

            DB.SQLExec("SELECT * FROM " + DB.SQLDatabase("OFFLINE", "DELETENET") + " WHERE 1 = 2 ", ref dtAuxiliar);
            dicDt.Add("DELETENET", dtAuxiliar);

            dtAuxiliar = new DataTable();
            DB.SQLExec("SELECT * FROM " + DB.SQLDatabase("OFFLINE", "ACTRIESGO") + " WHERE 1 = 2 ", ref dtAuxiliar);
            dicDt.Add("ACTRIESGO", dtAuxiliar);

            return dicDt;
        }

        private static void GenerarDeletesDeConfiguracion(OfflineDatosComunicaciones datos, Dictionary<string, DataTable> dicDt, bool prioridadUsuarios)
        {
            DataTable dtDelete = dicDt.FirstOrDefault(x => x.Key == "DELETENET").Value;

            if (datos._IsCentral)
            {
                DateTime ldFechaAux = datos._FechaInicial;
                datos._FechaInicial = datos._FechaConf;

                Gestionar_Tabla_DeleteNet(dtDelete, datos, "OFFLINE!MULTCONF", dicDt, new RegistroTabRel());
                Gestionar_Tabla_DeleteNet(dtDelete, datos, "OFFLINE!TABNETCONF", dicDt, new RegistroTabRel());

                if (datos._TipoCom == 1 && prioridadUsuarios)
                {
                    Gestionar_Tabla_DeleteNet(dtDelete, datos, "COMUNES!USUARIOS", dicDt, new RegistroTabRel());
                }

                Gestionar_Tabla_DeleteNet(dtDelete, datos, "OFFLINE!SUCURCONF", dicDt, new RegistroTabRel());
                Gestionar_Tabla_DeleteNet(dtDelete, datos, "OFFLINE!SUCURLET", dicDt, new RegistroTabRel());
                Gestionar_Tabla_DeleteNet(dtDelete, datos, "OFFLINE!SUCURALM", dicDt, new RegistroTabRel());
                Gestionar_Tabla_DeleteNet(dtDelete, datos, "OFFLINE!SUCURCAJA", dicDt, new RegistroTabRel());

                Gestionar_Tabla_DeleteNet(dtDelete, datos, "OFFLINE!SUCURART", dicDt, new RegistroTabRel());

                datos._FechaInicial = ldFechaAux;
            }
        }

        private static OfflineDatosComunicaciones EstablecerConfiguracion(string tcSucursal, DateTime tdFechaConf, DateTime tdFechaMin, DateTime tdFechaMax, bool isCentral, int idConf, string cTipoEnvio, ILog_comoffRepository logRepository)
        {
            OfflineDatosComunicaciones datos = new OfflineDatosComunicaciones();
            _offlineConfig = DependencyInjector.Instance.Retrieve<OfflineConfig>();

            datos._Log_ComoffID = _cIdLog;
            datos._IdConf = idConf;
            datos._MultConf = DB.SQLValor("MULTCONF", "IDCONF", idConf.ToString(), "CODIGO", "OFFLINE").ToString();
            datos._Usuario = sage.ew.global.EW_GLOBAL._GetVariable("wc_usuario").ToString();
            datos._BdOffline = clsOfflineUtils.ObtenerNombreBdReal("OFFLINE");
            datos._Sucursal = tcSucursal;
            datos._PathFolderInicial = TempFolderName;
            datos._IniServidor = DB._GetVariable("wc_iniservidor").ToString().ToLower();
            datos._EnvioArticulos = _offlineConfig.GetValorVariable(EnumVariables.ENVIOARTICULOS) == ".T.";
            datos._FechaConf = tdFechaConf;
            datos._FechaInicial = tdFechaMin;
            datos._FechaFinal = tdFechaMax;
            datos._Almacenes = _offlineConfig.ObtenerAlmacenesSucursal(tcSucursal);
            datos._Series = _offlineConfig.ObtenerSeriesSucursal(tcSucursal);
            datos._Cajas = _offlineConfig.ObtenerCajasSucursal(tcSucursal);
            datos._TipoCom = (cTipoEnvio == "i" ? 1 : 2);
            datos._IsCentral = isCentral;

            if (isCentral)
            {
                datos._Delete_Mantes = _offlineConfig.GetValorVariable(EnumVariables.DELETE_CEN_MANT) == ".T.";
                datos._Delete_Documentos = _offlineConfig.GetValorVariable(EnumVariables.DELETE_CEN_DOC) == ".T.";
            }
            else
            {
                datos._Delete_Mantes = _offlineConfig.GetValorVariable(EnumVariables.DELETE_SUC_MANT) == ".T.";
                datos._Delete_Documentos = _offlineConfig.GetValorVariable(EnumVariables.DELETE_SUC_DOC) == ".T.";
            }

            datos._NotificacionEnvio = Convert.ToBoolean(DB.SQLValor("MULTCONF", "IDCONF", idConf.ToString(), "NOTIFICAEN", "OFFLINE"));
            datos._EmailNotificacionEnvio = Convert.ToString(DB.SQLValor("MULTCONF", "IDCONF", idConf.ToString(), "EMAILNOTEN", "OFFLINE"));

            datos._NotificacionRecepcion = Convert.ToBoolean(DB.SQLValor("MULTCONF", "IDCONF", idConf.ToString(), "NOTIFICARE", "OFFLINE"));
            datos._EmailNotificacionRecepcion = Convert.ToString(DB.SQLValor("MULTCONF", "IDCONF", idConf.ToString(), "EMAILNOTRE", "OFFLINE"));

            try
            {
                datos._UltimoLog = Convert.ToInt32(_offlineConfig.GetValorVariable(EnumVariables.ULTIMOLOG));
            }
            catch
            {
                datos._UltimoLog = 6;
            }



            string[] loClaveBackup = _offlineConfig.GetValorVariable(EnumVariables.BACKUP_RECEP).Split('|');
            if (loClaveBackup.Length == 3)
            {
                try
                {
                    datos._Backup = (loClaveBackup[0].ToUpper() == ".T." ? true : false);
                    datos._BackupPath = loClaveBackup[1].TrimEnd();
                    datos._BackupNumArchivos = Convert.ToInt32(loClaveBackup[2]);
                }
                catch
                {
                    Log_comoffDto logDto = logRepository.GetDto(datos);
                    logDto.TipoDato = "01";
                    logDto.Resultado = 2;
                    logDto.Detalle = "Error al leer la configuración de la variable " + EnumVariables.BACKUP_RECEP.ToString();
                    logRepository.Insert(logDto);
                }
            }

            return datos;
        }

        private static void GenerarRiesgoCliente(OfflineDatosComunicaciones datos)
        {
            if (!datos._IsCentral)
            {
                return;
            }

            _TextStepDetalle = "Generando riesgo de clientes";
            _TextStepProgreso = _TextStepDetalle;
            _PorcenProgreso = IncrementarBarraProgreso();

            DataTable tablaDatos = new DataTable();
            string lcSql = "SELECT * FROM " + DB.SQLDatabase("GESTION", "RIESGO");
            lcSql += " WHERE 1 = 1 ";
            lcSql += " AND MODIFIED >= " + DB.SQLString(datos._FechaInicial) + " AND MODIFIED <= " + DB.SQLString(datos._FechaFinal);
            lcSql += " AND (CREATED < " + DB.SQLString(datos._FechaInicial) + " OR CREATED > " + DB.SQLString(datos._FechaFinal) + ")";
            lcSql += " UNION ALL ";
            lcSql += " SELECT * FROM " + DB.SQLDatabase("GESTION", "RIESGO");
            lcSql += " WHERE 1 = 1 ";
            lcSql += " AND CREATED >= " + DB.SQLString(datos._FechaInicial) + " AND CREATED <= " + DB.SQLString(datos._FechaFinal);

            DB.SQLExec(lcSql, ref tablaDatos);
            ConvertIndividualFile(tablaDatos, TempFolderName, "RIESGO", FormatoExportacion.XML);
        }

        private static void TratamientoFinal_Fabricacion(OfflineDatosComunicaciones datos)
        {
            _TextStepDetalle = "Ejecutando procesos adicionales";
            _TextStepProgreso = _TextStepDetalle;
            _PorcenProgreso = IncrementarBarraProgreso();

            string lcSql = string.Empty;
            string[] Sufijos = new string[] { "_CREATED", "_MODIFIED" };
            DataTable table = new DataTable();

            foreach (string sufijo in Sufijos)
            {
                // Cabecera Partes de costes
                if (clsOfflineUtils.ExisteTablaOffline("[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "C_PARTES" + sufijo + "]"))
                {
                    bool llPartes1 = clsOfflineUtils.ExisteTablaOffline("[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_PARTES1_C_PARTES" + sufijo + "]");
                    bool llPartes2 = clsOfflineUtils.ExisteTablaOffline("[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_PARTES2_C_PARTES" + sufijo + "]");
                    bool llCostes = clsOfflineUtils.ExisteTablaOffline("[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_COSTES_C_PARTES" + sufijo + "]");

                    if (llPartes1 && llPartes2 && llCostes)
                    {
                        lcSql = " SELECT a.* INTO [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "C_PARTES" + sufijo + "] " +
                                " FROM ( " +
                                        " SELECT * FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_PARTES1_C_PARTES" + sufijo + "] " +
                                        " UNION ALL " +
                                        " SELECT * FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_PARTES2_C_PARTES" + sufijo + "] " +
                                        " UNION ALL " +
                                        " SELECT * FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_COSTES_C_PARTES" + sufijo + "] " +
                                     " ) a ";
                    }
                    else
                    {
                        if (llPartes1)
                        {
                            lcSql = " SELECT * INTO [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "C_PARTES" + sufijo + "] " +
                                    "FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_PARTES1_C_PARTES" + sufijo + "] ";
                        }

                        if (llPartes2)
                        {
                            lcSql = " SELECT * INTO [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "C_PARTES" + sufijo + "] " +
                                    "FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_PARTES2_C_PARTES" + sufijo + "] ";
                        }

                        if (llCostes)
                        {
                            lcSql = " SELECT * INTO [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "C_PARTES" + sufijo + "] " +
                                    "FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_COSTES_C_PARTES" + sufijo + "] ";
                        }
                    }

                    if (!string.IsNullOrWhiteSpace(lcSql))
                    {
                        DB.SQLExec("DROP TABLE IF EXISTS [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "C_PARTES" + sufijo + "]");
                        DB.SQLExec(lcSql);
                    }
                }

                // Lineas Partes de costes
                if (clsOfflineUtils.ExisteTablaOffline("[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "D_PARTES" + sufijo + "]"))
                {
                    bool llPartes1 = clsOfflineUtils.ExisteTablaOffline("[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_PARTES1_D_PARTES" + sufijo + "]");
                    bool llPartes2 = clsOfflineUtils.ExisteTablaOffline("[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_PARTES2_D_PARTES" + sufijo + "]");
                    bool llCostes = clsOfflineUtils.ExisteTablaOffline("[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_COSTES_D_PARTES" + sufijo + "]");

                    if (llPartes1 && llPartes2 && llCostes)
                    {
                        lcSql = " SELECT a.* INTO [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "D_PARTES" + sufijo + "] " +
                                " FROM ( " +
                                        " SELECT * FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_PARTES1_D_PARTES" + sufijo + "] " +
                                        " UNION ALL " +
                                        " SELECT * FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_PARTES2_D_PARTES" + sufijo + "] " +
                                        " UNION ALL " +
                                        " SELECT * FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_COSTES_D_PARTES" + sufijo + "] " +
                                     " ) a ";
                    }
                    else
                    {
                        if (llPartes1)
                        {
                            lcSql = " SELECT * INTO [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "D_PARTES" + sufijo + "] " +
                                    "FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_PARTES1_D_PARTES" + sufijo + "] ";
                        }

                        if (llPartes2)
                        {
                            lcSql = " SELECT * INTO [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "D_PARTES" + sufijo + "] " +
                                    "FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_PARTES2_D_PARTES" + sufijo + "] ";
                        }

                        if (llCostes)
                        {
                            lcSql = " SELECT * INTO [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "D_PARTES" + sufijo + "] " +
                                    "FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_COSTES_D_PARTES" + sufijo + "] ";
                        }
                    }

                    if (!string.IsNullOrWhiteSpace(lcSql))
                    {
                        DB.SQLExec("DROP TABLE IF EXISTS [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "D_PARTES" + sufijo + "]");
                        DB.SQLExec(lcSql);
                    }
                }

                DB.SQLExec("DROP TABLE IF EXISTS [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_PARTES1_C_PARTES" + sufijo + "]");
                DB.SQLExec("DROP TABLE IF EXISTS [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_PARTES2_C_PARTES" + sufijo + "]");
                DB.SQLExec("DROP TABLE IF EXISTS [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_COSTES_C_PARTES" + sufijo + "]");
                DB.SQLExec("DROP TABLE IF EXISTS [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_PARTES1_D_PARTES" + sufijo + "]");
                DB.SQLExec("DROP TABLE IF EXISTS [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_PARTES2_D_PARTES" + sufijo + "]");
                DB.SQLExec("DROP TABLE IF EXISTS [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "_COSTES_D_PARTES" + sufijo + "]");
            }
        }

        private static void GenerarFicherosXML(OfflineDatosComunicaciones datos)
        {
            GenerarFicherosDatabaseXML(_cRaizDataBaseTemporal + "COMUNES", datos);
            GenerarFicherosDatabaseXML(_cRaizDataBaseTemporal + "GESTION", datos);

            //* *Faig un recorregut per tots els móduls que tinc
            foreach (KeyValuePair<string, DB._ModuloSchema> entry in DB._dicCacheModulos)
            {
                GenerarFicherosDatabaseXML(_cRaizDataBaseTemporal + entry.Value._Nombre, datos);
            }

            GenerarFicherosDatabaseXML(_cRaizDataBaseTemporal + "EUROWINSYS", datos);
        }

        private static void GenerarFicherosDatabaseXML(string tcDatabase, OfflineDatosComunicaciones datos)
        {
            string lcSql = string.Empty;
            DataTable ldtDatos = new DataTable();

            if (clsOfflineUtils.ExisteDatabaseOffline(tcDatabase))
            {
                int lnPos = tcDatabase.LastIndexOf("_");
                string lcNombre = tcDatabase.Substring(lnPos + 1);
                string lcGetDate = " GETDATE() ";

                _TextStepDetalle = "Generando ficheros XML de la base de datos " + lcNombre.ToUpper();
                _TextStepProgreso = _TextStepDetalle;
                _PorcenProgreso = IncrementarBarraProgreso();

                DataTable table = clsOfflineUtils.ListaTablasDatabaseOffline(tcDatabase);

                foreach (DataRow item in table.Rows)
                {
                    string lcCadenaCamps = ObtenerCamposSelect(lcNombre, item["table_name"].ToString().Trim());

                    lcSql = "SELECT DISTINCT " + lcCadenaCamps + ", " + lcGetDate + " as created, " + lcGetDate + " as modified FROM [" + tcDatabase + "].dbo.[" + item["table_name"].ToString().Trim() + "] ";
                    DB.SQLExec(lcSql, ref ldtDatos);

                    ConvertIndividualFile(ldtDatos, Path.Combine(datos._PathFolderInicial, lcNombre), item["table_name"].ToString().Trim(), FormatoExportacion.XML);
                }

            }
        }

        private static string ObtenerCamposSelect(string tcDBLocal, string tcTablaLocal)
        {
            // tcDBLocal->Nombre de la base de datos a la cual pertenece la tabla tcTablaLocal
            // tcTablaLocal->nombre de la tabla de la cual se debe comparar

            string lcSelect = string.Empty;
            string lcComa = string.Empty;
            DataTable ldtCampos = new DataTable();

            DB.SQLExec("SELECT column_name, data_type FROM " + _cRaizDataBaseTemporal + tcDBLocal + ".INFORMATION_SCHEMA.COLUMNS WHERE table_name = '" + tcTablaLocal + "' ", ref ldtCampos);

            //Creamos estructura vacia
            foreach (DataRow item in ldtCampos.Rows)
            {
                switch (item["column_name"].ToString().ToLower())
                {
                    case "com_estado":
                    case "com_fecha":
                    case "com_ini":
                    case "sucursal":
                    case "created":
                    case "modified":
                    case "vista":

                        break;

                    default:

                        switch (item["data_type"].ToString().ToLower())
                        {
                            case "text":
                            case "ntext":

                                lcSelect += lcComa + "CONVERT(VARCHAR(MAX), [" + item["column_name"].ToString().ToLower() + "]) as [" + item["column_name"].ToString().ToLower() + "] ";
                                break;

                            default:

                                lcSelect += lcComa + "[" + item["column_name"].ToString().ToLower() + "]";

                                break;
                        }

                        lcComa = ", ";

                        break;
                }
            }

            return lcSelect;
        }

        private static void TratarTablasEnvio(DataRow item, OfflineDatosComunicaciones datos, RegistroTabRel registro, string tcSucursal, bool tlImagenes, Dictionary<string, bool> dicTablas, Dictionary<string, DataTable> dicDt, ref DataTable ldtImagenes, ILog_comoffRepository logRepository)
        {
            string lcTipoDato = clsOfflineUtils.ObtenerTipoDato(registro._Clave);

            string lcCampoEmpresa = item.Field<string>("empresa").TrimEnd();
            string lcCampoEmpreSecun = item.Field<string>("empresecun").TrimEnd();

            // Obtenir nom real de la bd
            string lcBdReal = clsOfflineUtils.ObtenerNombreBdReal(registro._DBSecundaria);

            // Ens saltem les bases de dades que no existeixen
            if (string.IsNullOrEmpty(lcBdReal))
            {
                Log_comoffDto logDto = logRepository.GetDto(datos);
                logDto.TipoDato = lcTipoDato;
                logDto.Resultado = 3;
                logDto.Detalle = "No existe la base de datos " + registro._DBSecundaria + ".";
                logRepository.Insert(logDto);
            }
            else
            {
                _TextStepDetalle = "Revisando datos tabla " + registro._DBSecundaria + "!" + registro._TablaSecundaria;
                _TextStepProgreso = _TextStepDetalle;
                _PorcenProgreso = IncrementarBarraProgreso();

                string lcSql = string.Empty;
                string lcFiltrePrincipal = string.Empty;
                string lcFilterCondCtrl = string.Empty;
                string lcFilterCondCtrl_2 = string.Empty;
                string lcAny = EW_GLOBAL._GetVariable("wc_any").ToString();

                if (!string.IsNullOrWhiteSpace(registro._CondCtrl))
                {
                    string lcOn = string.Empty;

                    lcOn = ObtenerInnerOn(registro._DBPrincipal, registro._DBCondCtrl, registro._TablaPrincipal, registro._TablaCondCtrl, registro._RelaCtrl, registro._Clave, datos, logRepository, true);
                    lcOn = lcOn + " AND c.EJERCICIO = " + DB.SQLString(lcAny);

                    lcFilterCondCtrl = " INNER JOIN [" + clsOfflineUtils.ObtenerNombreBdReal(registro._DBCondCtrl) + "].dbo." + registro._TablaCondCtrl + " c " + " ON " + lcOn;

                    lcFilterCondCtrl = lcFilterCondCtrl.Replace("b.", "c.");
                    lcFilterCondCtrl = lcFilterCondCtrl.Replace("B.", "C.");

                    lcFilterCondCtrl_2 = _offlineConfig.ConstruirFiltroCaja(registro._CondCtrl, tcSucursal, datos._Cajas);
                    lcFilterCondCtrl_2 = lcFilterCondCtrl_2.Replace("{TABLA}", "c.");

                    lcFilterCondCtrl = lcFilterCondCtrl + " AND " + lcFilterCondCtrl_2;
                }

                lcSql = " FROM [" + lcBdReal + "].dbo." + registro._TablaSecundaria + " b " +
                        " INNER JOIN [" + clsOfflineUtils.ObtenerNombreBdReal(registro._DBPrincipal) + "].dbo." + registro._TablaPrincipal + " a " +
                        " ON " + ObtenerInnerOn(registro._DBPrincipal, registro._DBSecundaria, registro._TablaPrincipal, registro._TablaSecundaria, registro._Relacion, registro._Clave, datos, logRepository) +
                        lcFilterCondCtrl +
                        " WHERE 1=1 ";

                // Casos especiales
                if (datos._EnvioArticulos && ((registro._DBPrincipal + "!" + registro._TablaPrincipal) == "GESTION!ARTICULO" || registro._Clave == "STOCKINI" || registro._Clave == "STOCKS"))
                {
                    lcSql += Envio_Articulos_Sucursal(datos, registro._TablaSecundaria);
                }

                if (datos._IsCentral && registro._DBPrincipal + "!" + registro._TablaPrincipal == "COMUNES!LETRAS")
                {
                    lcSql += Envio_Series_Sucursal(datos);
                }

                if (datos._IsCentral && registro._DBPrincipal + "!" + registro._TablaPrincipal == "TPV!CAJAS")
                {
                    lcSql += Envio_Cajas_Sucursal(datos);
                }

                if (registro._DBPrincipal != registro._DBSecundaria || registro._TablaPrincipal != registro._TablaSecundaria)
                {
                    
                    if (!string.IsNullOrEmpty(registro._CondSecun))
                    {
                        lcFiltrePrincipal = registro._CondSecun;
                        lcFiltrePrincipal = lcFiltrePrincipal.Replace("{TABLA}", "b.");

                        lcSql = lcSql + " AND " + lcFiltrePrincipal;
                    }
                }

                if (!string.IsNullOrWhiteSpace(registro._CondEnv))
                {
                    lcFiltrePrincipal = registro._CondEnv;
                    lcFiltrePrincipal = _offlineConfig.ConstruirFiltroAlmacen(lcFiltrePrincipal, tcSucursal, datos._Almacenes, registro._TablaSecundaria);
                    lcFiltrePrincipal = _offlineConfig.ConstruirFiltroLetra(lcFiltrePrincipal, tcSucursal, datos._Series);
                    lcFiltrePrincipal = _offlineConfig.ConstruirFiltroCaja(lcFiltrePrincipal, tcSucursal, datos._Cajas);

                    lcFiltrePrincipal = lcFiltrePrincipal.Replace("{TABLA}", "a.");

                    lcSql = lcSql + " AND " + lcFiltrePrincipal;
                }

                //Copiar només els registres de les empreses no excloses
                clsOfflineUtils.RevisarTablasCampoEmpresa(registro._TablaPrincipal, ref lcCampoEmpresa);
                if (!string.IsNullOrWhiteSpace(lcCampoEmpresa))
                {
                    lcSql = lcSql + " AND a." + lcCampoEmpresa + " NOT IN (SELECT empresa FROM [" + datos._BdOffline + "].dbo.empexclu) ";
                }

                clsOfflineUtils.RevisarTablasCampoEmpresa(registro._TablaSecundaria, ref lcCampoEmpreSecun);
                if (!string.IsNullOrWhiteSpace(lcCampoEmpreSecun))
                {
                    lcSql = lcSql + " AND b." + lcCampoEmpreSecun + " NOT IN (SELECT empresa FROM [" + datos._BdOffline + "].dbo.empexclu) ";
                }

                ActualizarDatosEnvio(item, datos, registro, tcSucursal, tlImagenes, dicTablas, dicDt, ref ldtImagenes, lcSql, logRepository);

                // Gestionar la tabla DELETENET
                DataTable dtDelete = dicDt.FirstOrDefault(x => x.Key == "DELETENET").Value;

                if (datos._IsCentral ? Convert.ToBoolean(registro._Prioridad) : !Convert.ToBoolean(registro._Prioridad))
                {
                    if (datos._TipoCom == 2 || (datos._TipoCom == 1 && (registro._IdGrupo == 3 || registro._IdGrupo == 4)))
                    {
                        Gestionar_Tabla_DeleteNet(dtDelete, datos, registro._Nombre, dicDt, registro);
                    }
                }
            }
        }

        private static void TratarTablasEnvioEspecial(DataRow item, OfflineDatosComunicaciones datos, RegistroTabRel registro, string tcSucursal, bool tlImagenes, Dictionary<string, bool> dicTablas, Dictionary<string, DataTable> dicDt, ILog_comoffRepository logRepository)
        {
            string lcTipoDato = clsOfflineUtils.ObtenerTipoDato(registro._Clave);

            string lcCampoEmpresa = item.Field<string>("empresa").TrimEnd();
            string lcCampoEmpreSecun = item.Field<string>("empresecun").TrimEnd();

            // Obtenir nom real de la bd
            string lcBdReal = clsOfflineUtils.ObtenerNombreBdReal(registro._DBSecundaria);

            // Ens saltem les bases de dades que no existeixen
            if (string.IsNullOrEmpty(lcBdReal))
            {
                Log_comoffDto logDto = logRepository.GetDto(datos);
                logDto.TipoDato = lcTipoDato;
                logDto.Resultado = 3;
                logDto.Detalle = "No existe la base de datos " + registro._DBSecundaria + ".";
                logRepository.Insert(logDto);
            }
            else
            {
                if (_TextStepDetalle != "Revisando datos tabla " + registro._DBSecundaria + "!" + registro._TablaSecundaria)
                {
                    _TextStepDetalle = "Revisando datos tabla " + registro._DBSecundaria + "!" + registro._TablaSecundaria;
                }
         
                if (clsOfflineUtils.ExisteTablaOffline("[" + _cRaizDataBaseTemporal + registro._DBPrincipal + "].dbo.[" + registro._TablaPrincipal + registro._Sufijo + "]"))
                {
                    string lcSql = string.Empty;
                    string lcFiltrePrincipal = string.Empty;

                    lcSql = " FROM [" + lcBdReal + "].dbo." + registro._TablaSecundaria + " b " +
                            " INNER JOIN [" + _cRaizDataBaseTemporal + registro._DBPrincipal + "].dbo." + registro._TablaPrincipal + registro._Sufijo + " a " +
                            " ON " + ObtenerInnerOn(registro._DBPrincipal, registro._DBSecundaria, registro._TablaPrincipal, registro._TablaSecundaria, registro._Relacion, registro._Clave, datos, logRepository) +
                            " WHERE 1=1 ";

                    // Casos especiales
                    if (datos._EnvioArticulos && ((registro._DBPrincipal + "!" + registro._TablaPrincipal) == "GESTION!ARTICULO" || registro._Clave == "STOCKINI" || registro._Clave == "STOCKS"))
                    {
                        lcSql += Envio_Articulos_Sucursal(datos, registro._TablaSecundaria);
                    }

                    if (datos._IsCentral && registro._DBPrincipal + "!" + registro._TablaPrincipal == "COMUNES!LETRAS")
                    {
                        lcSql += Envio_Series_Sucursal(datos);
                    }

                    if (datos._IsCentral && registro._DBPrincipal + "!" + registro._TablaPrincipal == "TPV!CAJAS")
                    {
                        lcSql += Envio_Cajas_Sucursal(datos);
                    }

                    if (registro._DBPrincipal != registro._DBSecundaria || registro._TablaPrincipal != registro._TablaSecundaria)
                    {

                        if (!string.IsNullOrEmpty(registro._CondSecun))
                        {
                            lcFiltrePrincipal = registro._CondSecun;
                            lcFiltrePrincipal = lcFiltrePrincipal.Replace("{TABLA}", "b.");

                            lcSql = lcSql + " AND " + lcFiltrePrincipal;
                        }
                    }

                    if (!string.IsNullOrWhiteSpace(registro._CondEnv))
                    {
                        lcFiltrePrincipal = registro._CondEnv;
                        lcFiltrePrincipal = _offlineConfig.ConstruirFiltroAlmacen(lcFiltrePrincipal, tcSucursal, datos._Almacenes, registro._TablaSecundaria);
                        lcFiltrePrincipal = _offlineConfig.ConstruirFiltroLetra(lcFiltrePrincipal, tcSucursal, datos._Series);
                        lcFiltrePrincipal = _offlineConfig.ConstruirFiltroCaja(lcFiltrePrincipal, tcSucursal, datos._Cajas);

                        lcFiltrePrincipal = lcFiltrePrincipal.Replace("{TABLA}", "a.");

                        lcSql = lcSql + " AND " + lcFiltrePrincipal;
                    }

                    //Copiar només els registres de les empreses no excloses
                    clsOfflineUtils.RevisarTablasCampoEmpresa(registro._TablaPrincipal, ref lcCampoEmpresa);
                    if (!string.IsNullOrWhiteSpace(lcCampoEmpresa))
                    {
                        lcSql = lcSql + " AND a." + lcCampoEmpresa + " NOT IN (SELECT empresa FROM [" + datos._BdOffline + "].dbo.empexclu) ";
                    }

                    clsOfflineUtils.RevisarTablasCampoEmpresa(registro._TablaSecundaria, ref lcCampoEmpreSecun);
                    if (!string.IsNullOrWhiteSpace(lcCampoEmpreSecun))
                    {
                        lcSql = lcSql + " AND b." + lcCampoEmpreSecun + " NOT IN (SELECT empresa FROM [" + datos._BdOffline + "].dbo.empexclu) ";
                    }

                    DataTable ldtImagenes = new DataTable();
                    ActualizarDatosEnvio(item, datos, registro, tcSucursal, tlImagenes, dicTablas, dicDt, ref ldtImagenes, lcSql, logRepository);
                }

                // Gestionar la tabla DELETENET
                DataTable dtDelete = dicDt.FirstOrDefault(x => x.Key == "DELETENET").Value;

                if (datos._IsCentral ? Convert.ToBoolean(registro._Prioridad) : !Convert.ToBoolean(registro._Prioridad))
                {
                    if (datos._TipoCom == 2 || (datos._TipoCom == 1 && (registro._IdGrupo == 3 || registro._IdGrupo == 4)))
                    {
                        Gestionar_Tabla_DeleteNet(dtDelete, datos, registro._Nombre, dicDt, registro);
                    }
                }
            }
        }

        private static RegistroTabRel ComprobarFicheros(DataRow item)
        {
            RegistroTabRel registro = new RegistroTabRel();

            registro._DBPrincipal = string.Empty;
            registro._TablaPrincipal = string.Empty;

            registro._DBSecundaria = string.Empty;
            registro._TablaSecundaria = string.Empty;

            registro._Empresa = item.Field<string>("empresa").TrimEnd();
            
            
            registro._ID = item.Field<int>("id");
            registro._IdGrupo = item.Field<int>("idgrupo");
            registro._Clave = item.Field<string>("clave").TrimEnd();
            registro._Nombre = item.Field<string>("nombre").TrimEnd();
            registro._Prioridad = Convert.ToInt32(item.Field<bool>("prioridad"));
            registro._Titulo = item.Field<string>("titulo").TrimEnd().ToUpper();

            registro._CondEnv = item.Field<string>("condenv").TrimEnd().ToUpper();
            registro._CondSecun = item.Field<string>("condsecun").TrimEnd().ToUpper();
            registro._CondCtrl = item.Field<string>("condctrl").TrimEnd().ToUpper();
            registro._NombreTablaCtrl = item.Field<string>("tablactrl").TrimEnd().ToUpper();

            if (!string.IsNullOrWhiteSpace(item.Field<string>("principal")))
            {
                string[] subPos = item.Field<string>("principal").TrimEnd().Split('!');
                if (subPos.Length == 2)
                {
                    registro._DBPrincipal = subPos[0].TrimEnd();
                    registro._TablaPrincipal = subPos[1].TrimEnd();
                }
            }

            // taula secundaria
            if (!string.IsNullOrWhiteSpace(item.Field<string>("nombre")))
            {
                string[] subPos = item.Field<string>("nombre").TrimEnd().Split('!');
                if (subPos.Length == 2)
                {
                    registro._DBSecundaria = subPos[0].TrimEnd();
                    registro._TablaSecundaria = subPos[1].TrimEnd();
                }
            }

            if (!string.IsNullOrWhiteSpace(item.Field<string>("tablactrl")))
            {
                string[] subPos = item.Field<string>("tablactrl").TrimEnd().Split('!');
                if (subPos.Length == 2)
                {
                    registro._DBCondCtrl = subPos[0].TrimEnd();
                    registro._TablaCondCtrl = subPos[1].TrimEnd();
                }
            }

            registro._Sufijo = "_CREATED";
            registro._TipoTabla = item.Field<int>("tipotabla");

            registro._Asientos = item.Field<string>("asientos").TrimEnd();
            registro._Otrasien = item.Field<string>("otrasien").TrimEnd();
            registro._Eos = item.Field<string>("eos").TrimEnd();
            registro._Iva_exen = item.Field<string>("iva_exen").TrimEnd();
            registro._Ivasopor = item.Field<string>("ivasopor").TrimEnd();
            registro._Ivareper = item.Field<string>("ivareper").TrimEnd();
            registro._Retsopor = item.Field<string>("retsopor").TrimEnd();
            registro._Retreper = item.Field<string>("retreper").TrimEnd();
            registro._Compras = item.Field<string>("compras").TrimEnd();
            registro._Relacion = item.Field<string>("relacion").TrimEnd();
            registro._RelaCtrl = item.Field<string>("relactrl").TrimEnd();

            return registro;
        }

        private static void ActualizarDatosEnvio(DataRow item, OfflineDatosComunicaciones datos, RegistroTabRel registro, string tcSucursal, bool tlImagenes, Dictionary<string, bool> dicTablas, Dictionary<string, DataTable> dicDt, ref DataTable ldtImagenes, string lcSql, ILog_comoffRepository logRepository)
        {
            bool llPrioridad = (datos._IsCentral && Convert.ToBoolean(registro._Prioridad) || !datos._IsCentral && !Convert.ToBoolean(registro._Prioridad));

            if (llPrioridad || (registro._Clave == "FACTURAS" || registro._Clave == "FACTURAC" || registro._TablaSecundaria == "ENTREGAS"))
            {
                registro._Sufijo = "_MODIFIED";

                ProcesoActualizarDatos(item, datos, registro, tcSucursal, tlImagenes, dicTablas, dicDt, ref ldtImagenes, lcSql, logRepository);
            }

            registro._Sufijo = "_CREATED";

            ProcesoActualizarDatos(item, datos, registro, tcSucursal, tlImagenes, dicTablas, dicDt, ref ldtImagenes, lcSql, logRepository);
        }

        private static void ProcesoActualizarDatos(DataRow item, OfflineDatosComunicaciones datos, RegistroTabRel registro, string tcSucursal, bool tlImagenes, Dictionary<string, bool> dicTablas, Dictionary<string, DataTable> dicDt, ref DataTable ldtImagenes, string tcSql, ILog_comoffRepository logRepository)
        {
            string lcSqlCondicion = string.Empty;
            DataTable dtDatos = new DataTable();

            Dictionary<string, object> tablaSucursales = DB.SQLREGValor("SUCURSALES", "CODIGO", tcSucursal, "OFFLINE");

            string lcBdReal = clsOfflineUtils.ObtenerNombreBdReal(registro._DBSecundaria);
            string lcTipoDato = clsOfflineUtils.ObtenerTipoDato(registro._Clave);
            string lcAlias = ProcesoActualizarDatos_Alias(datos, registro);

            if (registro._Sufijo == "_MODIFIED")
            {
                string lcSufijo = string.Empty;
                string[] subPos = registro._Sufijo.Split('_');

                if (subPos.Length == 2)
                {
                    lcSufijo = subPos[1].TrimEnd();
                }

                lcSqlCondicion = " AND " + lcAlias + lcSufijo + " >= " + DB.SQLString(datos._FechaInicial) + " AND " + lcAlias + lcSufijo + " <= " + DB.SQLString(datos._FechaFinal);
                lcSqlCondicion += " AND (" + lcAlias + "CREATED < " + DB.SQLString(datos._FechaInicial) + " OR " + lcAlias + "CREATED > " + DB.SQLString(datos._FechaFinal) + ")";
            }
            else
            {
                lcSqlCondicion = " AND " + lcAlias + "CREATED >= " + DB.SQLString(datos._FechaInicial) + " AND " + lcAlias + "CREATED <= " + DB.SQLString(datos._FechaFinal);
            }

            string lcSql = " SELECT b.* " + tcSql + lcSqlCondicion;

            if (!DB.SQLExec(lcSql, ref dtDatos))
            {
                Log_comoffDto logDto = logRepository.GetDto(datos);
                logDto.TipoDato = lcTipoDato;
                logDto.Resultado = 3;
                logDto.Detalle = "No se ha podido ejecutar la instrucción " + lcSql + ".";
                logRepository.Insert(logDto);
            }
            else
            {
                if (dtDatos.Rows.Count > 0)
                {
                    RegistroDatos(datos, item, lcBdReal, registro._DBSecundaria, registro._TablaSecundaria, dtDatos, registro._Sufijo, logRepository);
                    dicTablas[item[0].ToString()] = true;

                    if (clsOfflineUtils.ExisteTablaOffline("[" + _cRaizDataBaseTemporal + registro._DBSecundaria + "].dbo.[" + registro._TablaSecundaria + registro._Sufijo + "]"))
                    {
                        InsertarDatosBulkMode(dtDatos, "[" + _cRaizDataBaseTemporal + registro._DBSecundaria + "].dbo.[" + registro._TablaSecundaria + registro._Sufijo + "]");
                    }
                    else
                    {
                        if (!clsOfflineUtils.ExisteDatabaseOffline(_cRaizDataBaseTemporal + registro._DBSecundaria))
                        {
                            CrearDataTable(registro._DBSecundaria, _cRaizDataBaseTemporal);
                        }

                        lcSql = " SELECT b.* INTO [" + _cRaizDataBaseTemporal + registro._DBSecundaria + "].dbo.[" + registro._TablaSecundaria + registro._Sufijo + "]" +
                                tcSql + lcSqlCondicion;
                        DB.SQLExec(lcSql);
                    }

                    ProcesoActualizarDatosEspecial(registro, datos, dicDt);
                }

                if (Revisar_Imagenes_Datos(tlImagenes, tablaSucursales, registro._TablaSecundaria, datos, ref dtDatos))
                {
                    // Actualizar el campo ULTFECENV en TABNETFEC
                    Actualizar_Ultima_Fecha_Envio(registro._ID);

                    // Gestionar la tabla de control
                    if (registro._Sufijo == "_CREATED")
                    {
                        Gestionar_Tabla_Control(dtDatos, datos, registro, Convert.ToBoolean(registro._Prioridad), registro._ID, lcTipoDato, item, dicTablas, logRepository);
                    }

                    // Enviar imagenes??
                    Seleccionar_Imagenes_Envio(tlImagenes, tablaSucursales, registro._TablaSecundaria, datos, ref ldtImagenes);
                }
            }
        }

        private static string ProcesoActualizarDatos_Alias(OfflineDatosComunicaciones datos, RegistroTabRel registro)
        {
            string lcAlias = "a.";

            if (datos._IsCentral && Convert.ToBoolean(registro._Prioridad) || !datos._IsCentral && !Convert.ToBoolean(registro._Prioridad))
            {
                lcAlias = "b.";
            }
            else
            {
                // Caso especial para las entregas de clientes
                if (registro._TablaPrincipal == "C_ALBVEN" && registro._TablaSecundaria == "ENTRE_CL" && !registro._Sobreescribir)
                {
                    lcAlias = "b.";
                }

                // Caso especial para las entregas de pedidos 
                if (registro._TablaPrincipal == "C_PEDIVE" && registro._TablaSecundaria == "ENTRE_PV" && !registro._Sobreescribir)
                {
                    lcAlias = "b.";
                }

                // Caso especial para las entregas de presupuestos
                if (registro._TablaPrincipal == "C_PRESUV" && registro._TablaSecundaria == "ENTRE_PR" && !registro._Sobreescribir)
                {
                    lcAlias = "b.";
                }
            }

            return lcAlias;
        }

        private static void TratamientoEspecial_RiesgoCliente(RegistroTabRel registro, OfflineDatosComunicaciones datos, Dictionary<string, DataTable> dicDt)
        {
            DataTable tablaDatos = new DataTable();
            string lcSql = string.Empty;

            DataTable dtActRiesgo = dicDt.FirstOrDefault(x => x.Key == "ACTRIESGO").Value;

            switch (registro._Clave)
            {
                case "C_PEDIVE":

                    if (registro._TablaPrincipal == "C_PEDIVE")
                    {
                        lcSql = " SELECT DISTINCT EMPRESA, CLIENTE AS CODIGO FROM [" + _cRaizDataBaseTemporal + registro._DBPrincipal + "].[dbo].[" + registro._TablaPrincipal + registro._Sufijo + "]";
                        DB.SQLExec(lcSql, ref tablaDatos);
                    }

                    break;

                case "C_ALBVEN":
                case "FACTURAS":
                case "TPVCONARQUEO":
                case "TPVSINARQUEO":

                    if (registro._TablaPrincipal == "C_ALBVEN")
                    {
                        lcSql = " SELECT DISTINCT EMPRESA, CLIENTE AS CODIGO FROM [" + _cRaizDataBaseTemporal + registro._DBPrincipal + "].[dbo].[" + registro._TablaPrincipal + registro._Sufijo + "]";
                        DB.SQLExec(lcSql, ref tablaDatos);
                    }

                    break;

                case "CLIENTES":

                    if (registro._TablaPrincipal == "CLIENTES")
                    {
                        lcSql = " SELECT DISTINCT B.EMPRESA, A.CODIGO " +
                                " FROM [" + _cRaizDataBaseTemporal + registro._DBPrincipal + "].[dbo].[" + registro._TablaPrincipal + registro._Sufijo + "]  A " +
                                " INNER JOIN " + DB.SQLDatabase("OFFLINE","ACTRIESGO") + " B ON A.CODIGO = B.CODIGO " +
                                " WHERE B.EMPRESA NOT IN (SELECT EMPRESA FROM " + DB.SQLDatabase("OFFLINE", "EMPEXCLU") + ")";

                        DB.SQLExec(lcSql, ref tablaDatos);
                    }

                    break;

                default:

                    break;
            }

            // Eliminamos la tabla que tenemos salvada en el diccionario y guardamos de nuevo actualizada
            if (tablaDatos != null && tablaDatos.Rows.Count > 0)
            {
                foreach (DataRow item in tablaDatos.Rows)
                {
                    var dataRow = dtActRiesgo.AsEnumerable().Where(dr => dr.Field<string>("empresa") == item.Field<string>("empresa") &&
                                                                        dr.Field<string>("codigo") == item.Field<string>("codigo"));
                    if (!dataRow.Any())
                    {
                        DataRow newRow = dtActRiesgo.NewRow();

                        newRow["empresa"] = item["empresa"];
                        newRow["codigo"] = item["codigo"];

                        dtActRiesgo.Rows.Add(newRow);
                    }
                }

                dicDt.Remove("ACTRIESGO");
                dicDt.Add("ACTRIESGO", dtActRiesgo);
            }
        }

        private static void ProcesoActualizarDatosEspecial(RegistroTabRel registro, OfflineDatosComunicaciones datos, Dictionary<string, DataTable> dicDt)
        {
            string lcSql = string.Empty;

            // buscar los registros de ASIENTOS afectados
            if (!string.IsNullOrWhiteSpace(registro._Asientos))
            {
                TratamientoEspecial_ASI(registro, "ASIENTOS", registro._Asientos);
                TratamientoEspecial_Asientos(registro, datos, true);
            }

            // buscar los registros de COMPRAS afectados
            if (!string.IsNullOrWhiteSpace(registro._Compras))
            {
                TratamientoEspecial_Compras(registro, datos);
            }

            if (!datos._IsCentral)
            {
                TratamientoEspecial_RiesgoCliente(registro, datos, dicDt);
            }

            // Si la taula secundaria és ASIENTOS, hem d'agafar tots el registres de cada assentament.
            switch (registro._TablaSecundaria)
            {
                case "ASIENTOS":

                    TratamientoEspecial_Asientos(registro, datos);

                    break;

                case "PREVIS":
                case "PREVI_CL":

                    TratamientoEspecial_Previsiones(registro, datos);

                    break;

                case "IVAREPER":
                case "IVASOPOR":

                    DataTable ldtDatosEOS = new DataTable();

                    lcSql = " SELECT A.* " +
                            " FROM " + DB.SQLDatabase("GESTION", "EOS") + " A " +
                            " INNER JOIN [" + _cRaizDataBaseTemporal + registro._DBSecundaria + "].dbo.[" + registro._TablaSecundaria + registro._Sufijo + "] B ON A.EMPRESA = B.EMPRESA AND A.ASIIVA = B.ASI ";

                    if (registro._TablaSecundaria == "IVAREPER")
                    {
                        lcSql = lcSql + " AND A.TIPO = 1 ";
                    }
                    else
                    {
                        lcSql = lcSql + " AND A.TIPO = 0 ";
                    }

                    DB.SQLExec(lcSql, ref ldtDatosEOS);

                    if (ldtDatosEOS != null && ldtDatosEOS.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "EOS");

                        InsertarDatosBulkMode(ldtDatosEOS, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "EOS" + registro._Sufijo + "]");
                    }

                    break;

                case "IVACJSOPOR":
                case "IVACJREPER":

                    TratamientoEspecial_CriterioCaja(registro, datos);

                    break;

                case "D_PROD":
                case "D_TRANS":
                case "D_PARTES":
                    TratamientoEspecial_EnvioFabricacion(registro, datos);
                    break;

                case "C_PARTES":
                    break;

                case "D_PEDIVE":

                    TratamientoEspecial_PedidosVenta(registro, datos);
                    break;

                case "D_PEDICO":

                    TratamientoEspecial_PedidosCompra(registro, datos);
                    break;

                case "D_ALBDEP":

                    TratamientoEspecial_DepositosVenta(registro, datos);
                    break;

                case "D_DEPCOM":

                    TratamientoEspecial_DepositosCompra(registro, datos);
                    break;

                case "D_ALBVEN":

                    TratamientoEspecial_AlbaranesVenta(registro, datos);
                    break;

                case "D_ALBCOM":

                    TratamientoEspecial_AlbaranesCompra(registro, datos);
                    break;

                case "C_FACTUVEN":

                    TratamientoEspecial_FacturasVenta(registro, datos);
                    break;

                case "C_FACTUCOM":

                    TratamientoEspecial_FacturasCompra(registro, datos);
                    break;

                case "ACCESOGRUP":

                    TratamientoEspecial_AccesoGrup(registro, datos);
                    break;

                default:

                    break;
            }
        }

        private static void TratamientoEspecial_AccesoGrup(RegistroTabRel registro, OfflineDatosComunicaciones datos)
        {
            string lcSql = string.Empty;
            string lcGrupo = GrupoEmpresa._CodigoGrupoActual().ToString().Trim();

            lcSql = " Delete From [" + _cRaizDataBaseTemporal + registro._DBSecundaria + "].dbo." + registro._TablaSecundaria + registro._Sufijo + " " +
                    " Where grupo != " + DB.SQLString(lcGrupo);

            // Executem la consulta
            DB.SQLExec(lcSql);
        }

        private static void TratamientoEspecial_PedidosVenta(RegistroTabRel registro, OfflineDatosComunicaciones datos)
        {
            // Se debe modificar el proceso de envío para realizar una excepción cuando se haga envío sin prioridad (solo enviamos datos nuevos) 
            // para que enviemos la modificación de datos del documento origen.
            if (!registro._Sobreescribir && registro._DBPrincipal == "GESTION")
            {
                DataTable ldtDatosRelacionados = new DataTable();
                string lcSql = string.Empty;

                // buscar documento asociado a la linea del albarán
                lcSql = " SELECT DISTINCT empresa, doc_num, doc_lin " +
                        " FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].[dbo].[D_PEDIVE" + registro._Sufijo + "]" +
                        " WHERE DOC = 3 ";
                DB.SQLExec(lcSql, ref ldtDatosRelacionados);

                foreach (DataRow item in ldtDatosRelacionados.Rows)
                {
                    DataTable ldtDatos = new DataTable();
                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "C_PRESUV") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND NUMERO + LETRA = " + DB.SQLString(item.Field<string>("doc_num"));
                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "C_PRESUV", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "C_PRESUV" + "_ESPECIAL" + "]");
                    }

                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "D_PRESUV") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND NUMERO + LETRA = " + DB.SQLString(item.Field<string>("doc_num")) +
                            " AND LINIA = " + DB.SQLString(item.Field<int>("doc_lin"));

                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "D_PRESUV", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "D_PRESUV" + "_ESPECIAL" + "]");
                    }
                }
            }
        }

        private static void TratamientoEspecial_PedidosCompra(RegistroTabRel registro, OfflineDatosComunicaciones datos)
        {
            // Se debe modificar el proceso de envío para realizar una excepción cuando se haga envío sin prioridad (solo enviamos datos nuevos) 
            // para que enviemos la modificación de datos del documento origen.
            if (!registro._Sobreescribir && registro._DBPrincipal == "GESTION")
            {
                // No hay nada que hacer
            }
        }

        private static void TratamientoEspecial_DepositosVenta(RegistroTabRel registro, OfflineDatosComunicaciones datos)
        {
            // Se debe modificar el proceso de envío para realizar una excepción cuando se haga envío sin prioridad (solo enviamos datos nuevos) 
            // para que enviemos la modificación de datos del documento origen.
            if (!registro._Sobreescribir && registro._DBPrincipal == "GESTION")
            {
                DataTable ldtDatosRelacionados = new DataTable();
                string lcSql = string.Empty;

                // buscar documento asociado a la linea del albarán
                lcSql = " SELECT DISTINCT empresa, doc_num, doc_lin " +
                        " FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].[dbo].[D_ALBDEP" + registro._Sufijo + "]" +
                        " WHERE DOC = 1 ";
                DB.SQLExec(lcSql, ref ldtDatosRelacionados);

                foreach (DataRow item in ldtDatosRelacionados.Rows)
                {
                    DataTable ldtDatos = new DataTable();
                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "C_PEDIVE") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND NUMERO + LETRA = " + DB.SQLString(item.Field<string>("doc_num"));
                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "C_PEDIVE", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "C_PEDIVE" + "_ESPECIAL" + "]");
                    }

                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "D_PEDIVE") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND NUMERO + LETRA = " + DB.SQLString(item.Field<string>("doc_num")) +
                            " AND LINIA = " + DB.SQLString(item.Field<int>("doc_lin"));

                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "D_PEDIVE", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "D_PEDIVE" + "_ESPECIAL" + "]");
                    }
                }

                // buscar documento asociado a la linea del albarán
                lcSql = " SELECT DISTINCT empresa, doc_num, doc_lin " +
                        " FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].[dbo].[D_ALBDEP" + registro._Sufijo + "]" +
                        " WHERE DOC = 2 ";
                DB.SQLExec(lcSql, ref ldtDatosRelacionados);

                foreach (DataRow item in ldtDatosRelacionados.Rows)
                {
                    DataTable ldtDatos = new DataTable();
                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "C_ALBDEP") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND NUMERO + LETRA = " + DB.SQLString(item.Field<string>("doc_num"));
                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "C_ALBDEP", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "C_ALBDEP" + "_ESPECIAL" + "]");
                    }

                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "D_ALBDEP") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND NUMERO + LETRA = " + DB.SQLString(item.Field<string>("doc_num")) +
                            " AND LINIA = " + DB.SQLString(item.Field<int>("doc_lin"));

                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "D_ALBDEP", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "D_ALBDEP" + "_ESPECIAL" + "]");
                    }
                }
            }
        }

        private static void TratamientoEspecial_DepositosCompra(RegistroTabRel registro, OfflineDatosComunicaciones datos)
        {
            // Se debe modificar el proceso de envío para realizar una excepción cuando se haga envío sin prioridad (solo enviamos datos nuevos) 
            // para que enviemos la modificación de datos del documento origen.
            if (!registro._Sobreescribir && registro._DBPrincipal == "GESTION")
            {
                DataTable ldtDatosRelacionados = new DataTable();
                string lcSql = string.Empty;

                // buscar documento asociado a la linea del albarán
                lcSql = " SELECT DISTINCT empresa, doc_num, doc_lin " +
                        " FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].[dbo].[D_DEPCOM" + registro._Sufijo + "]" +
                        " WHERE DOC = 1 ";
                DB.SQLExec(lcSql, ref ldtDatosRelacionados);

                foreach (DataRow item in ldtDatosRelacionados.Rows)
                {
                    DataTable ldtDatos = new DataTable();
                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "C_PEDICO") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND NUMERO = " + DB.SQLString(item.Field<string>("doc_num"));
                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "C_PEDICO", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "C_PEDICO" + "_ESPECIAL" + "]");
                    }

                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "D_PEDICO") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND NUMERO = " + DB.SQLString(item.Field<string>("doc_num")) +
                            " AND LINIA = " + DB.SQLString(item.Field<int>("doc_lin"));

                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "D_PEDICO", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "D_PEDICO" + "_ESPECIAL" + "]");
                    }
                }

                // buscar documento asociado a la linea del albarán
                lcSql = " SELECT DISTINCT empresa, doc_num, doc_lin " +
                        " FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].[dbo].[D_DEPCOM" + registro._Sufijo + "]" +
                        " WHERE DOC = 3 ";
                DB.SQLExec(lcSql, ref ldtDatosRelacionados);

                foreach (DataRow item in ldtDatosRelacionados.Rows)
                {
                    DataTable ldtDatos = new DataTable();
                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "C_DEPCOM") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND NUMERO = " + DB.SQLString(item.Field<string>("doc_num"));
                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "C_DEPCOM", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "C_DEPCOM" + "_ESPECIAL" + "]");
                    }

                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "D_DEPCOM") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND NUMERO = " + DB.SQLString(item.Field<string>("doc_num")) +
                            " AND LINIA = " + DB.SQLString(item.Field<int>("doc_lin"));

                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "D_DEPCOM", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "D_DEPCOM" + "_ESPECIAL" + "]");
                    }
                }
            }
        }


        private static void TratamientoEspecial_AlbaranesVenta(RegistroTabRel registro, OfflineDatosComunicaciones datos)
        {
            // Se debe modificar el proceso de envío para realizar una excepción cuando se haga envío sin prioridad (solo enviamos datos nuevos) 
            // para que enviemos la modificación de datos del documento origen.
            if (!registro._Sobreescribir && registro._DBSecundaria == "GESTION")
            {
                DataTable ldtDatosRelacionados = new DataTable();
                string lcSql = string.Empty;

                // buscar documento asociado a la linea del albarán
                lcSql = " SELECT DISTINCT empresa, doc_num, doc_lin " +
                        " FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].[dbo].[D_ALBVEN" + registro._Sufijo + "]" +
                        " WHERE DOC = 1 ";
                DB.SQLExec(lcSql, ref ldtDatosRelacionados);

                foreach (DataRow item in ldtDatosRelacionados.Rows)
                {
                    DataTable ldtDatos = new DataTable();
                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "C_PEDIVE") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND NUMERO + LETRA = " + DB.SQLString(item.Field<string>("doc_num"));
                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "C_PEDIVE", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "C_PEDIVE" + "_ESPECIAL" + "]");
                    }

                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "D_PEDIVE") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND NUMERO + LETRA = " + DB.SQLString(item.Field<string>("doc_num")) +
                            " AND LINIA = " + DB.SQLString(item.Field<int>("doc_lin"));

                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "D_PEDIVE", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "D_PEDIVE" + "_ESPECIAL" + "]");
                    }
                }

                // buscar documento asociado a la linea del albarán
                lcSql = " SELECT DISTINCT empresa, doc_num, doc_lin " +
                        " FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].[dbo].[D_ALBVEN" + registro._Sufijo + "]" +
                        " WHERE DOC = 2 ";
                DB.SQLExec(lcSql, ref ldtDatosRelacionados);

                foreach (DataRow item in ldtDatosRelacionados.Rows)
                {
                    DataTable ldtDatos = new DataTable();
                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "C_ALBDEP") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND NUMERO + LETRA = " + DB.SQLString(item.Field<string>("doc_num"));
                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "C_ALBDEP", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "C_ALBDEP" + "_ESPECIAL" + "]");
                    }

                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "D_ALBDEP") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND NUMERO + LETRA = " + DB.SQLString(item.Field<string>("doc_num")) +
                            " AND LINIA = " + DB.SQLString(item.Field<int>("doc_lin"));

                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "D_ALBDEP", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "D_ALBDEP" + "_ESPECIAL" + "]");
                    }
                }

                // buscar documento asociado a la linea del albarán
                lcSql = " SELECT DISTINCT empresa, doc_num, doc_lin " +
                        " FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].[dbo].[D_ALBVEN" + registro._Sufijo + "]" +
                        " WHERE DOC = 3 ";
                DB.SQLExec(lcSql, ref ldtDatosRelacionados);

                foreach (DataRow item in ldtDatosRelacionados.Rows)
                {
                    DataTable ldtDatos = new DataTable();
                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "C_PRESUV") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND NUMERO + LETRA = " + DB.SQLString(item.Field<string>("doc_num"));
                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "C_PRESUV", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "C_PRESUV" + "_ESPECIAL" + "]");
                    }

                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "D_PRESUV") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND NUMERO + LETRA = " + DB.SQLString(item.Field<string>("doc_num")) +
                            " AND LINIA = " + DB.SQLString(item.Field<int>("doc_lin"));

                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "D_PRESUV", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "D_PRESUV" + "_ESPECIAL" + "]");
                    }
                }
            }
        }

        private static void TratamientoEspecial_AlbaranesCompra(RegistroTabRel registro, OfflineDatosComunicaciones datos)
        {
            // Se debe modificar el proceso de envío para realizar una excepción cuando se haga envío sin prioridad (solo enviamos datos nuevos) 
            // para que enviemos la modificación de datos del documento origen.
            if (!registro._Sobreescribir && registro._DBSecundaria == "GESTION")
            {
                DataTable ldtDatosRelacionados = new DataTable();
                string lcSql = string.Empty;

                // buscar documento asociado a la linea del albarán
                lcSql = " SELECT DISTINCT empresa, doc_num, doc_lin " +
                        " FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].[dbo].[D_ALBCOM" + registro._Sufijo + "]" +
                        " WHERE DOC = 1 ";
                DB.SQLExec(lcSql, ref ldtDatosRelacionados);

                foreach (DataRow item in ldtDatosRelacionados.Rows)
                {
                    DataTable ldtDatos = new DataTable();
                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "C_PEDICO") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND NUMERO = " + DB.SQLString(item.Field<string>("doc_num"));
                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "C_PEDICO", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "C_PEDICO" + "_ESPECIAL" + "]");
                    }

                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "D_PEDICO") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND NUMERO = " + DB.SQLString(item.Field<string>("doc_num")) +
                            " AND LINIA = " + DB.SQLString(item.Field<int>("doc_lin"));

                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "D_PEDICO", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "D_PEDICO" + "_ESPECIAL" + "]");
                    }
                }

                // buscar documento asociado a la linea del albarán
                lcSql = " SELECT DISTINCT empresa, doc_num, doc_lin " +
                        " FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].[dbo].[D_ALBCOM" + registro._Sufijo + "]" +
                        " WHERE DOC = 3 ";
                DB.SQLExec(lcSql, ref ldtDatosRelacionados);

                foreach (DataRow item in ldtDatosRelacionados.Rows)
                {
                    DataTable ldtDatos = new DataTable();
                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "C_DEPCOM") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND NUMERO = " + DB.SQLString(item.Field<string>("doc_num"));
                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "C_DEPCOM", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "C_DEPCOM" + "_ESPECIAL" + "]");
                    }

                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "D_DEPCOM") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND NUMERO = " + DB.SQLString(item.Field<string>("doc_num")) +
                            " AND LINIA = " + DB.SQLString(item.Field<int>("doc_lin"));

                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "D_DEPCOM", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "D_DEPCOM" + "_ESPECIAL" + "]");
                    }
                }
            }
        }

        private static void TratamientoEspecial_FacturasVenta(RegistroTabRel registro, OfflineDatosComunicaciones datos)
        {
            // Se debe modificar el proceso de envío para realizar una excepción cuando se haga envío sin prioridad (solo enviamos datos nuevos) 
            // para que enviemos la modificación de datos del documento origen.
            if (!registro._Sobreescribir && registro._DBPrincipal == "GESTION")
            {
                DataTable ldtDatosRelacionados = new DataTable();
                string lcSql = string.Empty;

                // buscar documento asociado a la linea del albarán
                lcSql = " SELECT DISTINCT empresa, numero " +
                        " FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].[dbo].[C_FACTUVEN" + registro._Sufijo + "]";
                DB.SQLExec(lcSql, ref ldtDatosRelacionados);

                foreach (DataRow item in ldtDatosRelacionados.Rows)
                {
                    DataTable ldtDatos = new DataTable();
                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "C_ALBVEN") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND FACTURA = " + DB.SQLString(item.Field<string>("numero"));
                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "C_ALBVEN", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "C_ALBVEN" + "_ESPECIAL" + "]");
                    }
                }
            }
        }

        private static void TratamientoEspecial_FacturasCompra(RegistroTabRel registro, OfflineDatosComunicaciones datos)
        {
            // Se debe modificar el proceso de envío para realizar una excepción cuando se haga envío sin prioridad (solo enviamos datos nuevos) 
            // para que enviemos la modificación de datos del documento origen.
            if (!registro._Sobreescribir && registro._DBPrincipal == "GESTION")
            {
                DataTable ldtDatosRelacionados = new DataTable();
                string lcSql = string.Empty;

                // buscar documento asociado a la linea del albarán
                lcSql = " SELECT DISTINCT empresa, proveedor, numero " +
                        " FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].[dbo].[C_FACTUCOM" + registro._Sufijo + "]";
                DB.SQLExec(lcSql, ref ldtDatosRelacionados);

                foreach (DataRow item in ldtDatosRelacionados.Rows)
                {
                    DataTable ldtDatos = new DataTable();
                    lcSql = " SELECT * " +
                            " FROM " + DB.SQLDatabase("GESTION", "C_ALBCOM") +
                            " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                            " AND PROVEEDOR = " + DB.SQLString(item.Field<string>("proveedor")) +
                            " AND FACTURA = " + DB.SQLString(item.Field<string>("numero"));
                    DB.SQLExec(lcSql, ref ldtDatos);

                    if (ldtDatos != null && ldtDatos.Rows.Count > 0)
                    {
                        ComprobarTablaTemporalSQL(registro, "GESTION", "C_ALBCOM", "_ESPECIAL");

                        InsertarDatosBulkMode(ldtDatos, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "C_ALBCOM" + "_ESPECIAL" + "]");
                    }
                }
            }
        }

        private static void ComprobarTablaTemporalSQL(RegistroTabRel registro, string tcDb, string tcTable, string tcSufijo = "")
        {
            if (!clsOfflineUtils.ExisteDatabaseOffline(_cRaizDataBaseTemporal + tcDb))
            {
                CrearDataTable(tcDb, _cRaizDataBaseTemporal);
            }

            string lcSufijo = (!string.IsNullOrWhiteSpace(tcSufijo) ? tcSufijo : registro._Sufijo);

            if (!clsOfflineUtils.ExisteTablaOffline("[" + _cRaizDataBaseTemporal + tcDb + "].dbo.[" + tcTable + lcSufijo + "]"))
            {
                string lcSql = " Select * INTO [" + _cRaizDataBaseTemporal + tcDb + "].dbo.[" + tcTable + lcSufijo + "]" +
                            " From " + DB.SQLDatabase(tcDb, tcTable) + " as A Where 1 = 2 ";

                // Executem la consulta
                DB.SQLExec(lcSql);
            }
        }

        private static void TratamientoEspecial_Compras(RegistroTabRel registro, OfflineDatosComunicaciones datos)
        {
            string lcSql;
            DataTable ldtDatosCompras = new DataTable();

            if (clsOfflineUtils.ExisteTablaOffline("[" + _cRaizDataBaseTemporal + registro._DBSecundaria + "].dbo.[" + registro._TablaSecundaria + registro._Sufijo + "]"))
            {
                ComprobarTablaTemporalSQL(registro, "COMUNES", "COMPRAS");

                // Montem la consulta per agafar les línies dels assentaments
                lcSql = " SELECT A.* " +
                        " FROM " + DB.SQLDatabase("COMUNES", "COMPRAS") + " A " +
                        " INNER JOIN [" + _cRaizDataBaseTemporal + registro._DBPrincipal + "].dbo.[" + registro._TablaSecundaria + registro._Sufijo + "] B " +
                        " ON A.SERIE = B." + registro._Compras;

                // Executem la consulta
                DB.SQLExec(lcSql, ref ldtDatosCompras);

                if (ldtDatosCompras != null && ldtDatosCompras.Rows.Count > 0)
                {
                    InsertarDatosBulkMode(ldtDatosCompras, "[" + _cRaizDataBaseTemporal + "COMUNES].dbo.[COMPRAS" + registro._Sufijo + "]");
                }
            }
        }

        private static void TratamientoEspecial_Asientos(RegistroTabRel registro, OfflineDatosComunicaciones datos, bool tlForzar = false)
        {
            string lcSql;
            DataTable ldtDatosAsientos = new DataTable();

            ComprobarTablaTemporalSQL(registro, "GESTION", "ASIENTOS");

            // Montem la consulta per agafar les línies dels assentaments
            lcSql = " SELECT DISTINCT A.* " +
                    " FROM " + DB.SQLDatabase("GESTION", "ASIENTOS") + " A " +
                    " INNER JOIN [" + _cRaizDataBaseTemporal + "GESTION].dbo.[ASIENTOS" + registro._Sufijo + "] B " +
                    " ON A.EMPRESA=B.EMPRESA And A.NUMERO=B.NUMERO ";

            // Executem la consulta
            DB.SQLExec(lcSql, ref ldtDatosAsientos);

            if (ldtDatosAsientos != null && ldtDatosAsientos.Rows.Count > 0)
            {
                DB.SQLExec("DELETE FROM [" + _cRaizDataBaseTemporal + "GESTION].dbo.[ASIENTOS" + registro._Sufijo + "] WHERE 1 = 1 ");

                InsertarDatosBulkMode(ldtDatosAsientos, "[" + _cRaizDataBaseTemporal + "GESTION].dbo.[ASIENTOS" + registro._Sufijo + "]");

                if (!clsOfflineUtils.ExisteTablaOffline("[" + _cRaizDataBaseTemporal + "OFFLINE" + "].dbo.[" + "CTRL_ASIEN" + registro._Sufijo + "]"))
                {
                    if (!clsOfflineUtils.ExisteDatabaseOffline(_cRaizDataBaseTemporal + "OFFLINE"))
                    {
                        CrearDataTable("OFFLINE", _cRaizDataBaseTemporal);
                    }

                    lcSql = " SELECT * INTO [" + _cRaizDataBaseTemporal + "OFFLINE" + "].dbo.[" + "CTRL_ASIEN" + registro._Sufijo + "]" +
                            " FROM [" + datos._BdOffline + "].dbo.[" + "CTRL_ASIEN" + "] WHERE 1 = 2";
             
                    DB.SQLExec(lcSql);
                }

                // Actualizar tabla de control
                Actualizar_Tabla_Control(ldtDatosAsientos, "GESTION!ASIENTOS", "CTRL_ASIEN", registro._ID, datos);

                if (tlForzar)
                {
                    string lcAny = EW_GLOBAL._GetVariable("wc_any").ToString();
                    string lcSet = " Set ORIGEN = " + (datos._IsCentral ? DB.SQLString("CENTRAL") : DB.SQLString(datos._Sucursal)) + ", MODIFIED = " + DB.SQLString(DateTime.Now);
                    string lcOrigen = (datos._IsCentral ? "CENTRAL" : datos._Sucursal);

                    foreach (DataRow item in ldtDatosAsientos.Rows)
                    {
                        string lcWhere = " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                                        " AND NUMERO = " + DB.SQLString(item.Field<int>("numero")) +
                                        " AND LINEA = " + DB.SQLString(item.Field<int>("linea")) +
                                        " AND EJERCICIO = " + DB.SQLString(lcAny);

                        string lcInsert = "(EMPRESA, NUMERO, LINEA, EJERCICIO, ORIGEN, IDTABREL, GUID_ID, CREATED, MODIFIED, VISTA) " +
                                        "Values(" +
                                            DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<int>("numero")) + ", " + DB.SQLString(item.Field<int>("linea")) + ", " +
                                            DB.SQLString(lcAny) + ", " + DB.SQLString(lcOrigen) + ", " + DB.SQLString(registro._ID) + ", NEWID(), GETDATE(), GETDATE(), cast(1 as bit))";

                        ComprobarTablaTemporalSQL(registro, "OFFLINE", "CTRL_ASIEN");

                        lcSql = " IF EXISTS " + Environment.NewLine +
                                        " ( SELECT NUMERO FROM [" + _cRaizDataBaseTemporal + "OFFLINE].dbo.[CTRL_ASIEN" + registro._Sufijo + "] " + lcWhere + " ) " + Environment.NewLine +
                                        " BEGIN " + Environment.NewLine +
                                                " Update [" + _cRaizDataBaseTemporal + "OFFLINE].dbo.[CTRL_ASIEN" + registro._Sufijo + "] " + lcSet + lcWhere + Environment.NewLine +
                                        " END " + Environment.NewLine +
                                        " ELSE " + Environment.NewLine +
                                        " BEGIN" + Environment.NewLine +
                                                "Insert Into [" + _cRaizDataBaseTemporal + "OFFLINE].dbo.[CTRL_ASIEN" + registro._Sufijo + "] " + lcInsert +
                                        " END ";

                        DB.SQLExec(lcSql);
                    }
                }
            }

            TratamientoEspecialTablas(registro);
        }

        private static void TratamientoEspecialTablas(RegistroTabRel registro)
        {
            // buscar ASI en las tablas relacionadas
            if (!string.IsNullOrWhiteSpace(registro._Otrasien))
            {
                TratamientoEspecial_ASI(registro, "OTRASIEN", registro._Otrasien);
            }

            if (!string.IsNullOrWhiteSpace(registro._Ivareper))
            {
                TratamientoEspecial_ASI(registro, "IVAREPER", registro._Ivareper);
            }

            if (!string.IsNullOrWhiteSpace(registro._Ivasopor))
            {
                TratamientoEspecial_ASI(registro, "IVASOPOR", registro._Ivasopor);
            }

            if (!string.IsNullOrWhiteSpace(registro._Iva_exen))
            {
                TratamientoEspecial_ASI(registro, "IVA_EXEN", registro._Iva_exen);
            }

            if (!string.IsNullOrWhiteSpace(registro._Retreper))
            {
                TratamientoEspecial_ASI(registro, "RETREPER", registro._Retreper);
            }

            if (!string.IsNullOrWhiteSpace(registro._Retsopor))
            {
                TratamientoEspecial_ASI(registro, "RETSOPOR", registro._Retsopor);
            }

            if (!string.IsNullOrWhiteSpace(registro._Eos))
            {
                TratamientoEspecial_ASI(registro, "EOS", registro._Eos);
            }
        }

        private static void ProcesoActualizarControlEspecial(RegistroTabRel registro, string tcTablaControl, OfflineDatosComunicaciones datos)
        {
            // Si la taula secundaria és ASIENTOS, hem d'agafar tots el registres de cada assentament.
            switch (tcTablaControl)
            {
                case "CTRL_ASIEN":

                    DataTable ldtDatosAsientos = new DataTable();
                    string lcSql = string.Empty;

                    ComprobarTablaTemporalSQL(registro, "OFFLINE", tcTablaControl);

                    // Montem la consulta per agafar les línies dels assentaments
                    lcSql = " SELECT DISTINCT A.* " +
                            " FROM " + DB.SQLDatabase("OFFLINE", tcTablaControl) + " A " +
                            " INNER JOIN [" + _cRaizDataBaseTemporal + "OFFLINE" + "].dbo.[" + tcTablaControl + registro._Sufijo + "] B " +
                            " ON A.EMPRESA=B.EMPRESA And A.NUMERO=B.NUMERO ";

                    // Executem la consulta
                    DB.SQLExec(lcSql, ref ldtDatosAsientos);

                    if (ldtDatosAsientos != null && ldtDatosAsientos.Rows.Count > 0)
                    {
                        DB.SQLExec("DELETE FROM [" + _cRaizDataBaseTemporal + "OFFLINE" + "].dbo.[" + tcTablaControl + registro._Sufijo + "] WHERE 1 = 1 ");

                        InsertarDatosBulkMode(ldtDatosAsientos, "[" + _cRaizDataBaseTemporal + "OFFLINE" + "].dbo.[" + tcTablaControl + registro._Sufijo + "]");
                    }

                    break;

                default:
                
                    break;


            }
        }

        private static void TratamientoEspecial_ASI(RegistroTabRel registro, string tcTabla, string tcCampo)
        {
            DataTable ldtDatosASI = new DataTable();
            string lcSql = string.Empty;

            lcSql = " Select A.* " +
                    " From " + DB.SQLDatabase("GESTION", tcTabla) + " as a " +
                    " Inner Join ( Select a.empresa, a.asi " +
                                 " From " + DB.SQLDatabase("GESTION", "ASIENTOS") + " as a " +
                                 " Inner Join ( Select b.empresa, b.numero " +
                                              " From [" + _cRaizDataBaseTemporal + registro._DBSecundaria + "].dbo." + registro._TablaSecundaria + registro._Sufijo + " as a " +
                                              " Inner Join " + DB.SQLDatabase("GESTION", "ASIENTOS") + " b ON a.EMPRESA = b.EMPRESA And a." + tcCampo + " = b.ASI " +
                                            " ) b ON a.EMPRESA = b.EMPRESA And a.NUMERO = b.NUMERO " +
                               " ) b ON a.EMPRESA = b.EMPRESA And a.ASI = b.ASI ";


            // Executem la consulta
            DB.SQLExec(lcSql, ref ldtDatosASI);

            if (ldtDatosASI != null && ldtDatosASI.Rows.Count > 0)
            {
                ComprobarTablaTemporalSQL(registro, "GESTION", tcTabla);

                InsertarDatosBulkMode(ldtDatosASI, "[" + _cRaizDataBaseTemporal + "GESTION].dbo.[" + tcTabla + registro._Sufijo + "]");
            }
        }

        private static void TratamientoEspecial_Previsiones(RegistroTabRel registro, OfflineDatosComunicaciones datos)
        {
            DataTable ldtDatosPrevisiones = new DataTable();
            string lcSql = string.Empty;


            lcSql = " Select DISTINCT A.* " +
                    " From " + DB.SQLDatabase("GESTION", "ASIENTOS") + " as A " +
                    " Where Exists ( " +
                                    " Select B.* " +
                                    " From [" + _cRaizDataBaseTemporal + registro._DBSecundaria + "].dbo." + registro._TablaSecundaria + registro._Sufijo + " as B " +
                                    " Where A.EMPRESA=B.EMPRESA And A.ASI=B.ASI )";

            // Executem la consulta
            DB.SQLExec(lcSql, ref ldtDatosPrevisiones);

            if (ldtDatosPrevisiones != null && ldtDatosPrevisiones.Rows.Count > 0)
            {
                ComprobarTablaTemporalSQL(registro, "GESTION", "ASIENTOS");

                InsertarDatosBulkMode(ldtDatosPrevisiones, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "ASIENTOS" + registro._Sufijo + "]");

                TratamientoEspecial_Asientos(registro, datos, true);
            }


            DataTable ldtDatosIva = new DataTable();
            string lcTabla = (registro._TablaSecundaria == "PREVIS" ? "IVASOPOR" : "IVAREPER");

            if (clsOfflineUtils.ExisteTablaOffline("[" + _cRaizDataBaseTemporal + "GESTION].dbo.[" + lcTabla + registro._Sufijo + "]"))
            {
                lcSql = " Select A.* " +
                        " From " + DB.SQLDatabase("GESTION", lcTabla) + " as A " +
                        " Where Exists ( " +
                                        " Select B.* " +
                                        " From [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo." + lcTabla + registro._Sufijo + " as B " +
                                        " Where A.EMPRESA=B.EMPRESA And A.ASI = B.ASI )";

                // Executem la consulta
                DB.SQLExec(lcSql, ref ldtDatosIva);

                if (ldtDatosIva != null && ldtDatosIva.Rows.Count > 0)
                {
                    ComprobarTablaTemporalSQL(registro, "GESTION", lcTabla);

                    InsertarDatosBulkMode(ldtDatosIva, "[" + _cRaizDataBaseTemporal + "GESTION].dbo.[" + lcTabla + registro._Sufijo + "]");
                }
            }
        }

        private static void TratamientoEspecial_CriterioCaja(RegistroTabRel registro, OfflineDatosComunicaciones datos)
        {
            TratamientoEspecial_CriterioCaja(registro, datos, "ASI");
            TratamientoEspecial_CriterioCaja(registro, datos, "ASI_IVA");
            TratamientoEspecial_CriterioCaja(registro, datos, "ASIRECC");
        }

        private static void TratamientoEspecial_CriterioCaja(RegistroTabRel registro, OfflineDatosComunicaciones datos, string lcCampo)
        {
            DataTable ldtDatosPrevisiones = new DataTable();
            string lcSql = string.Empty;

            lcSql = " Select DISTINCT A.* " +
                    " From " + DB.SQLDatabase("GESTION", "ASIENTOS") + " as A " +
                    " Where Exists ( " +
                                    " Select B.* " +
                                    " From [" + _cRaizDataBaseTemporal + registro._DBSecundaria + "].dbo." + registro._TablaSecundaria + registro._Sufijo + " as B " +
                                    " Where A.EMPRESA=B.EMPRESA And A.ASI=B." + lcCampo + " )";

            // Executem la consulta
            DB.SQLExec(lcSql, ref ldtDatosPrevisiones);

            if (ldtDatosPrevisiones != null && ldtDatosPrevisiones.Rows.Count > 0)
            {
                ComprobarTablaTemporalSQL(registro, "GESTION", "ASIENTOS");

                InsertarDatosBulkMode(ldtDatosPrevisiones, "[" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "ASIENTOS" + registro._Sufijo + "]");

                TratamientoEspecial_Asientos(registro, datos, true);
            }
        }

        private static void CrearDataTable(string tcDB, string tcArrelDB)
        {
            string lcDataBaseTemp = tcArrelDB + tcDB;

            DB._DBCreate(lcDataBaseTemp);
        }

        private static void CrearDataTable(string tcDB, string tcArrelDB, RegistroTabRel registro)
        {
            string lcDataBaseTemp = tcArrelDB + tcDB;
            string lcRutaTemp = Path.Combine(TempFolderName, tcDB);

            DB._DBCreate(lcDataBaseTemp);

            string lcBdReal = clsOfflineUtils.ObtenerNombreBdReal(registro._DBSecundaria);

            // tinc que comprovar si existeix
            if (Directory.Exists(lcRutaTemp))
            {
                DB._DBCreate(lcDataBaseTemp);

                DB.SQLExec("DROP TABLE IF EXISTS [" + lcDataBaseTemp + "].dbo.[" + registro._TablaSecundaria + registro._Sufijo + "]");

                
                DB.SQLExec("SELECT * INTO [" + lcDataBaseTemp + "].dbo.[" + registro._TablaSecundaria + registro._Sufijo + "]" +
                    " FROM [" + lcBdReal + "].dbo.[" + registro._TablaSecundaria + "] WHERE 1 = 2");
            }
        }

        private static void InsertarTablaBaseDatosBulk(string tcDB, string tcArrelDB, RegistroTabRel registro, DataTable dtDatos)
        {
            string lcDataBaseTemp = tcArrelDB + tcDB;
            string lcRutaTemp = Path.Combine(TempFolderName, tcDB);

            // tinc que comprovar si existeix
            if (Directory.Exists(lcRutaTemp))
            {
                //Inertamos con BulkCopy
                using (System.Data.SqlClient.SqlBulkCopy bulkCopy = new System.Data.SqlClient.SqlBulkCopy(DB.Conexion))
                {
                    bulkCopy.DestinationTableName = "[" + lcDataBaseTemp + "].dbo.["+ registro._TablaSecundaria + registro._Sufijo + "]";

                    // Write from the source to the destination.
                    bulkCopy.WriteToServer(dtDatos);
                }
            }
        }

        private static void GestionarXML_TablasTemporales(Dictionary<string, DataTable> dicTablas, OfflineDatosComunicaciones datos, string lcBd, ILog_comoffRepository logRepository)
        {
            _TextStepDetalle = "Generando ficheros XML adicionales";
            _TextStepProgreso = _TextStepDetalle;
            _PorcenProgreso = IncrementarBarraProgreso();
    
            foreach (KeyValuePair<string, DataTable> tabla in dicTablas)
            {
                if (tabla.Value != null && tabla.Value.Rows.Count > 0)
                {
                    // Convertir el datatable en XML
                    ConvertIndividualFile(tabla.Value, Path.Combine(datos._PathFolderInicial), tabla.Key, FormatoExportacion.XML);

                    Log_comoffDto logDto = logRepository.GetDto(datos);
                    logDto.TipoDato = "01";
                    logDto.Resultado = 1;

                    if (tabla.Key.Contains("DELETENET"))
                    {
                        tabla.Value.DefaultView.Sort = "tabla ASC";
                        DataTable ldtAux = tabla.Value.DefaultView.ToTable();

                        // Gestionar XML de la tabla DELETENET
                        if (ldtAux.Rows.Count > 0)
                        {
                            List<string> lsTabla = new List<string>();

                            foreach (DataRow row in ldtAux.Rows)
                            {
                                if (!lsTabla.Contains(row["tabla"]))
                                {
                                    DataRow[] dtRow = ldtAux.Select("tabla =" + DB.SQLString(row["tabla"]));
                                    if (dtRow.Length > 0)
                                    {
                                        logDto.Detalle = "Se han eliminado " + dtRow.Length + " registros en la tabla " + row["tabla"].ToString().Trim() + ". " + Environment.NewLine +
                                                "Dichas eliminaciones se corresponden con datos eliminados en el grupo de empresa origen de los datos.";
                                        logRepository.Insert(logDto);

                                        lsTabla.Add(row["tabla"].ToString());
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        logDto.Detalle = "Se han incluido datos nuevos en el fichero de comunicaciones. (" + tabla.Key + ")";
                        logRepository.Insert(logDto);
                    }
                }
            }
        }

        private static void TratamientoEspecial_EnvioAsientos(RegistroTabRel registro, DataRow itemRow, DataRow row, ref DataTable dtAsientos, ref DataTable dtOtrasien, ref DataTable dtEos)
        {
            string lcValueAsientos = string.Empty;
            string lcValueOtrasien = string.Empty;
            string lcValueEos = string.Empty;
            string lcSql = string.Empty;
            Dictionary<string, string> dcValue = new Dictionary<string, string>();

            switch (registro._Clave)
            {
                case "C_PRESUV":
                case "C_PEDIVE":
                case "C_ALBDEP":
                case "C_ALBVEN":
                case "FACTURAS":
                case "C_PEDICO":
                case "C_DEPCOM":
                case "C_ALBCOM":
                case "FACTURAC":
                case "C_TRANSDUA":
                    if (registro._Asientos != "")
                    {
                        if (!string.IsNullOrEmpty(itemRow["asientos"].ToString().Trim()))
                        {
                            dcValue.Add("Asientos", itemRow["asientos"].ToString().Trim());

                            RegistroEspecial_Asientos_Envio(dcValue, "ASIENTOS", row, ref dtAsientos, "Asientos");
                        }
                    }
                    if (registro._Otrasien != "")
                    {
                        if (!string.IsNullOrEmpty(itemRow["otrasien"].ToString().Trim()))
                        {
                            dcValue.Add("Otrasien", itemRow["otrasien"].ToString().Trim());

                            RegistroEspecial_Asientos_Envio(dcValue, "ASIENTOS", row, ref dtOtrasien, "Otrasien");
                        }
                    }
                    if (registro._Eos != "")
                    {
                        if (!string.IsNullOrEmpty(itemRow["eos"].ToString().Trim()))
                        {
                            dcValue.Add("Eos", itemRow["eos"].ToString().Trim());

                            RegistroEspecial_Asientos_Envio(dcValue, "ASIENTOS", row, ref dtEos, "Eos");
                        }
                    }
                    
                    break;
            }
        }

        private static void RegistroEspecial_Asientos_Envio(Dictionary<string,string> dcValue, string lcTabla, DataRow row, ref DataTable dtTabla, string lcBusqueda)
        {
            DataTable dtTemp = new DataTable();
            DataTable dtDatos = new DataTable();

            string Value = dcValue.FirstOrDefault(x => x.Key == lcBusqueda).Value;
        
            if (!string.IsNullOrEmpty(Value))
            {
                // preparo la taula secundaria
                string lcSql = "SELECT * FROM " + DB.SQLDatabase("GESTION", lcTabla) + " WHERE " + Value + " = " + DB.SQLString(row[Value]);

                DB.SQLExec(lcSql, ref dtTemp);

                foreach (DataRow loRow in dtTemp.Rows)
                {
                    lcSql = "SELECT * FROM " + DB.SQLDatabase("GESTION", lcTabla) + " WHERE NUMERO = " + DB.SQLString(loRow["numero"]) + " AND EMPRESA = " + DB.SQLString(loRow["empresa"]);

                    DB.SQLExec(lcSql, ref dtDatos);

                    string lcValue = string.Empty;
                    foreach (DataRow item in dtDatos.Rows)
                    {
                        dtTabla.ImportRow(item);
                    }
                }
            }
        }

        private static void RegistroEspecial_OtrasienEos_Envio(string value, string lcTabla, DataRow row, ref DataTable dtTabla, DataRow loRow)
        {
            DataTable dtDatos = new DataTable();

            string lcSql = "SELECT * FROM " + DB.SQLDatabase("GESTION", lcTabla) + " WHERE ASI = " + DB.SQLString(loRow["asi"]) + " AND EMPRESA = " + DB.SQLString(loRow["empresa"]);

            DB.SQLExec(lcSql, ref dtDatos);

            foreach (DataRow item in dtDatos.Rows)
            {
                dtTabla.ImportRow(item);
            }
        }

        private static void RegistroDatosEspecial(OfflineDatosComunicaciones datos, string tcTabla, DataTable ldtDatos, ILog_comoffRepository logRepository)
        {
            string lcDetalle = string.Empty;

            if (ldtDatos.TableName.Contains("_MODIFIED"))
            {
                lcDetalle = "Se han incluido los siguientes datos modificados en el fichero de comunicaciones. Dato: " + tcTabla + Environment.NewLine;
            }
            else
            {
                lcDetalle = "Se han incluido los siguientes datos nuevos en el fichero de comunicaciones. Dato: " + tcTabla + Environment.NewLine;
            }

            
            lcDetalle += ConstruirTextoDetalle(ldtDatos, "numero", "ASIENTOS", "GESTION");

            Log_comoffDto logDto = logRepository.GetDto(datos);
            logDto.TipoDato = "02";
            logDto.Resultado = 1;
            logDto.Detalle = lcDetalle;
            logRepository.Insert(logDto);
        }

        private static void TratamientoEspecial_EnvioFabricacion(RegistroTabRel registro, OfflineDatosComunicaciones datos)
        {
            string lcSql = string.Empty;
     
            // Obtenir nom real de la bd
            string lcBdReal = clsOfflineUtils.ObtenerNombreBdReal(registro._DBSecundaria);

            //Si son partes de costes sin asignar, se deben eliminar las lineas que estan relacionados con documentos
            if (registro._TablaSecundaria == "D_PARTES")
            {
                lcSql = " SELECT a.* INTO [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[_COSTES_C_PARTES" + registro._Sufijo + "]" +
                        " FROM [" + lcBdReal + "].dbo.C_PARTES a " +
                        " INNER JOIN ( " +
                                        " SELECT DISTINCT empresa, numero " +
                                        " FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "D_PARTES" + registro._Sufijo + "] " +
                                        " WHERE albaran = 0 " +
                                   " ) b ON a.empresa = b.empresa AND a.numero = b.numero ";
                DB.SQLExec(lcSql);

                lcSql = " SELECT * INTO [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[_COSTES_D_PARTES" + registro._Sufijo + "]" +
                        " FROM [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + "D_PARTES" + registro._Sufijo + "] WHERE albaran = 0 ";
                DB.SQLExec(lcSql);
            }
            else
            {
                string[] filesTablas = new string[] { "D_PARTES", "C_PARTES" };
                DataTable table = new DataTable();

                foreach (string file in filesTablas)
                {
                    ComprobarTablaTemporalSQL(registro, "GESTION", file);

                    int tipo_alb = (registro._TablaSecundaria == "D_PROD" ? 1 : 2);

                    if (file == "D_PARTES")
                    {
                        lcSql =     " FROM [" + lcBdReal + "].dbo.[D_PARTES] as A " +
                                    " INNER JOIN [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + registro._TablaSecundaria + registro._Sufijo + "] as B " +
                                    " ON A.EMPRESA = B.EMPRESA AND A.ALBARAN = B.NUMERO AND A.LINEA = B.LINEA AND A.TIPO_ALB = " + tipo_alb;
                    }
                    else
                    {
                        lcSql =     " FROM [" + lcBdReal + "].dbo.C_PARTES a " +
                                    " INNER JOIN ( SELECT DISTINCT A.EMPRESA, A.NUMERO " +
                                                    " FROM [" + lcBdReal + "].dbo.[D_PARTES] as A " +
                                                    " INNER JOIN [" + _cRaizDataBaseTemporal + "GESTION" + "].dbo.[" + registro._TablaSecundaria + registro._Sufijo + "] as B " +
                                                    " ON A.EMPRESA = B.EMPRESA AND A.ALBARAN = B.NUMERO AND A.LINEA = B.LINEA AND A.TIPO_ALB = " + tipo_alb +
                                               " ) b on A.EMPRESA = B.EMPRESA And A.NUMERO = B.NUMERO ";
                    }

                    DB.SQLExec(" SELECT a.* " + lcSql, ref table);

                    if (table != null & table.Rows.Count > 0)
                    {
                        DB.SQLExec(" SELECT A.* INTO [" + _cRaizDataBaseTemporal + registro._DBSecundaria + "].dbo.[_PARTES" + tipo_alb + "_" + file + registro._Sufijo + "] " + lcSql);

                        // Actualizar tabla de control
                        if (file == "D_PARTES")
                        {
                            Actualizar_Tabla_Control(table, "GESTION!D_PARTES", "CTRL_PARCO", registro._ID, datos);

                            string lcAny = EW_GLOBAL._GetVariable("wc_any").ToString();
                            string lcSet = " Set ORIGEN = " + (datos._IsCentral ? DB.SQLString("CENTRAL") : DB.SQLString(datos._Sucursal)) + ", MODIFIED = " + DB.SQLString(DateTime.Now);
                            string lcOrigen = (datos._IsCentral ? "CENTRAL" : datos._Sucursal);

                            foreach (DataRow item in table.Rows)
                            {
                                string lcWhere = " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                                                " AND NUMERO = " + DB.SQLString(item.Field<string>("numero")) +
                                                " AND LINIA = " + DB.SQLString(item.Field<int>("linea")) +
                                                " AND EJERCICIO = " + DB.SQLString(lcAny);

                                string lcInsert = "(EMPRESA, NUMERO, LINIA, ORIGEN, EJERCICIO, GUID_ID, CREATED, MODIFIED, VISTA, IDTABREL) " +
                                                "Values(" +
                                                    DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<string>("numero")) + ", " + DB.SQLString(item.Field<int>("linea")) + ", " +
                                                    DB.SQLString(lcOrigen) + ", " + DB.SQLString(lcAny) + ", NEWID(), GETDATE(), GETDATE(), cast(1 as bit), 0)";

                                ComprobarTablaTemporalSQL(registro, "OFFLINE", "CTRL_PARCO");

                                lcSql = " IF EXISTS " + Environment.NewLine +
                                                " ( SELECT NUMERO FROM [" + _cRaizDataBaseTemporal + "OFFLINE].dbo.[CTRL_PARCO" + registro._Sufijo + "] " + lcWhere + " ) " + Environment.NewLine +
                                                " BEGIN " + Environment.NewLine +
                                                        " Update [" + _cRaizDataBaseTemporal + "OFFLINE].dbo.[CTRL_PARCO" + registro._Sufijo + "] " + lcSet + lcWhere + Environment.NewLine +
                                                " END " + Environment.NewLine +
                                                " ELSE " + Environment.NewLine +
                                                " BEGIN" + Environment.NewLine +
                                                        "Insert Into [" + _cRaizDataBaseTemporal + "OFFLINE].dbo.[CTRL_PARCO" + registro._Sufijo + "] " + lcInsert +
                                                " END ";

                                DB.SQLExec(lcSql);
                            }
                        }
                    }
                }
            }
        }

        private static void RegistroDatos(OfflineDatosComunicaciones datos, DataRow registro, string tcBdReal, string tbDB, string tcTabla, DataTable tdtDatos, string lcSufijo, ILog_comoffRepository logRepository)
        {
            string lcDetalle = string.Empty;
            string lcCampo = string.Empty;

            List<string> lista = new List<string>();

      
            if (lcSufijo.Contains("_MODIFIED"))
            {
                lcDetalle = "Se han incluido los siguientes datos modificados en el fichero de comunicaciones. " + Environment.NewLine;
            }
            else
            {
                lcDetalle = "Se han incluido los siguientes datos nuevos en el fichero de comunicaciones. " + Environment.NewLine;
            }

            lcDetalle += "Dato: " + (tcTabla.Contains("CTRL_") ? "Información extendida de " : "") + registro.Field<string>("titulo").TrimEnd().ToUpper() + Environment.NewLine + Environment.NewLine;
            
            int nId = registro.Field<int>("id");
            string cClave = registro.Field<string>("clave");

            switch (tcTabla)
            {
                case "BARRAS":
                case "IDI_ART":
                case "OFERTAS":
                case "PVP":
                case "REFERPRO":
                case "PVPCOL":
                case "ART_COLO":
                case "ART_TALL":
                case "ESCANDAL":
                case "FACTORPTOS":
                case "ART_FOTO":
                case "ARTLOT":
                case "BAREAN":
                case "COSTELOT":
                case "STOALMMM":
                case "EAN_PESO":
                case "ART_REST":
                case "ART_REG":
                case "CMBPVP":

                case "CTRL_OFER":

                    lcDetalle += ConstruirTextoDetalle(tdtDatos, "articulo", "ARTICULO", "GESTION");
                    break;

                case "DESC_FAM":

                    lcDetalle += ConstruirTextoDetalle(tdtDatos, "familia", "ARTICULO", "GESTION");
                    break;

                case "MULTICAM":
                case "VALMULTI":
                    lcDetalle += ConstruirTextoDetalle(tdtDatos, "codigo", "MCAMPOS", "GESTION");
                    break;

                case "DESC_SUB":

                    lcDetalle += ConstruirTextoDetalle(tdtDatos, "subfam", "SUBFAM", "GESTION");
                    break;

                case "TALLGRUP":

                    lcDetalle += ConstruirTextoDetalle(tdtDatos, "talla", "TALLAS", "COMUNES");
                    break;

                case "COLOGRUP":

                    lcDetalle += ConstruirTextoDetalle(tdtDatos, "color", "COLORES", "COMUNES");
                    break;

                case "COMPRAS":
                case "STOCKS2":
                case "STOCKLOTES":
                case "STOCKS":
                case "STOCKINI":
                case "ALMA_ANALI":
                case "INICIALSER":
                case "LTSTINI":
                case "CTRL_STINI":
                case "REGULARI":
                case "LTREGUL":
                case "REGULARISER":
                case "CTRL_REGUL":

                    lcDetalle += ConstruirTextoDetalle(tdtDatos, "almacen", "ALMACEN", "GESTION");
                    break;

                case "HISSERIE":
                    switch (cClave)
                    {
                        case "STOCKINI":

                            lcDetalle += ConstruirTextoDetalle(tdtDatos, "almacen", "ALMACEN", "GESTION");
                            break;

                        case "C_ALBARE":
                        case "C_ALBATR":
                        case "PEDINT_C":
                        case "C_ALBCOM":
                        case "C_DEPCOM":
                        case "C_PROD":
                        case "C_TRANS":

                            ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "numero", "", "numero");
                            break;

                        case "C_ALBVEN":
                        case "C_ALBDEP":

                            ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "letra", "numero", "numero");
                            break;

                        case "REGULARI":

                            ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "documento", "", "documento");
                            break;
                    }
                    break;

                case "C_FORMUL":
                case "D_FORMUL":
                case "CTRL_FORMU":

                    lcCampo = (tcTabla == "D_FORMUL" ? "formula" : "articulo");
                    lcDetalle += ConstruirTextoDetalle(tdtDatos, lcCampo, "C_FORMUL", "LOTES", "ARTICULO");
                    break;

                case "ART_CLASIF":
                case "CTRL_CLASI":

                    lcCampo = (tcTabla == "ART_CLASIF" ? "clasif" : "codigo");
                    lcDetalle += ConstruirTextoDetalle(tdtDatos, lcCampo, "CLASIF", "COMUNES");
                    break;

                case "DESCUEN":
                case "ACTI_CLI":
                case "BANC_CLI":
                case "CONT_CLI":
                case "ENV_CLI":
                case "GIRO_CLI":
                case "TELF_CLI":
                case "VACA_CLI":
                case "CLITARJFID":
                case "MANDATOS":
                //case "MANDEMP":
                case "CONTLF_CLI":
                case "RIESGO":

                    lcCampo = (tcTabla == "RIESGO" ? "codigo" : "cliente");
                    lcDetalle += ConstruirTextoDetalle(tdtDatos, lcCampo, "CLIENTES", "GESTION");
                    break;

                case "TCPS":

                    lcDetalle += ConstruirTextoDetalle(tdtDatos, "tcp", "TCP", "COMUNES");
                    break;

                case "OTRAS":
                case "GIRO_CUE":
                case "BANC_CUE":

                    lcCampo = (tcTabla == "OTRAS" ? "codigo" : "cuenta");
                    lcDetalle += ConstruirTextoDetalle(tdtDatos, lcCampo, "CUENTAS", "GESTION");
                    break;

                case "TELF_PRO":
                case "GIRO_PRO":
                case "CONT_PRO":
                case "ACTI_PRO":
                case "ENV_PRO":
                case "VACA_PRO":
                case "BANC_PRO":
                case "CONTLF_PRO":
                case "DESC_PRO":

                    lcCampo = (tcTabla == "DESC_PRO" ? "proveed" : "proveedor");
                    lcDetalle += ConstruirTextoDetalle(tdtDatos, lcCampo, "PROVEED", "GESTION");
                    break;

                case "ENTRE_CL":
                
                    switch (nId)
                    {
                        case 113:
                            // Entregas a cuenta de cliente
                            lcCampo = (tcTabla == "ENTRE_CL" || tcTabla == "PREVI_CL" ? "cliente" : "cuenta");
                            lcDetalle += ConstruirTextoDetalle(tdtDatos, lcCampo, "CLIENTES", "GESTION");
                            break;

                        case 318:
                            // Entregas a cuenta de proveedor
                            lcCampo = (tcTabla == "ENTRE_CL" ? "cliente" : (tcTabla == "PREVIS" ? "proveedor" : "cuenta"));
                            lcDetalle += ConstruirTextoDetalle(tdtDatos, lcCampo, "PROVEED", "GESTION");
                            break;
                    }

                    break;

                case "EOS":
                    switch (nId)
                    {
                        case 68: // Facturas de venta
                        case 301: // TPV con arqueo
                        case 326: // TPV sin arqueo

                            lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "factura");
                            break;

                        case 113:
                            // Entregas a cuenta de cliente
                            lcCampo = (tcTabla == "ENTRE_CL" || tcTabla == "PREVI_CL" ? "cliente" : "cuenta");
                            lcDetalle += ConstruirTextoDetalle(tdtDatos, lcCampo, "CLIENTES", "GESTION");
                            break;

                        case 318:
                            // Entregas a cuenta de proveedor
                            lcCampo = (tcTabla == "ENTRE_CL" ? "cliente" : (tcTabla == "PREVIS" ? "proveedor" : "cuenta"));
                            lcDetalle += ConstruirTextoDetalle(tdtDatos, lcCampo, "PROVEED", "GESTION");
                            break;

                        case 216:
                            // Facturas de compra
                            lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "cuenta", "factura");

                            break;
                    }

                    break;

                case "IVAREPER":

                    switch (nId)
                    {
                        case 69:  // Facturas de venta
                        case 302: // TPV con arqueo
                        case 327: // TPV sin arqueo
                            lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "numfra");
                            break;

                        case 113:
                            // Entregas a cuenta de cliente
                            lcCampo = (tcTabla == "ENTRE_CL" || tcTabla == "PREVI_CL" ? "cliente" : "cuenta");
                            lcDetalle += ConstruirTextoDetalle(tdtDatos, lcCampo, "CLIENTES", "GESTION");
                            break;

                        case 318:
                            // Entregas a cuenta de proveedor
                            lcCampo = (tcTabla == "ENTRE_CL" ? "cliente" : (tcTabla == "PREVIS" ? "proveedor" : "cuenta"));
                            lcDetalle += ConstruirTextoDetalle(tdtDatos, lcCampo, "PROVEED", "GESTION");
                            break;

                        case 344:
                            // Facturas de compra
                            lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "cuenta", "numfra");
                            break;
                    }

                    break;

                case "IVASOPOR":

                    switch (nId)
                    {
                        case 318:
                            // Entregas a cuenta de proveedor
                            lcDetalle += ConstruirTextoDetalle(tdtDatos, "cuenta", "PROVEED", "GESTION");
                            break;

                        case 217:
                            // Facturas de compra
                            lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "cuenta", "numfra");
                            break;
                    }

                    break;

                case "IVA_EXEN":

                    switch (nId)
                    {
                        case 276: // Facturas de venta
                        case 308: // TPV con arqueo
                        case 333: // TPV sin arqueo

                            lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "factura");
                            break;

                        case 113:
                            // Entregas a cuenta de cliente
                            lcDetalle += ConstruirTextoDetalle(tdtDatos, "cuenta", "CLIENTES", "GESTION");
                            break;

                        case 318:
                            // Entregas a cuenta de proveedor
                            lcDetalle += ConstruirTextoDetalle(tdtDatos, "cuenta", "PROVEED", "GESTION");
                            break;

                        case 277:
                            // Facturas de compra
                            lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "cuenta", "factura");

                            break;
                    }

                    break;

                case "RETREPER":
                    // Factura de compra
                    lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "numfra");

                    break;

                case "RETSOPOR":

                    switch (nId)
                    {
                        case 393: // Facturas de venta
                        case 395: // TPV con arqueo
                        case 396: // TPV sin arqueo

                            lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "numfra");
                            break;
                    }

                    break;

                case "PREVI_CL":
                case "CTRL_PREVV":

                    switch (nId)
                    {
                        case 67:   // Facturas de venta
                        case 300:  // TPV con arqueo
                        case 325:  // TPV sin arqueo
                            lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "factura");
                            break;

                        case 360:
                            // Entregas a cuenta de cliente
                            lcDetalle += ConstruirTextoDetalle(tdtDatos, "cliente", "CLIENTES", "GESTION");
                            break;
                    }

                    break;

                case "PREVIS":
                case "CTRL_PREVC":

                    switch (nId)
                    {
                        case 361:
                            // Entregas a cuenta de proveedor
                            lcDetalle += ConstruirTextoDetalle(tdtDatos, "proveedor", "PROVEED", "GESTION");
                            break;

                        case 245:
                            // Facturas de compra
                            lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "proveedor", "factura");
                            break;
                    }

                    break;

                case "CTRL_ASIEN":

                    lcDetalle += tdtDatos.Rows.Count.ToString() + " registros.";
                    break;

                case "ASIENTOS":
                case "OTRASIEN":
                //case "CTRL_ASIEN":

                    switch (nId)
                    {
                        case 336:
                            // Presupuestos de venta
                            lcCampo = (tcTabla == "OTRASIEN" ? "codcuen" : "cuenta");
                            lcDetalle += ConstruirTextoDetalle(tdtDatos, lcCampo, "CLIENTES", "GESTION");
                            break;

                        case 72:
                            // Pedidos de venta
                            lcCampo = (tcTabla == "OTRASIEN" ? "codcuen" : "cuenta");
                            lcDetalle += ConstruirTextoDetalle(tdtDatos, lcCampo, "CLIENTES", "GESTION");
                            break;

                        case 5:
                            // Albaranes de venta
                            lcCampo = (tcTabla == "OTRASIEN" ? "codcuen" : "cuenta");
                            lcDetalle += ConstruirTextoDetalle(tdtDatos, lcCampo, "CLIENTES", "GESTION");
                            break;

                        case 67:
                        case 68:
                        case 222:
                        case 348:
                            // Facturas de venta
                            lcCampo = (tcTabla == "OTRASIEN" ? "codcuen" : "cuenta");
                            lcDetalle += ConstruirTextoDetalle(tdtDatos, lcCampo, "CLIENTES", "GESTION");
                            break;

                        case 216:
                        case 245:
                        case 221:
                            // Facturas de compra
                            lcCampo = (tcTabla == "OTRASIEN" ? "codcuen" : "cuenta");
                            lcDetalle += ConstruirTextoDetalle(tdtDatos, lcCampo, "PROVEED", "GESTION");
                            break;

                        case 360:
                            // Clientes
                            lcCampo = (tcTabla == "OTRASIEN" ? "codcuen" : "cuenta");
                            lcDetalle += ConstruirTextoDetalle(tdtDatos, lcCampo, "CLIENTES", "GESTION");
                            break;

                        case 361:
                            // Proveedores
                            lcCampo = (tcTabla == "OTRASIEN" ? "codcuen" : "cuenta");
                            lcDetalle += ConstruirTextoDetalle(tdtDatos, lcCampo, "PROVEED", "GESTION");
                            break;
                    }
                    break;

                case "C_FACTUVEN":

                    switch (nId)
                    {
                        case 288:  // Facturas de venta
                        case 310:  // TPV con arqueo
                        case 335:  // TPV sin arqueo

                            lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "numero");

                            break;
                    }
                    break;

                case "C_FACTUCOM":

                    switch (nId)
                    {
                        case 289: // Facturas de compra

                            lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "proveedor", "numero");

                            break;
                    }
                    break;

                case "FINTECHFAC":

                    switch (nId)
                    {
                        case 293: // Facturas de venta
                        case 311: // TPV con arqueo
                        case 252: // TPV sin arqueo

                            lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "numfra");


                            break;
                    }
                    break;

                case "FCFACTUVEN":

                    switch (nId)
                    {
                        case 400: // Facturas de venta
                        case 408: // TPV con arqueo
                        case 407: // TPV sin arqueo

                            lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "borrador");


                            break;
                    }
                    break;

                case "FCREGCERT":

                    switch (nId)
                    {
                        case 403: // Facturas de venta
                        case 405: // TPV con arqueo
                        case 404: // TPV sin arqueo

                            lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "borrador");


                            break;
                    }
                    break;
                case "FPAG_GIR":

                    lcDetalle += ConstruirTextoDetalle(tdtDatos, "fpag", "FPAG", "GESTION");
                    break;

                case "LIN_DESC":

                    lcDetalle += ConstruirTextoDetalle(tdtDatos, "codigo", "LINEAS", "GESTION");
                    break;

                case "ZONAS":

                    lcDetalle += ConstruirTextoDetalle(tdtDatos, "ruta", "RUTAS", "GESTION");
                    break;

                case "ART_COMI":

                    lcDetalle += ConstruirTextoDetalle(tdtDatos, "vendedor", "VENDEDOR", "GESTION");
                    break;

                case "CONIRPF":

                    lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "conirpf", "nombre");

                    break;

                case "FCLETRAS":

                    lcDetalle += ConstruirTextoDetalle(tdtDatos, "letra", "LETRAS", "COMUNES");
                    break;

                case "CAJ_FCOB":

                    lcDetalle += ConstruirTextoDetalle(tdtDatos, "caja", "CAJAS", "TPV");
                    break;

                case "PLAN_D":

                    lcDetalle += ConstruirTextoDetalle(tdtDatos, "plancont", "PLANS", "GESTION");
                    break;

                case "MODCONFI":
                case "CFGFACT":
                case "CODIGOS":
                case "FACTUCNF":
                case "FLAGS":
                case "OPCEMP":
                case "CONTACNF":
                case "ESCALADO":
                case "CONTADOR":
                case "SERIES":
                case "ACCESOS":
                case "MENUS":
                case "CONFIGURA":
                case "CONFTPV":
                case "CONFVAL":
                case "CONFTICK":

                    lcDetalle += ConstruirTextoDetalle(tdtDatos, "empresa", "EMPRESA", "GESTION");
                    break;

                case "OPC_USER":

                    lcDetalle += ConstruirTextoDetalle(tdtDatos, "operario", "OPERARIO", "COMUNES");
                    break;

                case "ACCE_MON":
                case "OPCESPUS":

                    lcDetalle += ConstruirTextoDetalle(tdtDatos, "usuario", "USUARIOS", "COMUNES");
                    break;


                case "OPCFLAG":
                case "CASH":
                case "PERFILES":
                case "PRCLIENT":

                    foreach (DataRow item in tdtDatos.Rows)
                    {
                        lcDetalle += item.Field<int>("codigo").ToString().TrimEnd() + " - " + item.Field<string>("nombre").TrimEnd() + Environment.NewLine;
                    }

                    break;

                case "ARQUEOS":
                case "D_ARQUEO":
                case "CTRL_ARQUE":

                    lcCampo = (tcTabla == "D_ARQUEO" ? "arqueo" : "numero");

                    foreach (DataRow item in tdtDatos.Rows)
                    {
                        if (!lista.Contains(item.Field<string>("empresa").ToString().TrimEnd() + " - " + item.Field<int>(lcCampo).ToString().TrimEnd()))
                        {
                            lcDetalle += item.Field<string>("empresa").ToString().TrimEnd() + " - " + item.Field<int>(lcCampo).ToString().TrimEnd() + Environment.NewLine;
                            lista.Add(item.Field<string>("empresa").ToString().TrimEnd() + " - " + item.Field<int>(lcCampo).ToString().TrimEnd());
                        }
                    }

                    break;

                case "C_ALBATR":
                case "D_ALBATR":
                case "LTALBTR":
                case "TRASPSER":
                case "CTRL_ALBTR":

                case "C_ALBARE":
                case "D_ALBARE":
                case "LTALBRE":
                case "REGUSER":
                case "CTRL_ALBRE":

                case "PEDINT_C":
                case "PEDINT_D":
                case "PEDINT_LIN":
                case "PEDINT_REG":
                case "CTRL_PEDIN":

                case "CTRL_FACV":

                    lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "numero");

                    break;

                case "MULTICA2":

                    switch (cClave)
                    {
                        case "C_PRESUV":
                        case "C_PEDIVE":
                        case "C_ALBDEP":
                        case "C_ALBVEN":
                        case "FACTURAS":
                        case "TPVCONARQUEO":
                        case "TPVSINARQUEO":

                            lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "letra", "numero");

                            break;
                    }
                    break;

                case "MULTICA3":

                    switch (cClave)
                    {
                        case "C_PEDICO":
                        case "C_DEPCOM":
                        case "C_ALBCOM":
                        case "FACTURAC":

                            lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "proveedor", "numero");

                            break;
                    }
                    break;

                case "CONTADO":

                    switch (cClave)
                    {
                        case "C_PEDIVE":
                        case "C_ALBDEP":
                        case "C_ALBVEN":
                        case "CONTADO":

                            lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "letra", "numero");

                            break;
                    }
                    break;

                case "C_PRESUV":
                case "D_PRESUV":
                case "PORTES_PRV":
                case "ENTRE_PR":
                case "PRES_ADI":

                case "C_PEDIVE":
                case "D_PEDIVE":
                case "D_PEDIVEES":
                case "PORTES_PDV":
                case "ENTRE_PV":
                case "PEDV_ADI":

                case "C_ALBDEP":
                case "D_ALBDEP":
                case "LTDEPVE":
                case "DEPSER":
                case "PORTES_DPV":
                case "DEPV_ADI":

                case "C_ALBVEN":
                case "D_ALBVEN":
                case "LTALBVE":
                case "VENSER":
                case "PORTES":
                case "ENTREGAS":
                case "ALBV_ADI":
                case "REFALBCLI":
                case "CAB_AV":
                case "LIN_AV":
                case "ALB_FPAG":
                case "VALES":

                case "CTRL_PRESV":
                case "CTRL_PEDV":
                case "CTRL_DEPV":
                case "CTRL_ALBV":
                

                    lcCampo = (tcTabla == "PORTES" || tcTabla == "ENTREGAS" ? "albaran" : (tcTabla == "VALES" ? "ticket" : "numero"));
                    if (cClave == "FACTURAS")
                    {
                        lcCampo = (tcTabla == "C_ALBVEN" && tcBdReal == "GESTION" ? "factura" : lcCampo);
                    }

                    lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "letra", lcCampo);
                    break;
                    

                case "C_PEDICO":
                case "D_PEDICO":
                case "D_PEDICOES":

                case "C_DEPCOM":
                case "D_DEPCOM":
                case "LTDEPCO":
                case "DEPCSER":

                case "C_PROD":
                case "D_PROD":
                case "LTCPROD":
                case "LTDPROD":
                case "PRODUSER":
                case "PRODUSERC":

                case "C_TRANS":
                case "D_TRANS":
                case "LTCTRAN":
                case "LTDTRAN":
                case "TRANSER":
                case "TRANSSER":
                
                case "C_PARTES":
                case "D_PARTES":

                case "CTRL_PEDC":
                case "CTRL_DEPC":
                case "CTRL_PROD":
                case "CTRL_PARCO":
                case "CTRL_TRANS":

                    lcCampo = (tcTabla == "PRODUSER" || tcTabla == "PRODUSERC" || tcTabla == "TRANSER" || tcTabla == "TRANSSER" ? "albaran" : "numero");

                    lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", lcCampo);
                    break;

                case "C_ALBCOM":
                case "D_ALBCOM":
                case "LTALBCO":
                case "COMSER":
                case "PORTESC":
                case "ALB_FPA2":

                case "CTRL_ALBC":
                case "CTRL_FACC":
                case "CTRL_TRDUA":

                    lcCampo = (tcTabla == "PORTESC" ? "albaran" : "numero");
                    if (cClave == "FACTURAC")
                    {
                        lcCampo = (tcTabla == "C_ALBCOM" ? "factura" : lcCampo);
                    }

                    lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "empresa", "proveedor", lcCampo);
                    break;

                case "TIKETS":
                case "REPOSI":
                case "COB_PAGO":
                case "CTRL_REPOS":
                case "CTRL_RETIR":

                    lcDetalle += tdtDatos.Rows.Count.ToString() + " registros.";
                    break;

                case "ESTILOS":
                case "PERF_OBLIG":
                case "PERF_USERS":

                    // No hacer nada, de momento
                    break;

                default:

                    if (tcTabla.Contains("CTRL_"))
                    {
                        string[] loDatos = _offlineConfig.ObtenerTablaOriginalRelacionada(tcTabla).Split('!');
                        lcCampo = "CODIGO";

                        if (loDatos.Length == 2)
                        {
                            switch (tcTabla)
                            {
                                case "CTRL_FORMU":

                                    lcCampo = "ARTICULO";
                                    break;

                                case "CTRL_STINI":

                                    lcCampo = "ALMACEN";
                                    break;

                                case "CTRL_CIRPF":

                                    lcCampo = "CONIRPF";
                                    break;

                                default:

                                    lcCampo = "CODIGO";
                                    break;

                            }

                            if (tcTabla == "CTRL_PRCLI")
                            {
                                lcDetalle += ConstruirTextoDetalleEntero(tdtDatos, lcCampo.ToLower(), loDatos[1], loDatos[0], lcCampo);
                            }
                            else
                            {
                                lcDetalle += ConstruirTextoDetalle(tdtDatos, lcCampo.ToLower(), loDatos[1], loDatos[0], lcCampo);
                            }
                        }
                    }
                    else
                    {
                        if (tdtDatos.Columns.Contains("codigo") && tdtDatos.Columns.Contains("nombre"))
                        {
                            lcDetalle += ConstruirTextoDetalleEspecial(tdtDatos, "codigo", "nombre");

                        }
                    }
                    break;
            }

            Log_comoffDto logDto = logRepository.GetDto(datos);
            logDto.TipoDato = clsOfflineUtils.ObtenerTipoDato(registro.Field<string>("clave").TrimEnd().ToUpper());
            logDto.Resultado = 1;
            logDto.Detalle = lcDetalle;
            logRepository.Insert(logDto);

        }


        public static void EnvioEmailNotificacion(string tcFicheroZip, OfflineDatosComunicaciones datos, ILog_comoffRepository logRepository)
        {
            if (datos._NotificacionEnvio && !string.IsNullOrEmpty(datos._EmailNotificacionEnvio))
            {                
                // Comprobamos resultado del envío
                DataTable table = new DataTable();

                AsistenteOffEnvioDatosBizRule loAsist = new AsistenteOffEnvioDatosBizRule();
                Dictionary<string, int> loDic = loAsist.Result_LogComunicaciones_IdLog(ref table, datos._Log_ComoffID);
                int nResultado = 0;
                if (loDic.Count > 0)
                {
                    KeyValuePair<string, int> itemFirst = loDic.First();
                    nResultado = itemFirst.Value;
                }

                string lcAsunto = string.Empty;
                string lcMensajeEnvio = string.Empty;

                switch (nResultado)
                {
                    case 3:
                        lcAsunto = "Sage 50 – Errores en el envío de datos";
                        lcMensajeEnvio = " Se han producido errores en el proceso de envío de datos de fecha " + clsOfflineUtils.ObtenerFechaFicheroDatos(tcFicheroZip) + ", fichero " + tcFicheroZip + "<br><br>" +
                                            " Revise el documento adjunto donde se incluye detalle del registro de comunicaciones, en el cual podrá ver los errores  detectadas durante el proceso de envío de datos. ";
                        break;
                    case 2:
                        lcAsunto = "Sage 50 – Incidencias en el envío de datos";
                        lcMensajeEnvio = " Ha finalizado el envío de datos de fecha " + clsOfflineUtils.ObtenerFechaFicheroDatos(tcFicheroZip) + ", fichero " + tcFicheroZip + " con incidencias." + "<br><br>" + " Revise el documento adjunto donde se incluye detalle del registro de comunicaciones, en el cual podrá ver las incidencias detectadas durante el proceso de envío de datos. ";
                        break;
                    default:
                        lcAsunto = "Sage 50 – Envío de datos";
                        lcMensajeEnvio = " Ha finalizado el envío de datos de fecha " + clsOfflineUtils.ObtenerFechaFicheroDatos(tcFicheroZip) + ", fichero " + tcFicheroZip + " correctamente. " + "<br><br>" + " Revise documento adjunto donde se incluye detalle del registro de comunicaciones en el cual podrá ver los datos enviados. ";
                        break;

                }

                _TextStepDetalle = "Enviando email de notificación";
                _TextStepProgreso = _TextStepDetalle;
                _PorcenProgreso = IncrementarBarraProgreso();


                SendMail loSendMail = new SendMail("SUPERVISOR");
                loSendMail._Emails = datos._EmailNotificacionEnvio.Split(';').ToList();
                loSendMail._Subject = lcAsunto;

                string lcGrupoActual = GrupoEmpresa._CodigoGrupoActual();
                GrupoEmpresa _oGrupoEmpresa = new GrupoEmpresa(lcGrupoActual);

                string lcBody = " Grupo de empresa: " + GrupoEmpresa._CodigoGrupoActual() + " - " + _oGrupoEmpresa._Nombre.ToString().Trim() + "<br>" +
                                (datos._IsCentral ? "Sucursal destino: " + datos._Sucursal + " - " + DB.SQLValor("SUCURSALES", "CODIGO", datos._Sucursal, "NOMBRE", "OFFLINE").ToString() : "Central") + "<br><br>" +
                                lcMensajeEnvio;

                loSendMail._Body = lcBody;

                loSendMail._EnvioDirecto = true;
                loSendMail._ShowEmailForm = false;
                loSendMail._CCOUsuarioActivo = false;

                _ObtenerConfiguracionEmail(loSendMail); //Task 202603

                // Adjuntar fichero Comunicaciones
                string cRuta = TempFolderName;

                Log_comoffDto logDto = logRepository.GetDto(datos);
                logDto.TipoDato = "01";

                try
                {
                    using (RegistroComunicaciones loLogCom = new RegistroComunicaciones(datos._Log_ComoffID))
                    {

                        cRuta = Path.Combine(cRuta, loLogCom._NombreFicheroExportar);
                        loLogCom._Exportar(ew.listados.Clases.Listados.ExportType.pdf, cRuta, false, "REG_COMU");

                        loSendMail._AddAttachment(cRuta + ".pdf");
                    }
                }
                catch (Exception)
                {
                    logDto.Resultado = 2;
                    logDto.Detalle = "No se ha podido adjuntar el fichero PDF.";
                    logRepository.Insert(logDto);
                }

                if (!loSendMail._Send() && !string.IsNullOrWhiteSpace(loSendMail._Error_Message))
                {
                    //En caso de que haya dado un error en el envío del email y estemos en modo de tarea programada, guardamos una notificación de Sage 50
                    //FUNCTIONS._Notificacion("Sage 50 – Envío de datos", "Incidencia en envío de email del envío de datos.",
                    //"No se ha enviado correctamente el email de el envío de datos del grupo " + GrupoEmpresa._CodigoGrupoActual(), tcIcono: "warning");
                    logDto.Resultado = 3;
                    logDto.Detalle = "Fallo al realizar envío de mail de notificación de envío de datos. Revise en el mantenimiento de grupos de empresa, los datos de configuración en pestaña Configuración notificaciones del Add-on Comunicaciones offline.";
                }
                else
                {
                    logDto.Resultado = 1;
                    logDto.Detalle = "Enviado email de notificación de envío correctamente.";
                }
                logRepository.Insert(logDto);

                if (loSendMail._EnvioDirecto && File.Exists(cRuta + ".pdf"))
                {
                    File.Delete(cRuta + ".pdf");
                }
            }
        }

        private static string Envio_Articulos_Sucursal(OfflineDatosComunicaciones datos, string lcTabla)
        {
            string lcCampo = string.Empty;

            switch (lcTabla)
            {
                case "ARTICULO":
                case "MULTICAM":
                    lcCampo = "CODIGO";
                    break;

                case "HISSERIE":
                    // No existe el campo artículo en la tabla HISSERIE
                    return "";

                default:
                    lcCampo = "ARTICULO";
                    break;
            }

            return " AND b." + lcCampo + " IN (SELECT ARTICULO FROM [" + datos._BdOffline + "].dbo.sucurart WHERE SUCURSAL = " + DB.SQLString(datos._Sucursal) + ") ";
        }

        private static string Envio_Series_Sucursal(OfflineDatosComunicaciones datos)
        {
            return " AND a.codigo IN (SELECT LETRA FROM [" + datos._BdOffline + "].dbo.sucurlet WHERE SUCURSAL = " + DB.SQLString(datos._Sucursal) + ") ";
        }

        private static string Envio_Cajas_Sucursal(OfflineDatosComunicaciones datos)
        {
            return " AND a.codigo IN (SELECT CAJA FROM [" + datos._BdOffline + "].dbo.sucurcaja WHERE SUCURSAL = " + DB.SQLString(datos._Sucursal) + ") ";
        }

        private static void Actualizar_Fecha_Envio_Sucursales(OfflineDatosComunicaciones datos, string cTipoEnvio, ILog_comoffRepository logRepository)
        {
            // i -> Carga Inicial    
            // e -> Envío de datos
            string lcCampo = (cTipoEnvio == "i" ? "CARGAINI" : "ULTFECENV");
            string lcTipoEnvio = (cTipoEnvio == "i" ? "la carga inicial" : "datos");

            _TextStepDetalle = "Actualizando la fecha de envío de las sucursales";
            _TextStepProgreso = _TextStepDetalle;
            _PorcenProgreso = IncrementarBarraProgreso();

            DB.SQLExec("UPDATE " + DB.SQLDatabase("OFFLINE", "SUCURSALES") +
                        " SET " + lcCampo + " = " + DB.SQLString(DateTime.Now) + ", MODIFIED = MODIFIED " +
                        " WHERE CODIGO = " + DB.SQLString(datos._Sucursal));

            Log_comoffDto logDto = logRepository.GetDto(datos);
            logDto.TipoDato = "01";
            logDto.Resultado = 1;
            logDto.Detalle = "Envío de " + lcTipoEnvio + " finalizado correctamente.";
            logRepository.Insert(logDto);
        }



        private static void Actualizar_Fecha_Envio_Multiconf(OfflineDatosComunicaciones datos)
        {
            string lcCampo = "ULTFECENV";
            
            DB.SQLExec("UPDATE " + DB.SQLDatabase("OFFLINE", "MULTCONF") +
                        " SET " + lcCampo + " = " + DB.SQLString(DateTime.Now) + ", MODIFIED = MODIFIED " +
                        " WHERE IDCONF = " + DB.SQLString(datos._IdConf));
        }

        


        

        private static void Actualizar_Ultima_Fecha_Envio(int tnId)
        {
            DateTime dtUltFecEnv = DateTime.Now;
            string lcWhere = " WHERE ID = " + DB.SQLString(tnId);

            string lcSql = " IF EXISTS " + Environment.NewLine +
                " ( SELECT ID FROM " + DB.SQLDatabase("OFFLINE", "TABNETFEC") + lcWhere + " ) " + Environment.NewLine +
                    " BEGIN " + Environment.NewLine +
                        " UPDATE " + DB.SQLDatabase("OFFLINE", "TABNETFEC") +
                        " SET ULTFECENV = " + DB.SQLString(dtUltFecEnv) +
                        lcWhere + Environment.NewLine +
                        " AND ULTFECENV < " + DB.SQLString(dtUltFecEnv) + Environment.NewLine +
                    " END " + Environment.NewLine +
                    " ELSE " + Environment.NewLine +
                    " BEGIN" + Environment.NewLine +
                        "Insert Into " + DB.SQLDatabase("OFFLINE", "TABNETFEC") +
                        "(ID, ULTFECENV) " +
                        "Values(" +
                            DB.SQLString(tnId) + ", " + DB.SQLString(dtUltFecEnv) + ")" +
                    " END ";

            DB.SQLExec(lcSql);

        }

        private static void Gestionar_Tabla_Control(DataTable table, OfflineDatosComunicaciones datos, RegistroTabRel registro, bool tlPrioridad, int tnId, string tcTipoDato, DataRow itemRow, Dictionary<string, bool> dicTablas, ILog_comoffRepository logRepository)
        {
            DataTable tablaDatosNuevos = new DataTable();
            DataTable tablaDatosModi = new DataTable();

            string lcTablaControl = _offlineConfig.ObtenerTablaControlRelacionada(registro._DBSecundaria + "!" + registro._TablaSecundaria);

            if (!string.IsNullOrWhiteSpace(lcTablaControl))
            {
                // Actualizar tabla de control
                string lcInnerJoin = Actualizar_Tabla_Control(table, registro._DBSecundaria + "!" + registro._TablaSecundaria, lcTablaControl, tnId, datos);

                //* Copiar tabla de la bd de offline a la bd temporal
                string lcSql = " FROM [" + datos._BdOffline + "].dbo." + lcTablaControl + " a " +  lcInnerJoin + " WHERE 1=1 ";

                string lcCampoEmpresa = registro._Empresa;

                clsOfflineUtils.RevisarTablasCampoEmpresa(registro._TablaSecundaria, ref lcCampoEmpresa);

                // Casos especiales
                if (datos._EnvioArticulos && ((registro._DBSecundaria + "!" + registro._TablaSecundaria) == "GESTION!ARTICULO" || registro._Clave == "STOCKINI" || registro._Clave == "STOCKS"))
                {
                    lcSql += Envio_Articulos_Sucursal(datos, registro._TablaSecundaria);
                }

                if (datos._IsCentral && registro._DBPrincipal + "!" + registro._TablaPrincipal == "COMUNES!LETRAS")
                {
                    lcSql += Envio_Series_Sucursal(datos);
                }

                string lcFiltrePrincipal = string.Empty;
                if (!string.IsNullOrWhiteSpace(registro._CondEnv))
                {
                    if (registro._TablaPrincipal == registro._TablaSecundaria)
                    {
                        lcFiltrePrincipal = registro._CondEnv;
                        lcFiltrePrincipal = _offlineConfig.ConstruirFiltroAlmacen(lcFiltrePrincipal, datos._Sucursal, datos._Almacenes, registro._TablaSecundaria);
                        lcFiltrePrincipal = _offlineConfig.ConstruirFiltroLetra(lcFiltrePrincipal, datos._Sucursal, datos._Series);
                        lcFiltrePrincipal = _offlineConfig.ConstruirFiltroCaja(lcFiltrePrincipal, datos._Sucursal, datos._Cajas);

                        lcFiltrePrincipal = lcFiltrePrincipal.Replace("{TABLA}", "b.");

                        lcSql = lcSql + " AND " + lcFiltrePrincipal;
                    }
                }

                if (!string.IsNullOrWhiteSpace(registro._CondSecun))
                {
                    if (registro._TablaPrincipal != registro._TablaSecundaria)
                    {
                        lcFiltrePrincipal = registro._CondSecun;
                        lcFiltrePrincipal = _offlineConfig.ConstruirFiltroAlmacen(lcFiltrePrincipal, datos._Sucursal, datos._Almacenes, registro._TablaSecundaria);
                        lcFiltrePrincipal = _offlineConfig.ConstruirFiltroLetra(lcFiltrePrincipal, datos._Sucursal, datos._Series);
                        lcFiltrePrincipal = _offlineConfig.ConstruirFiltroCaja(lcFiltrePrincipal, datos._Sucursal, datos._Cajas);

                        lcFiltrePrincipal = lcFiltrePrincipal.Replace("{TABLA}", "b.");

                        lcSql = lcSql + " AND " + lcFiltrePrincipal;
                    }
                }

                //Copiar només els registres de les empreses no excloses
                if (!string.IsNullOrWhiteSpace(lcCampoEmpresa))
                {
                    lcSql = lcSql + " AND a." + lcCampoEmpresa + " NOT IN (SELECT empresa FROM [" + datos._BdOffline + "].dbo.empexclu) ";
                }

                // No se van a enviar tablas de control con los ficheros _MODIFIED.
                //if (Convert.ToBoolean(registro._Prioridad))
                //{
                //    registro._Sufijo = "_MODIFIED";

                //    ProcesoActualizarCtrl(itemRow, datos, registro, dicTablas, lcSql, lcTablaControl, logRepository);
                //}

                //registro._Sufijo = "_CREATED";

                ProcesoActualizarCtrl(itemRow, datos, registro, dicTablas, lcSql, lcTablaControl, logRepository);
            }
        }

        private static void ProcesoActualizarCtrl(DataRow itemRow, OfflineDatosComunicaciones datos, RegistroTabRel registro, Dictionary<string, bool> dicTablas, string tcSql, string lcTablaControl, ILog_comoffRepository logRepository)
        {
            DataTable dtDatos = new DataTable();
            string lcTipoDato = clsOfflineUtils.ObtenerTipoDato(registro._Clave);
            string lcSqlCondicion = string.Empty;

            // No se van a enviar tablas de control con los ficheros _MODIFIED.
            //if (registro._Sufijo == "_MODIFIED")
            //{
            //    string lcSufijo = string.Empty;
            //    string[] subPos = registro._Sufijo.Split('_');
            //    if (subPos.Length == 2)
            //        lcSufijo = subPos[1].TrimEnd();

            //    lcSqlCondicion = " AND a." + lcSufijo + " >= " + DB.SQLString(datos._FechaInicial) + " AND a." + lcSufijo + " <= " + DB.SQLString(datos._FechaFinal);
            //    lcSqlCondicion += " AND (a.CREATED < " + DB.SQLString(datos._FechaInicial) + " OR a.CREATED > " + DB.SQLString(datos._FechaFinal) + ")";
            //}
            //else
            //{

            //}

            lcSqlCondicion = " AND a.CREATED >= " + DB.SQLString(datos._FechaInicial) + " AND a.CREATED <= " + DB.SQLString(datos._FechaFinal);

            string lcSql = " SELECT a.* " + tcSql + lcSqlCondicion;

            if (!DB.SQLExec(lcSql, ref dtDatos))
            {
                Log_comoffDto logDto = logRepository.GetDto(datos);
                logDto.TipoDato = lcTipoDato;
                logDto.Resultado = 3;
                logDto.Detalle = "No se ha podido ejecutar la instrucción " + lcSql + ".";
                logRepository.Insert(logDto);
            }

            if (dtDatos.Rows.Count > 0)
            {
                if (clsOfflineUtils.ExisteTablaOffline("[" + _cRaizDataBaseTemporal + "OFFLINE" + "].dbo.[" + lcTablaControl + registro._Sufijo + "]"))
                {
                    using (SqlBulkCopy bulkCopy = new SqlBulkCopy(DB.Conexion))
                    {
                        bulkCopy.DestinationTableName = "[" + _cRaizDataBaseTemporal + "OFFLINE" + "].dbo.[" + lcTablaControl + registro._Sufijo + "]";

                        foreach (DataColumn column in dtDatos.Columns)
                        {
                            bulkCopy.ColumnMappings.Add(column.ColumnName.ToUpper(), column.ColumnName.ToUpper());
                        }

                        // Write from the source to the destination.
                        try
                        {
                            bulkCopy.WriteToServer(dtDatos);
                        }
                        catch (Exception)
                        {
                            bulkCopy.ColumnMappings.Clear();
                            bulkCopy.WriteToServer(dtDatos);
                        }
                    }
                }
                else
                {
                    if (!clsOfflineUtils.ExisteDatabaseOffline(_cRaizDataBaseTemporal + "OFFLINE"))
                    {
                        CrearDataTable("OFFLINE", _cRaizDataBaseTemporal);
                    }

                    lcSql = " SELECT a.* INTO [" + _cRaizDataBaseTemporal + "OFFLINE" + "].dbo.[" + lcTablaControl + registro._Sufijo + "]" +
                        tcSql + lcSqlCondicion;
                    DB.SQLExec(lcSql);
                }

                ProcesoActualizarControlEspecial(registro, lcTablaControl, datos);

                RegistroDatos(datos, itemRow, datos._BdOffline, registro._TablaSecundaria, lcTablaControl, dtDatos, registro._Sufijo, logRepository);
                dicTablas[itemRow[0].ToString()] = true;
            }
        }

        private static void Gestionar_Tabla_DeleteNet(DataTable dtDeleteNet, OfflineDatosComunicaciones datos, string tcBdTabla, Dictionary<string, DataTable> dicDt, RegistroTabRel registro)
        {
            if (!datos._Delete_Mantes && registro._TipoTabla == 1)
            {
                return;
            }

            if (!datos._Delete_Documentos && registro._TipoTabla == 2)
            {
                return;
            }

            DataTable tablaDatos = new DataTable();

            string lcAny = EW_GLOBAL._GetVariable("wc_any").ToString();

            string lcBd = string.Empty;
            string lcTabla = string.Empty;

            string[] subPos = tcBdTabla.Split('!');
            if (subPos.Length == 2)
            {
                lcBd = subPos[0].TrimEnd();
                lcTabla = subPos[1].TrimEnd();
            }

            string lcSql = " SELECT * FROM [" + datos._BdOffline + "].dbo." + "DELETENET" +
                           " WHERE DB = " + DB.SQLString(lcBd) + " AND TABLA = " + DB.SQLString(lcTabla) + " AND EJERCICIO = " + DB.SQLString(lcAny) +
                           (!string.IsNullOrWhiteSpace(registro._Clave) ? " AND CLAVETAB = " + DB.SQLString(registro._Clave) : " ") +
                           " AND CREATED >= " + DB.SQLString(datos._FechaInicial) + " AND CREATED <= " + DB.SQLString(datos._FechaFinal);

            if (DB.SQLExec(lcSql, ref tablaDatos))
            {
                foreach (DataRow loRow in tablaDatos.Rows)
                {
                    DataRow newRow = dtDeleteNet.NewRow();
                    newRow["id"] = loRow["id"];
                    newRow["clavetab"] = loRow["clavetab"];
                    newRow["db"] = loRow["db"];
                    newRow["tabla"] = loRow["tabla"];
                    newRow["ejercicio"] = loRow["ejercicio"];
                    newRow["orden"] = loRow["orden"];
                    newRow["tipo"] = loRow["tipo"];
                    newRow["sql"] = loRow["sql"];
                    newRow["guid_id"] = loRow["guid_id"];
                    newRow["created"] = loRow["created"];
                    newRow["modified"] = loRow["modified"];
                    newRow["vista"] = loRow["vista"];
                    newRow["checksum"] = loRow["checksum"];
                    dtDeleteNet.Rows.Add(newRow);

                    if (!string.IsNullOrWhiteSpace(registro._Compras))
                    {
                        // Parsear la query del delete
                        string lcSerie = string.Empty;
                        string lcQuery = loRow["sql"].ToString();
                        int lnPos = lcQuery.ToUpper().IndexOf(registro._Compras);
                        DataTable ldtDatosCompras = new DataTable();


                        if (lnPos > 0)
                        {
                            lcQuery = lcQuery.Substring(lnPos);

                            string[] stringSerie = lcQuery.Split('\'');
                            if (stringSerie.Length >= 2)
                            {
                                lcSerie = stringSerie[1];

                                ComprobarTablaTemporalSQL(registro, "COMUNES", "COMPRAS");

                                // Montem la consulta per agafar les línies dels assentaments
                                lcSql = " SELECT A.* " +
                                        " FROM " + DB.SQLDatabase("COMUNES", "COMPRAS") + " A " +
                                        " WHERE A.SERIE = " + DB.SQLString(lcSerie);

                                // Executem la consulta
                                DB.SQLExec(lcSql, ref ldtDatosCompras);

                                if (ldtDatosCompras != null && ldtDatosCompras.Rows.Count > 0)
                                {
                                    InsertarDatosBulkMode(ldtDatosCompras, "[" + _cRaizDataBaseTemporal + "COMUNES].dbo.[COMPRAS" + registro._Sufijo + "]");
                                }
                            }
                        }
                    }
                }

                // Eliminamos la tabla que tenemos salvada en el diccionario y guardamos de nuevo actualizada
                if (tablaDatos != null && tablaDatos.Rows.Count > 0)
                { 
                    dicDt.Remove("DELETENET");
                    dicDt.Add("DELETENET", dtDeleteNet);
                }
            }
        }

        private static void GenerarFicherosXML_Series(OfflineDatosComunicaciones datos, ILog_comoffRepository logRepository)
        {
            // Add-on Comunicaciones Offline – Release 7730 y 7740
            // 17.2.1   Contadores de documento configuradas en la sucursal
            // Según series configuradas en la sucursal que realiza el envío de datos(Registros en tabla SUCURLET) enviar los contadores de dichas series:
            // Registros de tabla SERIES de todas las series de documento configuradas en la sucursal. SUCURLET.LETRA = SERIES.SERIE.

            if (!datos._IsCentral)   // Sucursal
            {
                DataTable tablaDatos = new DataTable();
                string lcSql = string.Empty;

                _TextStepDetalle = "Generando fichero Series.xml";
                _TextStepProgreso = _TextStepDetalle;
                _PorcenProgreso = IncrementarBarraProgreso();

                Log_comoffDto logDto = logRepository.GetDto(datos);
                logDto.TipoDato = "01";
                logDto.Resultado = 1;
                logDto.Detalle = "Actualizados contadores de series de documentos de la sucursal " + datos._Sucursal + ".";
                logRepository.Insert(logDto);

                lcSql += " SELECT * FROM " + DB.SQLDatabase("GESTION", "SERIES") +
                         " WHERE SERIE IN ( SELECT LETRA FROM " + DB.SQLDatabase("OFFLINE","SUCURLET") + " WHERE SUCURSAL = " + DB.SQLString(datos._Sucursal) + " ) " +
                         " AND MODIFIED >= " + DB.SQLString(datos._FechaInicial) + " AND MODIFIED <= " + DB.SQLString(datos._FechaFinal) +
                         " AND (CREATED < " + DB.SQLString(datos._FechaInicial) + " OR CREATED > " + DB.SQLString(datos._FechaFinal) + " ) ";

                lcSql += " UNION ALL ";

                lcSql += " SELECT * FROM " + DB.SQLDatabase("GESTION", "SERIES") +
                         " WHERE SERIE IN ( SELECT LETRA FROM " + DB.SQLDatabase("OFFLINE", "SUCURLET") + " WHERE SUCURSAL = " + DB.SQLString(datos._Sucursal) + " ) " +
                         " AND CREATED >= " + DB.SQLString(datos._FechaInicial) + " AND CREATED <= " + DB.SQLString(datos._FechaFinal);

                DB.SQLExec(lcSql, ref tablaDatos);

                if (tablaDatos.Rows.Count > 0)
                {
                    ConvertIndividualFile(tablaDatos, TempFolderName, "SERIES", FormatoExportacion.XML);
                }
            }
        }

        private static string Actualizar_Tabla_Control(DataTable table, string tcBdTabla, string tcTablaControl, int tnId, OfflineDatosComunicaciones datos)
        {
            string lcSql = string.Empty;
            string lcWhere = string.Empty;
            string lcInsert = string.Empty;
            string lcAux = string.Empty;
            string lcAny = EW_GLOBAL._GetVariable("wc_any").ToString();
            string lcSet = " Set ORIGEN = " + (datos._IsCentral ? DB.SQLString("CENTRAL") : DB.SQLString(datos._Sucursal)) + ", MODIFIED = " + DB.SQLString(DateTime.Now);
            string lcOrigen = (datos._IsCentral ? "CENTRAL" : datos._Sucursal);

            string lcInnerJoin = string.Empty;
            string lcBd = string.Empty;
            string lcTabla = string.Empty;

            string[] subPos = tcBdTabla.Split('!');
            if (subPos.Length == 2)
            {
                lcBd = subPos[0].TrimEnd();
                lcTabla = subPos[1].TrimEnd();
            }

            foreach (DataRow item in table.Rows)
            {
                switch (lcTabla)
                {
                    case "COLORES":
                    case "TALLAS":
                    case "GRUPCOLO":
                    case "GRUPTALL":
                    case "TCP":
                    case "CLASIF":
                    case "LETRAS":
                    case "OBRA":
                    case "SUPLIDOS":
                    case "CAJAS":
                    case "DEFVALES":
                    case "CONCEP":
                    case "EMPLEADO":
                    case "MAND_CONCE":
                    case "F_COBROS":
                    case "TIPO_REG":

                        lcWhere = " WHERE CODIGO = " + DB.SQLString(item.Field<string>("codigo"));

                        lcInsert = "(CODIGO, ORIGEN) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("codigo")) + ", " + DB.SQLString(lcOrigen) + ")";

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.CODIGO = B.CODIGO ";

                        break;

                    case "G_CONTRI":
                    case "MODREFEC":
                        
                        lcWhere = " WHERE CODIGO = " + DB.SQLString(item.Field<string>("codigo"));

                        lcInsert = "(CODIGO, EJERCICIO, ORIGEN) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("codigo")) + ", " + DB.SQLString(lcAny) + ", " + DB.SQLString(lcOrigen) + ")";


                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.CODIGO = B.CODIGO ";

                        break;

                    case "FACTORPTOS":
                        lcWhere = " WHERE CLIENTE = " + DB.SQLString(item.Field<string>("cliente")) +
                                    " AND ARTICULO = " + DB.SQLString(item.Field<string>("articulo")) +
                                    " AND FAMILIA = " + DB.SQLString(item.Field<string>("familia")) +
                                    " AND SUBFAMILIA = " + DB.SQLString(item.Field<string>("subfamilia")) +
                                    " AND MARCA = " + DB.SQLString(item.Field<string>("marca")) +
                                    " AND ACTIVIDAD = " + DB.SQLString(item.Field<string>("actividad")) +
                                    " AND TARIFA = " + DB.SQLString(item.Field<string>("tarifa")) +
                                    " AND CATALOGO = " + item.Field<int>("catalogo") +
                                    " AND LINEA = " + item.Field<int>("linea");

                        lcInsert = "(CLIENTE, ARTICULO, FAMILIA, SUBFAMILIA, MARCA, ACTIVIDAD, TARIFA, CATALOGO, LINEA, ORIGEN, IDTABREL) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("cliente")) + ", " + DB.SQLString(item.Field<string>("articulo")) + ", " + 
                                        DB.SQLString(item.Field<string>("familia")) + ", " + DB.SQLString(item.Field<string>("subfamilia")) + ", " + 
                                        DB.SQLString(item.Field<string>("marca")) + ", " + DB.SQLString(item.Field<string>("actividad")) + ", " + 
                                        DB.SQLString(item.Field<string>("tarifa")) + ", " + item.Field<int>("catalogo") + ", " +
                                        item.Field<int>("linea") + ", " + DB.SQLString(lcOrigen) + ", " + DB.SQLString(tnId) + ")";

                        break;

                    case "ASIENTOS":

                        lcWhere = " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                                    " AND NUMERO = " + DB.SQLString(item.Field<int>("numero")) +
                                    " AND LINEA = " + DB.SQLString(item.Field<int>("linea")) +
                                    " AND EJERCICIO = " + DB.SQLString(lcAny);

                        lcInsert = "(EMPRESA, NUMERO, LINEA, EJERCICIO, ORIGEN, IDTABREL) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<int>("numero")) + ", " + DB.SQLString(item.Field<int>("linea")) + ", " +
                                        DB.SQLString(lcAny) + ", " + DB.SQLString(lcOrigen) + ", " + DB.SQLString(tnId) + ")";

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.EMPRESA = B.EMPRESA AND A.NUMERO = B.NUMERO AND A.LINEA = B.LINEA ";

                        switch (tnId)
                        {
                            case 7:
                            case 96:
                                // COBROS, PAGOS Y ASIENTOS RELACIONADOS             
                                lcInnerJoin += " INNER JOIN " + DB.SQLDatabase("TPV", "TIKETS") + " C ON B.EMPRESA = C.EMPRESA AND B.ASI = C.ASI ";
                                break;

                            case 9:
                            case 98:
                                // REPOSICIONES Y ASIENTOS RELACIONADOS              
                                lcInnerJoin += " INNER JOIN " + DB.SQLDatabase("TPV", "REPOSI") + " C ON B.EMPRESA = C.EMPRESA AND B.ASI = C.ASI ";
                                break;

                            case 68:
                            case 301:
                            case 326:
                                // ASIENTO DE FACTURA DE VENDA
                                lcInnerJoin += " INNER JOIN " + DB.SQLDatabase("GESTION", "C_ALBVEN") + " C ON B.EMPRESA = C.EMPRESA AND B.ASI = C.ASI ";
                                break;

                            case 74:
                            case 99:
                                // RETIROS DE CAJA Y ASIENTOS RELACIONADOS           
                                lcInnerJoin += " INNER JOIN " + DB.SQLDatabase("TPV", "COB_PAGO") + " C ON B.EMPRESA = C.EMPRESA AND B.ASI = C.ASI ";
                                break;

                            case 113:
                            case 318:
                                // ENTREGAS A CUENTA DE CLIENTES/PROVEEDORES                     
                                lcInnerJoin += " INNER JOIN " + DB.SQLDatabase("GESTION", "ENTRE_CL") + " C ON B.EMPRESA = C.EMPRESA AND B.ASI = C.ASI ";
                                break;

                            case 216:
                                // ASIENTO DE FACTURA DE COMPRA
                                lcInnerJoin += " INNER JOIN " + DB.SQLDatabase("GESTION", "C_ALBCOM") + " C ON B.EMPRESA = C.EMPRESA AND B.ASI = C.ASI ";
                                break;

                            case 285:
                                // ASIENTO DE FACTURA TRANSITARIO
                                lcInnerJoin += " INNER JOIN " + DB.SQLDatabase("GESTION", "C_TRANSDUA") + " C ON B.EMPRESA = C.EMPRESA AND B.ASI = C.ASI_TRANS ";
                                break;

                            case 286:
                                // ASIENTO DE FACTURA DUA
                                lcInnerJoin += " INNER JOIN " + DB.SQLDatabase("GESTION", "C_TRANSDUA") + " C ON B.EMPRESA = C.EMPRESA AND B.ASI = C.ASI_DUA ";
                                break;

                        }

                        break;

                    case "C_FORMUL":

                        lcWhere = " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                                    " AND ARTICULO = " + DB.SQLString(item.Field<string>("articulo"));

                        lcInsert = "(EMPRESA, ARTICULO, ORIGEN) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<string>("articulo")) + ", " +
                                        DB.SQLString(lcOrigen) + ")";

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.EMPRESA = B.EMPRESA AND A.ARTICULO = B.ARTICULO ";

                        break;

                    case "CANALES":

                        lcWhere = " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                                    " AND CODIGO = " + DB.SQLString(item.Field<string>("codigo"));

                        lcInsert = "(EMPRESA, CODIGO, ORIGEN) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<string>("codigo")) + ", " +
                                        DB.SQLString(lcOrigen) + ")";

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.EMPRESA = B.EMPRESA AND A.CODIGO = B.CODIGO ";

                        break;

                    case "PLEFACT_C":

                        lcWhere = " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                                    " AND CODIGO = " + DB.SQLString(item.Field<string>("codigo"));

                        lcInsert = "(EMPRESA, CODIGO, EJERCICIO, ORIGEN) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<string>("codigo")) + ", " +
                                        DB.SQLString(lcAny) + ", " + DB.SQLString(lcOrigen) + ")";

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.EMPRESA = B.EMPRESA AND A.CODIGO = B.CODIGO ";

                        break;

                    case "IDIOMA":

                        lcWhere = " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                                    " AND CODIGO = " + DB.SQLString(item.Field<string>("codigo")) +
                                    " AND EJERCICIO = " + DB.SQLString(lcAny);

                        lcInsert = "(EMPRESA, CODIGO, EJERCICIO, ORIGEN) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<string>("codigo")) + ", " +
                                        DB.SQLString(lcAny) + ", " + DB.SQLString(lcOrigen) + ")";

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.EMPRESA = B.EMPRESA AND A.CODIGO = B.CODIGO ";

                        break;

                    case "CONIRPF":

                        lcWhere = " WHERE CONIRPF = " + DB.SQLString(item.Field<string>("conirpf")) +
                                    " AND CONGASING = " + DB.SQLString(item.Field<string>("congasing")) +
                                    " AND EJERCICIO = " + DB.SQLString(lcAny);

                        lcInsert = "(CONIRPF, CONGASING, EJERCICIO, ORIGEN) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("conirpf")) + ", " + DB.SQLString(item.Field<string>("congasing")) + ", " +
                                        DB.SQLString(lcAny) + ", " + DB.SQLString(lcOrigen) + ")";

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.CONIRPF = B.CONIRPF AND A.CONGASING = B.CONGASING ";

                        break;

                    case "OFERTAS":

                        lcWhere = " WHERE ARTICULO = " + DB.SQLString(item.Field<string>("articulo")) +
                                    " AND CLIENTE = " + DB.SQLString(item.Field<string>("cliente")) +
                                    " AND LINEA = " + DB.SQLString(item.Field<int>("linea")) +
                                    " AND EJERCICIO = " + DB.SQLString(lcAny);

                        lcInsert = "(ARTICULO, CLIENTE, LINEA, EJERCICIO, ORIGEN) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("articulo")) + ", " + DB.SQLString(item.Field<string>("cliente")) + ", " +
                                        DB.SQLString(item.Field<int>("linea")) + ", " + DB.SQLString(lcAny) + ", " + DB.SQLString(lcOrigen) + ")";

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.ARTICULO = B.ARTICULO AND A.CLIENTE = B.CLIENTE AND A.LINEA = B.LINEA ";

                        break;

                    case "PREVI_CL":

                        lcWhere = " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                                    " AND PERIODO = " + DB.SQLString(item.Field<int>("periodo")) +
                                    " AND FACTURA = " + DB.SQLString(item.Field<string>("factura")) +
                                    " AND ORDEN = " + DB.SQLString(item.Field<int>("orden")) +
                                    " AND IMPAGADO = " + DB.SQLString(item.Field<int>("impagado")) +
                                    " AND PENDIENTE = " + DB.SQLString(item.Field<decimal>("pendiente"));

                        lcInsert = "(EMPRESA, PERIODO, FACTURA, ORDEN, IMPAGADO, PENDIENTE, ORIGEN, IDTABREL) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<int>("periodo")) + ", " +
                                        DB.SQLString(item.Field<string>("factura")) + ", " + DB.SQLString(item.Field<int>("orden")) + ", " +
                                        DB.SQLString(item.Field<int>("impagado")) + ", " + DB.SQLString(item.Field<decimal>("pendiente")) + ", " +
                                        DB.SQLString(lcOrigen) + ", " + DB.SQLString(tnId) + ")";

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.EMPRESA = B.EMPRESA AND A.PERIODO = B.PERIODO " +
                                            " AND A.FACTURA = B.FACTURA AND A.ORDEN = B.ORDEN AND A.IMPAGADO = B.IMPAGADO AND A.PENDIENTE = B.PENDIENTE ";

                        break;

                    case "PREVIS":

                        lcWhere = " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                                    " AND YEAR(EMISION) = " + DB.SQLString(item.Field<int>("periodo")) +
                                    " AND PROVEEDOR = " + DB.SQLString(item.Field<string>("proveedor")) +
                                    " AND FACTURA = " + DB.SQLString(item.Field<string>("factura")) +
                                    " AND NUMEREB = " + DB.SQLString(item.Field<int>("numereb")) +
                                    " AND PENDIENTE = " + DB.SQLString(item.Field<int>("pendiente"));

                        lcInsert = "(EMPRESA, EMISION, PROVEEDOR, FACTURA, NUMEREB, PENDIENTE, ORIGEN, IDTABREL) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<DateTime>("emision")) + ", " +
                                        DB.SQLString(item.Field<string>("proveedor")) + ", " + DB.SQLString(item.Field<string>("factura")) + ", " +
                                        DB.SQLString(item.Field<int>("numereb")) + ", " + DB.SQLString(item.Field<int>("pendiente")) + ", " +
                                        DB.SQLString(lcOrigen) + ", " + DB.SQLString(tnId) + ")";

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.EMPRESA = B.EMPRESA AND A.EMISION = B.EMISION " +
                                            " AND A.PROVEEDOR = B.PROVEEDOR AND A.FACTURA = B.FACTURA AND A.NUMEREB = B.NUMEREB AND A.PENDIENTE = B.PENDIENTE ";

                        break;

                    case "STOCKINI":

                        lcWhere = " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                                    " AND FECHA = " + DB.SQLString(item.Field<DateTime>("fecha")) +
                                    " AND ALMACEN = " + DB.SQLString(item.Field<string>("almacen")) +
                                    " AND ARTICULO = " + DB.SQLString(item.Field<string>("articulo")) +
                                    " AND LINIA = " + DB.SQLString(item.Field<int>("linia")) +
                                    " AND EJERCICIO = " + DB.SQLString(lcAny);

                        lcInsert = "(EMPRESA, FECHA, ALMACEN, ARTICULO, LINIA, EJERCICIO, ORIGEN) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<DateTime>("fecha")) + ", " +
                                        DB.SQLString(item.Field<string>("almacen")) + ", " + DB.SQLString(item.Field<string>("articulo")) + ", " +
                                        DB.SQLString(item.Field<int>("linia")) + ", " + DB.SQLString(lcAny) + ", " +
                                        DB.SQLString(lcOrigen) + ")";

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.EMPRESA = B.EMPRESA AND A.FECHA = B.FECHA " +
                                            " AND A.ALMACEN = B.ALMACEN AND A.ARTICULO = B.ARTICULO AND A.LINIA = B.LINIA ";

                        break;

                    case "C_PLANT":
                    case "SECCIONES":

                        lcWhere = " WHERE CODIGO = " + DB.SQLString(item.Field<string>("codigo")) + " AND EJERCICIO = " + DB.SQLString(lcAny);

                        lcInsert = "(CODIGO, EJERCICIO, ORIGEN, IDTABREL) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("codigo")) + ", " + DB.SQLString(lcAny) + ", " + DB.SQLString(lcOrigen) + ", " + DB.SQLString(tnId) + ")";


                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.CODIGO = B.CODIGO ";

                        break;

                    case "C_ALBVEN":
                    case "C_ALBDEP":
                    case "C_PEDIVE":
                    case "C_PRESUV":

                        lcWhere = " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                                    " AND NUMERO = " + DB.SQLString(item.Field<string>("numero")) +
                                    " AND LETRA = " + DB.SQLString(item.Field<string>("letra")) +
                                    " AND EJERCICIO = " + DB.SQLString(lcAny);

                        if (lcTabla == "C_ALBVEN")
                        {
                            lcInsert = "(EMPRESA, NUMERO, LETRA, EJERCICIO, ORIGEN, IDTABREL) " +
                                        "Values(" +
                                            DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<string>("numero")) + ", " +
                                            DB.SQLString(item.Field<string>("letra")) + ", " + DB.SQLString(lcAny) + ", " +
                                            DB.SQLString(lcOrigen) + ", " + DB.SQLString(tnId) + ")";
                        }
                        else
                        {
                            lcInsert = "(EMPRESA, NUMERO, LETRA, EJERCICIO, ORIGEN) " +
                                        "Values(" +
                                            DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<string>("numero")) + ", " +
                                            DB.SQLString(item.Field<string>("letra")) + ", " + DB.SQLString(lcAny) + ", " +
                                            DB.SQLString(lcOrigen) + ")";
                        }

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.EMPRESA = B.EMPRESA AND A.NUMERO = B.NUMERO AND A.LETRA = B.LETRA ";

                        break;

                    case "C_FACTUVEN":
                    case "C_ALBARE":
                    case "C_ALBATR":
                    case "C_DEPCOM":
                    case "C_PEDICO":
                    case "C_PRECOM":
                    case "C_PROD":
                    case "C_TRANS":

                        lcWhere = " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                                    " AND NUMERO = " + DB.SQLString(item.Field<string>("numero")) +
                                    " AND EJERCICIO = " + DB.SQLString(lcAny);

                        if (lcTabla == "C_FACTUVEN")
                        {
                            lcInsert = "(EMPRESA, NUMERO, EJERCICIO, ORIGEN, IDTABREL) " +
                                        "Values(" +
                                            DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<string>("numero")) + ", " +
                                            DB.SQLString(lcAny) + ", " + DB.SQLString(lcOrigen) + ", " + DB.SQLString(tnId) + ")";
                        }
                        else
                        {
                            lcInsert = "(EMPRESA, NUMERO, EJERCICIO, ORIGEN) " +
                                        "Values(" +
                                            DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<string>("numero")) + ", " +
                                            DB.SQLString(lcAny) + ", " + DB.SQLString(lcOrigen) + ")";
                        }

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.EMPRESA = B.EMPRESA AND A.NUMERO = B.NUMERO ";

                        if (lcTabla == "C_FACTUVEN")
                        {
                            lcInnerJoin += " INNER JOIN " + DB.SQLDatabase("GESTION", "C_ALBVEN") + " C ON B.EMPRESA = C.EMPRESA AND B.NUMERO = C.FACTURA ";
                        }

                        break;

                    case "C_ALBCOM":
                    case "C_FACTUCOM":
                    case "C_TRANSDUA":

                        lcWhere = " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                                    " AND NUMERO = " + DB.SQLString(item.Field<string>("numero")) +
                                    " AND PROVEEDOR = " + DB.SQLString(item.Field<string>("proveedor")) +
                                    " AND EJERCICIO = " + DB.SQLString(lcAny);

                        lcInsert = "(EMPRESA, NUMERO, PROVEEDOR, EJERCICIO, ORIGEN) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<string>("numero")) + ", " +
                                        DB.SQLString(item.Field<string>("proveedor")) + ", " + DB.SQLString(lcAny) + ", " + DB.SQLString(lcOrigen) + ")";

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.EMPRESA = B.EMPRESA AND A.NUMERO = B.NUMERO AND A.PROVEEDOR = B.PROVEEDOR ";

                        if (lcTabla == "C_FACTUCOM")
                        {
                            lcInnerJoin += " INNER JOIN " + DB.SQLDatabase("GESTION", "C_ALBCOM") + " C ON B.EMPRESA = C.EMPRESA AND B.NUMERO = C.FACTURA AND B.PROVEEDOR = C.PROVEEDOR ";
                        }

                        break;

                    case "ARQUEOS":

                        lcWhere = " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                                    " AND NUMERO = " + DB.SQLString(item.Field<int>("numero"));

                        lcInsert = "(EMPRESA, NUMERO, EJERCICIO, ORIGEN) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<int>("numero")) + ", " +
                                        DB.SQLString(lcAny) + ", " + DB.SQLString(lcOrigen) + ")";

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.EMPRESA = B.EMPRESA AND A.NUMERO = B.NUMERO ";

                        break;

                    case "PEDINT_C":

                        lcWhere = " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                                    " AND NUMERO = " + DB.SQLString(item.Field<string>("numero"));

                        lcInsert = "(EMPRESA, NUMERO, ORIGEN) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<string>("numero")) + ", " +
                                        DB.SQLString(lcOrigen) + ")";

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.EMPRESA = B.EMPRESA AND A.NUMERO = B.NUMERO ";

                        break;

                    case "D_PARTES":

                        lcWhere = " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                                    " AND NUMERO = " + DB.SQLString(item.Field<string>("numero")) +
                                    " AND LINIA = " + DB.SQLString(item.Field<int>("linea")) +
                                    " AND EJERCICIO = " + DB.SQLString(lcAny);

                        lcInsert = "(EMPRESA, NUMERO, LINIA, EJERCICIO, ORIGEN) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<string>("numero")) + ", " +
                                        DB.SQLString(item.Field<int>("linea")) + ", " + DB.SQLString(lcAny) + ", " + DB.SQLString(lcOrigen) + ")";

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.EMPRESA = B.EMPRESA AND A.NUMERO = B.NUMERO AND A.LINIA = B.LINEA ";

                        break;

                    case "REGULARI":

                        lcWhere = " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                                    " AND ALMACEN = " + DB.SQLString(item.Field<string>("almacen")) +
                                    " AND FECHA = " + DB.SQLString(item.Field<DateTime>("fecha")) +
                                    " AND DOCUMENTO = " + DB.SQLString(item.Field<string>("documento")) +
                                    " AND LINIA = " + DB.SQLString(item.Field<int>("linia")) +
                                    " AND EJERCICIO = " + DB.SQLString(lcAny);

                        lcInsert = "(EMPRESA, ALMACEN, FECHA, LINIA, DOCUMENTO, EJERCICIO, ORIGEN) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<string>("almacen")) + ", " +
                                        DB.SQLString(item.Field<DateTime>("fecha")) + ", " + DB.SQLString(item.Field<int>("linia")) + ", " + DB.SQLString(item.Field<string>("documento")) + ", " +
                                        DB.SQLString(lcAny) + ", " + DB.SQLString(lcOrigen) + ")";

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.EMPRESA = B.EMPRESA AND A.ALMACEN = B.ALMACEN " +
                                                                        " AND A.FECHA = B.FECHA AND A.DOCUMENTO = B.DOCUMENTO AND A.LINIA = B.LINIA ";

                        break;

                    case "VALES":

                        lcWhere = " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                                    " AND LETRA = " + DB.SQLString(item.Field<string>("letra")) +
                                    " AND TICKET = " + DB.SQLString(item.Field<string>("ticket")) +
                                    " AND ORDEN = " + DB.SQLString(item.Field<int>("orden"));

                        lcInsert = "(EMPRESA, LETRA, TICKET, ORDEN, EJERCICIO, ORIGEN) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<string>("letra")) + ", " +
                                        DB.SQLString(item.Field<string>("ticket")) + ", " + DB.SQLString(item.Field<int>("orden")) + ", " +
                                        DB.SQLString(lcAny) + ", " + DB.SQLString(lcOrigen) + ")";

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.EMPRESA = B.EMPRESA AND A.LETRA = B.LETRA AND A.TICKET = B.TICKET " +
                                                                        " AND A.ORDEN = B.ORDEN ";

                        break;

                    case "REPOSI":

                        lcAux = ", ARQUEO = " + DB.SQLString(item.Field<int>("arqueo"));

                        lcWhere = " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                                    " AND CAJA = " + DB.SQLString(item.Field<string>("caja")) +
                                    " AND MONEDA = " + DB.SQLString(item.Field<string>("moneda")) +
                                    " AND FECHA = " + DB.SQLString(item.Field<DateTime>("fecha")) +
                                    " AND OPERARIO = " + DB.SQLString(item.Field<string>("operario")) +
                                    //" AND ARQUEO = " + DB.SQLString(item.Field<int>("arqueo")) +
                                    " AND LINEA = " + DB.SQLString(item.Field<int>("linea"));

                        lcInsert = "(EMPRESA, CAJA, MONEDA, FECHA, OPERARIO, ARQUEO, LINEA, ORIGEN) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<string>("caja")) + ", " +
                                        DB.SQLString(item.Field<string>("moneda")) + ", " + DB.SQLString(item.Field<DateTime>("fecha")) + ", " +
                                        DB.SQLString(item.Field<string>("operario")) + ", " + DB.SQLString(item.Field<int>("arqueo")) + ", " +
                                        DB.SQLString(item.Field<int>("linea")) + ", " + DB.SQLString(lcOrigen) + ")";

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.EMPRESA = B.EMPRESA AND A.CAJA = B.CAJA AND A.MONEDA = B.MONEDA " +
                                                                        " AND A.FECHA = B.FECHA AND A.OPERARIO = B.OPERARIO AND A.LINEA = B.LINEA ";

                        break;

                    case "COB_PAGO":

                        lcAux = ", ARQUEO = " + DB.SQLString(item.Field<int>("arqueo"));

                        lcWhere = " WHERE EMPRESA = " + DB.SQLString(item.Field<string>("empresa")) +
                                    " AND CAJA = " + DB.SQLString(item.Field<string>("caja")) +
                                    " AND FECHA = " + DB.SQLString(item.Field<DateTime>("fecha")) +
                                    " AND OPERARIO = " + DB.SQLString(item.Field<string>("operario")) +
                                    //" AND ARQUEO = " + DB.SQLString(item.Field<int>("arqueo")) +
                                    " AND LINEA = " + DB.SQLString(item.Field<int>("linea"));

                        lcInsert = "(EMPRESA, CAJA, FECHA, OPERARIO, ARQUEO, LINEA, ORIGEN) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("empresa")) + ", " + DB.SQLString(item.Field<string>("caja")) + ", " +
                                        DB.SQLString(item.Field<DateTime>("fecha")) + ", " + DB.SQLString(item.Field<string>("operario")) + ", " +
                                        DB.SQLString(item.Field<int>("arqueo")) + ", " + DB.SQLString(item.Field<int>("linea")) + ", " + DB.SQLString(lcOrigen) + ")";

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.EMPRESA = B.EMPRESA AND A.CAJA = B.CAJA " +
                                                                        " AND A.FECHA = B.FECHA AND A.OPERARIO = B.OPERARIO AND A.LINEA = B.LINEA ";

                        break;

                    case "PRCLIENT":

                        lcWhere = " WHERE CODIGO = " + DB.SQLString(item.Field<int>("codigo")) +
                                    " AND EJERCICIO = " + DB.SQLString(lcAny);

                        lcInsert = "(CODIGO, EJERCICIO, ORIGEN) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<int>("codigo")) + ", " +
                                        DB.SQLString(lcAny) + ", " + DB.SQLString(lcOrigen) + ")";

                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.CODIGO = B.CODIGO ";

                        break;


                    default:

                        if (lcBd == "LOTES" && lcTabla == "MCAMPOS")
                        {
                            lcWhere = " WHERE CODIGO = " + DB.SQLString(item.Field<string>("codigo"));
                        }
                        else
                        {
                            lcWhere = " WHERE CODIGO = " + DB.SQLString(item.Field<string>("codigo")) + " AND EJERCICIO = " + DB.SQLString(lcAny);
                        }

                        lcInsert = "(CODIGO, EJERCICIO, ORIGEN) " +
                                    "Values(" +
                                        DB.SQLString(item.Field<string>("codigo")) + ", " + DB.SQLString(lcAny) + ", " + DB.SQLString(lcOrigen) + ")";


                        lcInnerJoin = " INNER JOIN " + DB.SQLDatabase(lcBd, lcTabla) + " B ON A.CODIGO = B.CODIGO ";

                        break;
                }

                lcSql = " IF EXISTS " + Environment.NewLine +
                                " ( SELECT ORIGEN FROM " + DB.SQLDatabase("OFFLINE", tcTablaControl) + lcWhere + " ) " + Environment.NewLine +
                                " BEGIN " + Environment.NewLine +
                                        " Update " + DB.SQLDatabase("OFFLINE", tcTablaControl) + lcSet + lcAux + lcWhere + Environment.NewLine +
                                " END " + Environment.NewLine +
                                " ELSE " + Environment.NewLine +
                                " BEGIN" + Environment.NewLine +
                                        "Insert Into " + DB.SQLDatabase("OFFLINE", tcTablaControl) + lcInsert +
                                " END ";

                DB.SQLExec(lcSql);
            }

            return lcInnerJoin;
        }

        private static bool Subir_Fichero_DatosEnvio(OfflineDatosComunicaciones datos, string cTipoEnvio, ILog_comoffRepository logRepository)
        {
            // i -> Carga Inicial    
            // e -> Envío de datos
            string lcTipoEnvio = (cTipoEnvio == "i" ? "la carga inicial " : "envío ");

            string lcBaseFicheroZip = _cTempFileName + cTipoEnvio;
            bool llOk = true;

            if (!string.IsNullOrWhiteSpace(lcBaseFicheroZip) && Directory.Exists(datos._PathFolderInicial))
            {
                _TextStepDetalle = "Subiendo el fichero de " + lcTipoEnvio + lcBaseFicheroZip + ".zip ";
                _TextStepProgreso = _TextStepDetalle;
                _PorcenProgreso = IncrementarBarraProgreso();

                clsOffLine utilsOffline = new clsOffLine();
                string pathArchivoComprimido = utilsOffline.Fichero_Comprimir(datos._PathFolderInicial, lcBaseFicheroZip);

                //IOfflineUnitOfWork offlineUnitOfWork = DependencyInjector.Instance.Retrieve<IOfflineUnitOfWork>();
                //ILog_comoffRepository logRepository = offlineUnitOfWork.Log_comoffRepository;

                Log_comoffDto logDto = logRepository.GetDto(datos);
                logDto.TipoDato = "01";
                if (string.IsNullOrWhiteSpace(pathArchivoComprimido))
                {
                    logDto.Resultado = 3;
                    logDto.Detalle = "El fichero de " + lcTipoEnvio + lcBaseFicheroZip + ".zip no se ha podido generar.";
                    logRepository.Insert(logDto);
                }
                else
                {
                    logDto.Resultado = 1;
                    logDto.Detalle = "El fichero de " + lcTipoEnvio + lcBaseFicheroZip + ".zip se ha generado con éxito.";
                    logRepository.Insert(logDto);

                    string lcZipFile = Path.Combine(datos._PathFolderInicial, pathArchivoComprimido);
                    lcZipFile = Path.Combine(lcZipFile, lcBaseFicheroZip);
                    lcZipFile = lcZipFile + ".zip";

                    long uploadedFileSize = 0;

                    var carpetaserv = "SUCURNET" + datos._Sucursal + "/";


                    llOk = UploadManager.Subir_Fichero(lcZipFile, "", carpetaserv, datos._IdConf, ref uploadedFileSize);

                    int conexion = TipoConexion(datos);
                    string lcDescrip = (conexion == 0 ? "FTP" : "OneDrive");

                    if (llOk)
                    {
                        logDto.Resultado = 1;
                        logDto.Detalle = "El fichero de " + lcTipoEnvio + lcBaseFicheroZip + ".zip se ha subido a la carpeta " + carpetaserv + " del " + lcDescrip + ".";
                    }
                    else
                    {
                        logDto.Resultado = 3;
                        logDto.Detalle = "No se ha podido subir fichero de " + lcTipoEnvio + lcBaseFicheroZip + ".zip a carpeta " + lcDescrip + " , revise si el usuario " + lcDescrip + " configurado tiene permisos en la carpeta indicada.";
                    }

                    logRepository.Insert(logDto);
                }
            }

            return llOk;
        }


        private static int TipoConexion(OfflineDatosComunicaciones datos)
        {
            int tipoConexion = 0;

            DataTable ldtDatos = new DataTable();
            DB.SQLExec("SELECT CONEXION FROM " + DB.SQLDatabase("OFFLINE", "MULTCONF") + " WHERE IDCONF = " + DB.SQLString(datos._IdConf), ref ldtDatos);

            if (ldtDatos != null || ldtDatos.Rows.Count > 0)
            {
                return Convert.ToInt16(ldtDatos.Rows[0]["conexion"]);
            }

            return tipoConexion;
        }

        private static bool Subir_Fichero_Configuracion(OfflineDatosComunicaciones datos, ILog_comoffRepository logRepository)
        {
            string lcBaseFicheroZip = "configura_offline";
            bool llOk = true;

            if (!string.IsNullOrWhiteSpace(lcBaseFicheroZip) && Directory.Exists(datos._PathFolderInicial))
            {
                clsOffLine utilsOffline = new clsOffLine();
                string pathArchivoComprimido = utilsOffline.Fichero_Comprimir(datos._PathFolderInicial, lcBaseFicheroZip);

                Log_comoffDto logDto = logRepository.GetDto(datos);
                logDto.TipoDato = "01";
                if (string.IsNullOrWhiteSpace(pathArchivoComprimido))
                {
                    logDto.Resultado = 3;
                    logDto.Detalle = "El fichero de configuración offline " + lcBaseFicheroZip + ".zip no se ha podido generar.";
                    logRepository.Insert(logDto);
                }
                else
                {
                    logDto.Resultado = 1;
                    logDto.Detalle = "El fichero de configuración offline " + lcBaseFicheroZip + ".zip se ha generado con éxito.";
                    logRepository.Insert(logDto);

                    string lcZipFile = Path.Combine(datos._PathFolderInicial, pathArchivoComprimido);
                    lcZipFile = Path.Combine(lcZipFile, lcBaseFicheroZip);
                    lcZipFile = lcZipFile + ".zip";

                    long uploadedFileSize = 0;
                    var carpetaserv = "/";

                    llOk = UploadManager.Subir_Fichero(lcZipFile, "", carpetaserv, datos._IdConf, ref uploadedFileSize);

                    int conexion = TipoConexion(datos);
                    string lcDescrip = (conexion == 0 ? "FTP" : "OneDrive");

                    if (llOk)
                    {
                        logDto.Resultado = 1;
                        logDto.Detalle = "El fichero de configuración offline " + lcBaseFicheroZip + ".zip se ha subido a la carpeta " + carpetaserv + " del " + lcDescrip + ".";
                    }
                    else
                    {
                        logDto.Resultado = 3;
                        logDto.Detalle = "No se ha podido subir fichero de configuración offline " + lcBaseFicheroZip + ".zip a carpeta FTP, revise si el usuario FTP configurado tiene permisos en la carpeta indicada.";
                    }

                    logRepository.Insert(logDto);

                }
            }

            return llOk;
        }
        
        private static void Procesar_Imagenes_Envio(string tcNombre, OfflineDatosComunicaciones datos, DataTable tdtImagenes, ILog_comoffRepository logRepository)
        {
            if (tdtImagenes.Rows.Count > 0)
            {
                _TextStepDetalle = "Procesando imagenes a enviar";
                _TextStepProgreso = _TextStepDetalle;
                _PorcenProgreso = IncrementarBarraProgreso();

                DataTable _ldtImgOff = new DataTable();

                //Obtenir imatges OFFLINE
                DB.SQLExec("SELECT * FROM " + DB.SQLDatabase("OFFLINE", "IMAGENES") + " ORDER BY TIPO, NOMBRE ", ref _ldtImgOff);

                // Obtenir últim número pel comtpador d'imatges
                int lnId = 0;
                if (_ldtImgOff.Rows.Count > 0)
                {
                    lnId = Convert.ToInt32(_ldtImgOff.Compute("MAX(ID)", ""));
                }

                DB.SQLExec("SELECT * FROM " + DB.SQLDatabase("OFFLINE", "IMAGENES") + " WHERE SUCURSAL = " + DB.SQLString(datos._Sucursal) + " ORDER BY TIPO, NOMBRE ", ref _ldtImgOff);

                Log_comoffDto logDto = logRepository.GetDto(datos);
                logDto.TipoDato = "01";
                //Revisar imatges noves i modificades.
                foreach (DataRow item in tdtImagenes.Rows)
                {
                    int lnTipo = item.Field<int>("Tipo");
                    string lcRutaImagen = Path.GetDirectoryName(item.Field<string>("Imagen"));
                    string lcNombreImagen = Path.GetFileName(item.Field<string>("Imagen"));

                    string lcBuscar = "tipo = " + lnTipo.ToString().TrimEnd() + " and nombre = '" + lcNombreImagen + "'";

                    DateTime ldData = DateTime.Today;

                    bool llAfegir = false;

                    // Únicament acceptem imatges que estiguis guardades al servidor d'Eurowin, 
                    // ja que és quan podrem garantir la seva correcta recepció
                    if (!string.IsNullOrWhiteSpace(lcRutaImagen) && lcRutaImagen.ToLower().IndexOf(datos._IniServidor.ToLower()) < 0)
                    {
                        logDto.Resultado = 3;
                        logDto.Detalle = "La imagen asociada al código '" + item.Field<string>("codigo") + "' de la tabla '" + Definicion_Tipo_Imagen(lnTipo) + "' no está almacenada en una carpeta dentro del servidor de Sage50. (" + lcRutaImagen + "\\" + lcNombreImagen + ")";
                        logRepository.Insert(logDto);
                        //continue;
                    }

                    // Ens saltem les imatges que no existeixen físicament.Si no s'indica ruta suposem que està a COMUNES\FOTOS
                    string lcOrigen = (string.IsNullOrWhiteSpace(lcRutaImagen) ? datos._IniServidor + "COMUNES\\FOTOS\\" : lcRutaImagen + "\\") + lcNombreImagen;

                    if (!File.Exists(lcOrigen))
                    {
                        logDto.Resultado = 3;
                        logDto.Detalle = "La imagen " + lcNombreImagen + " no está almacenada en la carpeta especificada del servidor de Sage50.";
                        logRepository.Insert(logDto);
                        continue;
                    }

                    // Obtenim el MD5 de la imatge actual

                    string lcNewControl = "";

                    var plainTextBytes = Encoding.UTF8.GetBytes(lcOrigen);
                    string lcValor = System.Convert.ToBase64String(plainTextBytes);

                    try
                    {
                        DataRow[] ldrs = _ldtImgOff.Select(lcBuscar);

                        DataTable _curMd5 = new DataTable();
                        DB.SQLExec("select master.dbo.md5('" + lcValor + "') as control", ref _curMd5);

                        if (_curMd5 != null && _curMd5.Rows.Count > 0)
                        {
                            lcNewControl = _curMd5.Rows[0]["control"].ToString();
                        }

                        if (ldrs.Length == 0)
                        {
                            // La imatge NO existeix, per tant l'afegim a la taula IMAGENES de la bd del OFFLINE        
                            llAfegir = true;
                            lnId = lnId + 1;

                            // Treiem de la ruta la part del servidor, ja que a cada instal.lació pot ser diferent
                            string lcRutaDest = lcRutaImagen.Replace(datos._IniServidor, "");

                            DataRow newRow = _ldtImgOff.NewRow();
                            newRow["id"] = lnId;
                            newRow["nombre"] = lcNombreImagen;
                            newRow["control"] = lcNewControl;
                            newRow["ruta"] = lcRutaDest;
                            newRow["tipo"] = lnTipo;
                            newRow["fecha"] = ldData;
                            newRow["sucursal"] = datos._Sucursal;
                            _ldtImgOff.Rows.Add(newRow);

                            // Afegir també la imatge a la taula OFFLINE!IMAGENES
                            DB.SQLExec("INSERT INTO " + DB.SQLDatabase("OFFLINE", "IMAGENES") + " (id,nombre,control,ruta,tipo,fecha,sucursal) " +
                                        " VALUES (" + DB.SQLString(lnId) + ", " + DB.SQLString(lcNombreImagen) + ", " + DB.SQLString(lcNewControl) + ", " +
                                                        DB.SQLString(lcRutaDest) + ", " + DB.SQLString(lnTipo) + ", " + DB.SQLString(ldData) + ", " + DB.SQLString(datos._Sucursal) + ")");
                        }
                        else
                        {
                            // La imatge ja existeix, comprobar si ha canviat
                            string lcControl = ldrs[0]["Control"].ToString();

                            if (lcControl != lcNewControl)
                            {
                                llAfegir = true;

                                ldrs[0]["Control"] = lcNewControl;
                                ldrs[0]["Fecha"] = ldData;

                                // Actualitzar també la imatge a la taula OFFLINE!IMAGENES
                                DB.SQLExec("UPDATE " + DB.SQLDatabase("OFFLINE", "IMAGENES") + " SET control = " + DB.SQLString(lcNewControl) + ", fecha = " + DB.SQLString(ldData) +
                                            " WHERE tipo = " + DB.SQLString(lnTipo) + " AND nombre = " + DB.SQLString(lcNombreImagen) + " AND sucursal = " + DB.SQLString(datos._Sucursal));

                            }
                        }
                    }
                    catch (Exception)
                    {
                        throw;
                    }

                    // Anem afegint les imatges noves o modificades a la carpeta temporal
                    if (llAfegir)
                    {
                        string lcDestino = Path.Combine(datos._PathFolderInicial, "IMAGENES");

                        if (!Directory.Exists(lcDestino))
                            Directory.CreateDirectory(lcDestino);

                        lcDestino = Path.Combine(lcDestino, lcNombreImagen);

                        try
                        {
                            File.Copy(lcOrigen, lcDestino, true);

                            string lcTipoDato = clsOfflineUtils.ObtenerTipoDatoImagen(lnTipo);

                            logDto.Resultado = 1;
                            logDto.Detalle = "Imagen en la carpeta especificada del servidor de Sage50. (" + lcNombreImagen + ")";
                            logRepository.Insert(logDto);
                        }
                        catch (Exception)
                        {
                            logDto.Resultado = 3;
                            logDto.Detalle = "No ha sido posible copiar la imagen " + lcNombreImagen + ".";
                            logRepository.Insert(logDto);
                        }
                    }
                }

                // Crear la taula lliure a enviar en la carpeta temporal
                ConvertIndividualFile(_ldtImgOff, Path.Combine(datos._PathFolderInicial, "IMAGENES"), "IMAGENES", FormatoExportacion.XML);
            }
        }

        private static void Seleccionar_Imagenes_Envio(bool tlImagenes, Dictionary<string, object> tablaSucursales, string lcTabla, OfflineDatosComunicaciones datos, ref DataTable ldtImagenes)
        {
            if (tlImagenes && tablaSucursales.ContainsKey("env_foto") && Convert.ToBoolean(tablaSucursales["env_foto"]))
            {
                DataTable temporal = new DataTable();
                string lcSql = string.Empty;

                // Obtenir imatges EUROWIN
                switch (lcTabla)
                {
                    case "FAMILIAS":
                        lcSql = "SELECT 1 as tipo, LTRIM(RTRIM(b.foto)) as imagen, b.codigo FROM " + DB.SQLDatabase("GESTION", lcTabla) + " b WHERE LTRIM(RTRIM(b.foto)) != '' ";
                        break;

                    case "MARCAS":
                        lcSql = "SELECT 2 as tipo, LTRIM(RTRIM(b.foto)) as imagen, b.codigo FROM " + DB.SQLDatabase("GESTION", lcTabla) + " b WHERE LTRIM(RTRIM(b.foto)) != '' ";
                        break;

                    case "ART_FOTO":
                        lcSql = "SELECT 3 as tipo, LTRIM(RTRIM(b.imagen)) as imagen, b.articulo as codigo FROM " + DB.SQLDatabase("GESTION", lcTabla) + " b WHERE LTRIM(RTRIM(b.imagen)) != '' ";

                        // Casos especiales
                        if (datos._EnvioArticulos)
                        {
                            lcSql += Envio_Articulos_Sucursal(datos, lcTabla);
                        }

                        break;

                    case "COLORES":
                        lcSql = "SELECT 4 as tipo, LTRIM(RTRIM(b.imagen)) as imagen, b.codigo FROM " + DB.SQLDatabase("COMUNES", lcTabla) + " b WHERE LTRIM(RTRIM(b.imagen)) != '' ";
                        break;

                    case "EMPRESA":
                        lcSql = "SELECT 5 as tipo, LTRIM(RTRIM(b.foto)) as imagen, b.codigo FROM " + DB.SQLDatabase("GESTION", lcTabla) + " b WHERE LTRIM(RTRIM(b.foto)) != '' ";
                        break;

                    case "USUARIOS":
                        lcSql = "SELECT 6 as tipo, LTRIM(RTRIM(b.foto)) as imagen, b.codigo FROM " + DB.SQLDatabase("COMUNES", lcTabla) + " b WHERE LTRIM(RTRIM(b.foto)) != '' ";
                        break;

                    case "SUBFAM":
                        lcSql = "SELECT 7 as tipo, LTRIM(RTRIM(b.foto)) as imagen, b.codigo FROM " + DB.SQLDatabase("GESTION", lcTabla) + " b WHERE LTRIM(RTRIM(b.foto)) != '' ";
                        break;

                    case "VENDEDOR":
                        lcSql = "SELECT 8 as tipo, LTRIM(RTRIM(b.foto)) as imagen, b.codigo FROM " + DB.SQLDatabase("GESTION", lcTabla) + " b WHERE LTRIM(RTRIM(b.foto)) != '' ";
                        break;

                    case "CLASIF":
                        lcSql = "SELECT 9 as tipo, LTRIM(RTRIM(b.foto)) as imagen, b.codigo FROM " + DB.SQLDatabase("COMUNES", lcTabla) + " b WHERE LTRIM(RTRIM(b.foto)) != '' ";
                        break;
                }

                if (DB.SQLExec(lcSql, ref temporal))
                {
                    if (ldtImagenes.Rows.Count == 0)
                    {
                        ldtImagenes = temporal;
                    }
                    else
                    {
                        DBfunctions.SQLUnionDatatable(ref ldtImagenes, temporal);
                    }
                }
            }
        }

        private static bool Revisar_Imagenes_Datos(bool tlImagenes, Dictionary<string, object> tablaSucursales, string lcTabla, OfflineDatosComunicaciones datos, ref DataTable ldtDatos)
        {
            if (ldtDatos.Rows.Count == 0)
            {
                return false;
            }

            if (!tlImagenes || (tablaSucursales.ContainsKey("env_foto") && !Convert.ToBoolean(tablaSucursales["env_foto"])))
            {
                DataTable temporal = new DataTable();
                string lcSql = string.Empty;

                // Obtenir imatges EUROWIN
                switch (lcTabla)
                {
                    case "FAMILIAS":
                    case "MARCAS":
                    case "EMPRESA":
                    case "USUARIOS":
                    case "SUBFAM":
                    case "VENDEDOR":
                    case "CLASIF":
                        foreach (DataRow item in ldtDatos.Rows)
                        {
                            item["foto"] = string.Empty;
                        }
                        break;

                    case "COLORES":
                        foreach (DataRow item in ldtDatos.Rows)
                        {
                            item["imagen"] = string.Empty;
                        }
                        break;

                    case "ART_FOTO":
                        ldtDatos.Clear();
                        ldtDatos.AcceptChanges();

                        return false;
                }
            }

            return true;
        }

        private static DataTable obtenerDatosEnvio(Dictionary<int, bool> prioridades, string cTipoEnvio)
        {
            string lcSql = string.Empty;
            string lcWhereCentral = string.Empty;
            string lcWhereSucur = string.Empty;
            string lcOrCentral = string.Empty;
            string lcOrSucur = string.Empty;

            foreach (KeyValuePair<int, bool> item in prioridades)
            {
                if (item.Value)
                {
                    lcWhereCentral += lcOrCentral + " ID = " + DB.SQLString(item.Key);
                    lcOrCentral = " OR ";
                }
                else
                {
                    lcWhereSucur += lcOrSucur + " ID = " + DB.SQLString(item.Key);
                    lcOrSucur = " OR ";
                }
            }

            // Task 190661: Envío de datos - Addons Fabricación
            if (cTipoEnvio == "e" && (prioridades.ContainsKey(159) && !prioridades.ContainsKey(292)))
            {
                if (!string.IsNullOrEmpty(lcWhereCentral))
                {
                    lcWhereCentral += lcOrCentral + " ID = " + DB.SQLString(292);
                    lcOrCentral = " OR ";
                }
                else
                {
                    lcWhereSucur += lcOrSucur + " ID = " + DB.SQLString(292);
                    lcOrSucur = " OR ";
                }
            }

            if (!string.IsNullOrWhiteSpace(lcOrCentral))
            {
                lcWhereCentral = " AND (" + lcWhereCentral + ")";
            }
            else
            {
                lcWhereCentral = " AND ( 1=2 )";
            }

            if (!string.IsNullOrWhiteSpace(lcOrSucur))
            {
                lcWhereSucur = " AND (" + lcWhereSucur + ")";
            }
            else
            {
                lcWhereSucur = " AND ( 1=2 )";
            }

            // Obtenemos datos en la tabla dependiendo del tipo de envío:
            // i -> Carga Inicial    
            // e -> Envío de datos
            string lcCampoWhere = (cTipoEnvio == "i" ? "visicarga" : "visible");

            DataTable TabTmp = new DataTable();

            //Obtenir totes les taules del Tabrel a enviar en la càrrega inicial
            lcSql += " SELECT clave, (CASE WHEN secundaria = '' THEN principal ELSE secundaria END) as nombre, " +
                     " empresa, id, idgrupo, principal, cast(1 as bit) as prioridad, visicond, UPPER(nombre) as titulo, tipotabla, " +
                     " cast(condenv as varchar(max)) as condenv, cast(condsecun as varchar(max)) as condsecun, " +
                     " asientos, otrasien, eos, iva_exen, ivasopor, ivareper, retsopor, retreper, compras, relacion, empresecun, visible, condctrl, tablactrl, relactrl " + Environment.NewLine +
                     " FROM " + DB.SQLDatabase("OFFLINE", "TABRELNET") + Environment.NewLine +
                     " WHERE 1=1 " +
                     " AND clave IN (SELECT DISTINCT CLAVE FROM " + DB.SQLDatabase("OFFLINE", "TABRELNET") + " WHERE " + lcCampoWhere + " = 1 " + lcWhereCentral + ") " + Environment.NewLine;

            lcSql += " UNION ALL " + Environment.NewLine;

            lcSql += " SELECT clave, (CASE WHEN secundaria = '' THEN principal ELSE secundaria END) as nombre, " +
                     " empresa, id, idgrupo,principal, cast(0 as bit) as prioridad, visicond, UPPER(nombre) as titulo, tipotabla, " +
                     " cast(condenv as varchar(max)) as condenv, cast(condsecun as varchar(max)) as condsecun, " +
                     " asientos, otrasien, eos, iva_exen, ivasopor, ivareper, retsopor, retreper, compras, relacion, empresecun, visible, condctrl, tablactrl, relactrl " + Environment.NewLine +
                     " FROM " + DB.SQLDatabase("OFFLINE", "TABRELNET") + Environment.NewLine +
                     " WHERE 1=1 " +
                     " AND clave IN (SELECT DISTINCT CLAVE FROM " + DB.SQLDatabase("OFFLINE", "TABRELNET") + " WHERE " + lcCampoWhere + " = 1 " + lcWhereSucur + ") " + Environment.NewLine;

            DB.SQLExec(lcSql, ref TabTmp);

            TabTmp.DefaultView.Sort = " CLAVE ASC, VISIBLE DESC, PRINCIPAL ASC, PRIORIDAD DESC ";
            TabTmp = TabTmp.DefaultView.ToTable();

            // Addons Fabricación
            if (TabTmp != null && TabTmp.Rows.Count > 0 && (cTipoEnvio == "e" && (prioridades.ContainsKey(159) && !prioridades.ContainsKey(292))))
            {
                DataRow[] ldrDelete = TabTmp.Select("id = 292");
                if (ldrDelete != null && ldrDelete.Length == 1)
                {
                   ldrDelete[0].Delete();
                }
                TabTmp.AcceptChanges();
            }

            // Riesgo de clientes
            bool _lEsSucursal = Convert.ToBoolean(EW_GLOBAL._ModuloActivo("OFFLINE")) && !Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_TipoOffline"));
            if (TabTmp != null && TabTmp.Rows.Count > 0 && prioridades.ContainsKey(47) && _lEsSucursal)
            {
                DataRow[] ldrDelete = TabTmp.Select("id = 287");
                if (ldrDelete != null && ldrDelete.Length == 1)
                {
                    ldrDelete[0].Delete();
                }
                TabTmp.AcceptChanges();
            }

            DataTable dtTemp = new DataTable();

            if (TabTmp != null && TabTmp.Rows.Count > 0)
                dtTemp = TabTmp.Clone();

            foreach (DataRow item in TabTmp.Rows)
            {
                if (item.Field<string>("nombre").TrimEnd() != item.Field<string>("principal").TrimEnd())
                {
                    // descarto los historicos de series
                    if (item.Field<string>("nombre").TrimEnd() == "COMUNES!HISSERIE")
                    {
                        continue;
                    }

                    // busco si existe el principal en otro registro como nombre
                    DataRow[] ldrs = TabTmp.Select("nombre = '" + item.Field<string>("principal").TrimEnd() + "' and principal = '" + item.Field<string>("principal").TrimEnd() + "' and clave ='" + item.Field<string>("clave").TrimEnd() + "' ");
                    if (ldrs.Length == 0)
                    {
                        // busco si existe el principal en tabla temporal 
                        DataRow[] ldrTemp = dtTemp.Select("nombre = '" + item.Field<string>("principal").TrimEnd() + "' and principal = '" + item.Field<string>("principal").TrimEnd() + "'and clave ='" + item.Field<string>("clave").TrimEnd() + "' ");
                        if (ldrTemp.Length == 0)
                        {
                            // Copio el registro en la tabla temporal
                            DataRow dataRow = dtTemp.NewRow();
                   
                            dataRow.ItemArray = item.ItemArray.Clone() as object[];
                            dataRow["nombre"] = dataRow["principal"];
                            dataRow["asientos"] = "";
                            dataRow["otrasien"] = "";
                            dataRow["eos"] = "";
                            dataRow["relacion"] = "";
                            dataRow["iva_exen"] = "";
                            dataRow["ivasopor"] = "";
                            dataRow["ivareper"] = "";
                            dataRow["retreper"] = "";
                            dataRow["retsopor"] = "";
                            dataRow["compras"] = "";

                            dtTemp.Rows.Add(dataRow);
                        }
                    }
                }
            }

            if (dtTemp != null && dtTemp.Rows.Count > 0)
                TabTmp.Merge(dtTemp);

            TabTmp.DefaultView.Sort = " CLAVE ASC, VISIBLE DESC, PRINCIPAL ASC, RELACION ASC ";
            TabTmp = TabTmp.DefaultView.ToTable();

            return TabTmp;
        }

        private static bool UploadIndividualFile(DataTable datos, string path, string nombreTabla, int idConf, FormatoExportacion formatoExportacion, ref long uploadedFileSize, string carpeta)
        {
            //Prueba temporal con la tabla de sucursales
            string uploadFile = Path.Combine(path, nombreTabla + "." + formatoExportacion.ToString());

            ConvertIndividualFile(datos, path, nombreTabla, formatoExportacion);

            string zippedName = Path.GetFileName(uploadFile) + ".zip";

            if (!UploadManager.Subir_Fichero(uploadFile, zippedName, carpeta, idConf, ref uploadedFileSize))
                return false;

            return true;
        }

        #endregion Métodos para el Asistente de Configuración
    }
}