AsistenteOffEnvioDatosBizRule.cs

using sage.addons.offline.DataAccess.Dto;
using sage.addons.offline.DataAccess.UnitOfWork;
using sage.addons.offline.Visual.UserControls;
//using sage.ew.db;
using sage.ew.global;
using sage.ew.global.DependencyInjection;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Linq;
using System.Text;

namespace sage.addons.offline.Negocio.Clases
{

    internal class AsistenteOffEnvioDatosBizRule : AsistenteOffBase
    {
        #region PROPIEDADES

        private DateTime _dtIniEjer = Convert.ToDateTime(EW_GLOBAL._GetVariable("wd_periodoini"));

        public Dictionary<int, string> Selecteds = new Dictionary<int, string>();

        public Dictionary<int, string> SelectedsAddons = new Dictionary<int, string>();


        public Dictionary<int, bool> Prioridades = new Dictionary<int, bool>();

        public DataTable PrioridadesEnvio = null;

        #endregion PROPIEDADES

        internal DateTime GetDateIni()
        {
            return _asistenteOfflineDA.GetUltimaFechaEnvio(IdConf);
        }

        #region Metodos publicos

        public IList<GrupoDto> GetGroups(int lcTabEnviar)
        {
            using (IOfflineUnitOfWork offlineUnitOfWork = DependencyInjector.Instance.Retrieve<IOfflineUnitOfWork>())
            {
                return offlineUnitOfWork.GruposRepository.GetGrupos(lcTabEnviar);
            }
        }

        public bool Upload_Control_Files()
        {
            OfflineUploader._offBase = this;
            return OfflineUploader.Upload_Control_Files(2, IsCentral, IdConf);
        }

        public void MostrarResultado(string mensaje, int nResult, string tcIdLog, int tnIdConf)
        {
            OfflineUpAndDown.MostrarResultado(mensaje, nResult, 2, IsCentral, tcIdLog, tnIdConf);
        }

        public bool Upload_Offline_Files(clsOfflineUtils.ReportProgress progressReporter, bool tlAnterior)
        {
            bool llOk = true;

            DataTable dtSucursales = new DataTable();

            if (IsAutomatica)
                dtSucursales = GetSucursalesConf();

            foreach (string sucursal in Sucursales)
            {
                if (IsAutomatica)
                {
                    DataRow[] loSucursal = dtSucursales.Select("codigo = " + _asistenteOfflineDA.SQLString(sucursal));
                    if (loSucursal != null && loSucursal.Count() > 0)
                    {
                        //Si la fecha del último envio es null le ponemos inicio de ejercicio
                        if (loSucursal[0]["ultfecenv"] == null || loSucursal[0]["ultfecenv"] == DBNull.Value)
                        {
                            FechaInicial = Convert.ToDateTime(EW_GLOBAL._GetVariable("wd_periodoini"));
                            FechaConf = DateTime.MinValue;
                        }
                        else
                        {
                            FechaInicial = Convert.ToDateTime(loSucursal[0]["ultfecenv"]);
                            FechaConf = Convert.ToDateTime(loSucursal[0]["ultfecenv"]);
                        }
                    }
                }

                OfflineUploader._offBase = this;
                llOk = llOk && OfflineUploader.Upload_Offline_Files(progressReporter, FechaConf, FechaInicial, FechaFinal, sucursal, (EnvioImagenes == 0), tlAnterior, IsCentral, IdConf, false, Prioridades);
            }

            return llOk;
        }
        
        public DataTable GetSucursalesConf()
        {
            DataTable ret = dtSucursales.Clone();

            DataTable dtSucurConf = _asistenteOfflineDA.GetSucurConf(CodigoConfiguracion);

            foreach (DataRow row in dtSucursales.Rows)
            {
                DataRow[] loSucursal = dtSucurConf.Select("codigo = " + _asistenteOfflineDA.SQLString(row["codigo"]));
                if (loSucursal != null && loSucursal.Count() > 0)
                {
                    row["sel"] = 1;
                    ret.ImportRow(row);
                }
            }

            return ret;
        }


        public Dictionary<Int32, string> CargarDatosEnvio(int ctipo)
        {
            Dictionary  <Int32, string> claves = new Dictionary<Int32, string>();
            
            IList<GrupoDto> cargaGrupos;  //new Grupos();
            using (IOfflineUnitOfWork offlineUnitOfWork = DependencyInjector.Instance.Retrieve<IOfflineUnitOfWork>() )
            {
                cargaGrupos = offlineUnitOfWork.GruposRepository.GetGrupos(ctipo);
            }

            foreach (GrupoDto grupo in cargaGrupos)
            {
                foreach (DataAccess.Model.tabrelnet tn in grupo.Items)
                {
                    // hacer consulta en TABNETCONF y ver si registro de la configuración está en tabla y si campo SELENVIAR = .T.
                    if (Configuracion_TabConf(tn.ID, "TABNETCONF"))
                        claves.Add(tn.ID, tn.NOMBRE.TrimEnd());
                }
            }
            return claves;
        }

        public bool Configuracion_TabConf(Int32 id, string lcTabla)
        {
            return _asistenteOfflineDA.Configuracion_TabConf(id, lcTabla, CodigoConfiguracion);
        }

        public decimal InicializarBarraProgreso(int nDivisor)
        {
            return OfflineUpAndDown.InicializarBarraProgreso(nDivisor);
        }

        public decimal IncrementarBarraProgreso()
        {
            return OfflineUpAndDown.IncrementarBarraProgreso();
        }


        #endregion METODOS PUBLICOS
    }
}