AsistenteOffBase.cs

//using sage.ew.db;
using sage.addons.offline.DataAccess.Interfaz;
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;
using System.Windows.Forms;

namespace sage.addons.offline.Negocio.Clases
{
    internal class AsistenteOffBase : Interficies.IAsistenteOffBase
    {
        #region eventos

        protected internal delegate void _Mostrar_Progreso(String message);

        protected internal delegate void _Porcen_Progreso(decimal porcen, string message);

        protected internal event _Mostrar_Progreso _Mostrar_Progreso_Async;

        protected internal event _Porcen_Progreso _Porcen_Progreso_Async;

        #endregion eventos

        #region Variables Privadas

        private bool TerminalSeguridad = false;
        private int TipoOffline = 1;
        private int TipoComunicacion = 2;   // 1 -> comunicación via SKYDRIVE/OneDrive, 2 -> comunicación via FTP, per defecto FTP

        private clsOffLine toolsOffline = new clsOffLine();

        private DataRow sucursal;
        protected IAsistenteOfflineDA _asistenteOfflineDA;
        #endregion Variables Privadas


        #region Propiedades


        public FtpUserData ftp_user_data = new FtpUserData();
        public BindingList<Sucursales> _Sucursales = new BindingList<Sucursales>();

        public int IdConf { get; set; } = 0;

        public string IdLog { get; set; } = string.Empty;

        public int EnvioImagenes { get; set; } = 0;

        public bool NoRecalculoStockTrasRecibir { get; set; } = false;

        public bool BackupSel { get; set; } = false;
        public string BackupPath { get; set; } = "";
        public int BackupNumArchivos { get; set; } = 0;

        public string Hora_Envio { get; set; } = "";
        public string Hora_Recepcion { get; set; } = "";
        public string Hora_CargaIni { get; set; } = "";

        public int Delete_Cen_Mant { get; set; } = 1;
        public int Delete_Cen_Doc { get; set; } = 1;

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

        public string Serie_Sucursal { get; set; } = "";
        public string Almacen_Sucursal { get; set; } = "";
        public bool FiltroPorAlmacen { get; set; } = false;

        public string CuentaOneDrive { get; set; } = "";
        public string RutaOneDrive { get; set; } = "";

        public bool ConCargaInicial { get; set; } = false;

        public string CodigoConfiguracion
        {
            get
            {
                return _CodigoConfiguracion;
            }
            set
            {
                bool llCambiado = (_CodigoConfiguracion != value);

                _CodigoConfiguracion = value;

                if (llCambiado)
                {
                    Dictionary<string, object> tablaMultconf = _asistenteOfflineDA.GetMulticonf(value);
                    //DB.SQLREGValor("MULTCONF", "CODIGO", value, "OFFLINE");

                    IdConf = Convert.ToInt16(tablaMultconf["idconf"]);

                    if (tablaMultconf["conexion"].ToString() == "0")
                    {
                        string cadenaEncriptada = tablaMultconf["cfg_ftp"].ToString().Trim();

                        string cadenaDesencriptada = toolsOffline.Cadena_Desencriptar(cadenaEncriptada);

                        var trozos = cadenaDesencriptada.Split('~');

                        if (trozos.Length == 7)
                        {
                            ftp_user_data = new FtpUserData();
                            ftp_user_data.server = trozos[0].Trim();
                            ftp_user_data.user = trozos[1].Trim();
                            ftp_user_data.password = trozos[2].Trim();
                            ftp_user_data.port = Convert.ToDecimal(trozos[3]);
                            ftp_user_data.proxy = trozos[4].Trim();
                            ftp_user_data.rutaserv = trozos[5].Trim();
                            ftp_user_data.ftp_activo = trozos[6].Trim().ToUpper() == "SI";
                        }
                        else if (trozos.Length == 9)
                        {
                            ftp_user_data = new FtpUserData();
                            ftp_user_data.server = trozos[0].Trim();
                            ftp_user_data.user = trozos[1].Trim();
                            ftp_user_data.password = trozos[2].Trim();
                            ftp_user_data.port = Convert.ToDecimal(trozos[3]);
                            ftp_user_data.proxy = trozos[4].Trim();
                            ftp_user_data.rutaserv = trozos[5].Trim();
                            ftp_user_data.ftp_activo = trozos[6].Trim().ToUpper() == "SI";
                            ftp_user_data.use_ssl_tls = trozos[7].Trim().ToUpper() == "SI";
                            ftp_user_data.validate_server_cert = trozos[8].Trim().ToUpper() == "SI";
                        }


                        IsFTP = true;
                    }
                    else
                    {
                        ftp_user_data = null;
                        IsOneDrive = true;
                    }

                    OfflineUpAndDown.IdConf = IdConf;
                    
                    NoRecalculoStockTrasRecibir = Convert.ToBoolean(tablaMultconf["rec_stock"]);

                    cargarSucursales();
                }
            }
        }
        private string _CodigoConfiguracion = string.Empty;

        public bool IsCentral
        {
            get { return TipoOffline == 1; }
            set
            {
                if (value)
                    TipoOffline = 1;
                else
                    TipoOffline = 2;
            }
        }

        public bool IsSucursal
        {
            get { return TipoOffline == 2; }
            set
            {
                if (value)
                    TipoOffline = 2;
                else
                    TipoOffline = 1;
            }
        }

        public bool IsFTP
        {
            get { return TipoComunicacion == 2; }
            set
            {
                if (value)
                    TipoComunicacion = 2;
                else
                    TipoComunicacion = 1;
            }
        }

        public bool IsOneDrive
        {
            get { return TipoComunicacion == 1; }
            set
            {
                if (value)
                    TipoComunicacion = 1;
                else
                    TipoComunicacion = 2;
            }
        }

        protected internal int TipoRecepcion = 1;
        public bool IsAutomatica
        {
            get { return TipoRecepcion == 1; }
            set
            {
                if (value)
                    TipoRecepcion = 1;
                else
                    TipoRecepcion = 2;
            }
        }

        public bool IsPersonalizada
        {
            get { return TipoRecepcion == 2; }
            set
            {
                if (value)
                    TipoRecepcion = 2;
                else
                    TipoRecepcion = 1;
            }
        }


        public string CodigoSucursal
        {
            get
            {
                return _CodigoSucursal;
            }
            set
            {
                _CodigoSucursal = value;

                if (!string.IsNullOrEmpty(value))
                {
                    Serie_Sucursal = GetSerieDefectoCurrentSucursal();
                    Almacen_Sucursal = GetAlmacenDefectoCurrentSucursal();
                }
            }
        }
        private string _CodigoSucursal = "";

        public bool EnviarImagenes
        {
            get
            {
                return _EnviarImagenes;
            }
            set
            {
                _EnviarImagenes = value;
                EnvioImagenes = (value ? 0 : 1);
            }
        }
        private bool _EnviarImagenes = false;

        public List<string> Sucursales
        {
            get
            {
                List<string> sucursales = new List<string>();
                foreach (DataRow row in dtSucursales.Rows)
                {
                    if (row["sel"] != DBNull.Value && Convert.ToBoolean(row["sel"]))
                    {
                        if (IsCentral || (IsSucursal && row["codigo"].ToString() == _asistenteOfflineDA.CodigoSucursalActual()))
                        {
                            sucursales.Add(row["codigo"].ToString());
                        }
                    }
                }
                return sucursales;
            }
        }

        public DateTime FechaConf
        {
            get
            {
                if (_FechaConf == null)
                {
                    _FechaConf = GetDate();
                }
                return _FechaConf;
            }
            set
            {
                _FechaConf = value;
            }
        }
        private DateTime _FechaConf; // = GetDate();

        public DateTime FechaInicial
        {
            get
            {
                if (_FechaInicial == null)
                {
                    _FechaInicial = GetDate();
                }
                return _FechaInicial;
            }
            set
            {
                if (_FechaInicial != value)
                {
                    if (!ValidarQueFechasSonCorrectas(value, FechaFinal))
                    {
                        value = FechaFinal;
                    }

                    if (IsAutomatica)
                    {
                        _FechaInicial = value;
                    }
                    else
                    {
                        _FechaInicial = value.Date;
                    }
                }
            }
        }
        private DateTime _FechaInicial; // = GetDate();

        public DateTime FechaFinal
        {
            get
            {
                return _FechaFinal;
            }
            set
            {
                if (value < new DateTime(1900, 1, 1)) //CCR 179195: Si en lugar de null llega una fecha 1700 al vaciar la fecha en la parte visual
                {
                    value = value.Date.AddHours(23).AddMinutes(59).AddSeconds(59);
                }

                if (_FechaFinal != value)
                {
                    if (!ValidarQueFechasSonCorrectas(_FechaInicial, value))
                    {
                        value = _FechaFinal;
                    }

                    _FechaFinal = value.Date.AddHours(23).AddMinutes(59).AddSeconds(59);
                }
            }
        }
        private DateTime _FechaFinal = DateTime.Today.AddHours(23).AddMinutes(59).AddSeconds(59);


        public bool Incidencias
        {
            get { return Finalizacion == 2; }
            set
            {
                if (value)
                {
                    Finalizacion = 2;
                }
                else
                {
                    Finalizacion = 1;
                }
            }
        }
        private int Finalizacion = 1;    // 1 Finaliza Correctamente - 2 Finaliza con incidencias

        public bool Error
        {
            get 
            {
                return _Error;
            }
            set
            {
                _Error = value;
            }
        }
        private bool _Error = false;

        public string _TextStepDetalle
        {
            set
            {
                if (!string.IsNullOrEmpty(value))
                {
                    _cTextStepDetalle = value;
                    ActualizarProgresoDetalle();
                }
            }
            get { return _cTextStepDetalle; }
        }
        private string _cTextStepDetalle = "";

        public string _TextStepProgreso
        {
            set
            {
                if (!string.IsNullOrEmpty(value))
                {
                    _cTextStepProgreso = value;
                }
            }
            get { return _cTextStepProgreso; }
        }
        private string _cTextStepProgreso = "";

        public decimal _PorcenProgreso
        {
            set
            {
                _lnPorcenProgreso = value;
                ActualizarBarraProgreso();
            }
            get { return _lnPorcenProgreso; }
        }
        private decimal _lnPorcenProgreso = 0.0M;

  
        #endregion Propiedades



        public DataTable dtSucursales = new DataTable();

        #region Constructors
        public AsistenteOffBase()
        {
            _asistenteOfflineDA = DependencyInjector.Instance.Retrieve<IAsistenteOfflineDA>();
        }
        #endregion Constructors
        public bool ValidarQueFechasSonCorrectas(Nullable<DateTime> tdFechaIni, Nullable<DateTime> tdFechaFin)
        {
            if (!tdFechaIni.HasValue && !tdFechaFin.HasValue)
                return true; //Las dos a null => Ok

            bool llOK = true;

            if (tdFechaIni.HasValue && tdFechaFin.HasValue) //Si tengo las dos fechas
            {
                //Final ha de ser mayor que inicio
                int lnResult = DateTime.Compare(tdFechaIni.Value, tdFechaFin.Value);
                if (lnResult > 0)
                {
                    ew.functions.FUNCTIONS._MessageBox("La fecha final no puede ser inferior a la inicial.", "Atención", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return false;
                }
                return true;
            }
            else
            {
                if (!tdFechaIni.HasValue && tdFechaFin.HasValue) //Si tengo fin pero no origen
                {
                    ew.functions.FUNCTIONS._MessageBox("No se puede definir la fecha fin sin haber definido la inicial.", "Atención", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return false;
                }
            }

            return llOK;
        }

        public void Cargar_Variables()
        {
            DataTable tablaDatos = _asistenteOfflineDA.GetVariables(IdConf.ToString());
            if (tablaDatos.Rows.Count == 0 || tablaDatos == null)
            {
                return;
            }

            foreach (DataRow variable in tablaDatos.Rows)
            {
                switch (variable["VARIABLE"].ToString().Trim().ToUpper())
                {
                    case "TIPOOFFLINE":
                        if (variable["VALOR"].ToString().Trim().ToUpper() == "CENTRAL")
                            TipoOffline = 1;
                        else
                            TipoOffline = 2;
                        break;

                    case "CODIGOSUCURSAL":
                        CodigoSucursal = variable["VALOR"].ToString().Trim();
                        break;

                    case "BACKUP_RECEP":
                        {
                            var trozos = variable["VALOR"].ToString().Split('|');

                            if (trozos.Length == 3)
                            {
                                BackupSel = trozos[0].Trim().ToUpper() == ".T.";
                                BackupPath = trozos[1].Trim();
                                BackupNumArchivos = Convert.ToInt32(trozos[2]);
                            }
                            else
                            {
                                // TODO
                                // La configuración del backup de recepción se definirá en otro lugar
                            }
                            break;
                        }
                    case "ENVIARIMAGENES":
                        EnviarImagenes = variable["VALOR"].ToString().Trim() == ".T.";
                        break;
                    case "FILTROPORALMACEN":
                        FiltroPorAlmacen = variable["VALOR"].ToString().Trim() == ".T.";
                        break;
                    case "TERMINALSEGURIDAD":
                        TerminalSeguridad = variable["VALOR"].ToString().Trim() == ".T.";
                        break;
                    case "HORA_ENVIO":
                        Hora_Envio = variable["VALOR"].ToString().Trim();
                        break;
                    case "HORA_RECEPCION":
                        Hora_Recepcion = variable["VALOR"].ToString().Trim();
                        break;
                    case "HORA_CARGAINI":
                        Hora_CargaIni = variable["VALOR"].ToString().Trim();
                        break;
                    case "DELETE_CEN_MANT":
                        Delete_Cen_Mant = variable["VALOR"].ToString().Trim() == ".T." ? 1 : 2;
                        break;
                    case "DELETE_CEN_DOC":
                        Delete_Cen_Doc = variable["VALOR"].ToString().Trim() == ".T." ? 1 : 2;
                        break;
                    case "SERIECENTRAL":
                        Serie_Central = variable["VALOR"].ToString().Trim();
                        break;
                    case "NORECALCULOSTOCKIMP":
                        NoRecalculoStockTrasRecibir = variable["VALOR"].ToString().Trim() == ".T.";
                        break;
                }
            }

            string lcUsuario = Convert.ToString(EW_GLOBAL._GetVariable("wc_usuario")).TrimEnd();

            if (lcUsuario == "SUPERVISOR" || lcUsuario == "OFFLINE")
            {
                CodigoConfiguracion = _asistenteOfflineDA.GetCodigoConfiguracion(IdConf.ToString());
                    //DB.SQLValor("MULTCONF", "IDCONF", IdConf.ToString(), "CODIGO", "OFFLINE").ToString();
            }
            else
            {
                string codConf = _asistenteOfflineDA.GetCodigoConfiguracion(IdConf.ToString(), lcUsuario);
                if (!string.IsNullOrEmpty(codConf))
                {
                    CodigoConfiguracion = codConf;
                }
                
            }

            if (TipoOffline != 1)
            {
                sucursal = _asistenteOfflineDA.GetSucursal(IdConf.ToString(), CodigoSucursal) ?? null;
            }
        }

        private void cargarSucursales()
        {
            DataTable tablaDatos = _asistenteOfflineDA.GetSucursales(IdConf);

            _Sucursales.Clear();
            foreach (DataRow ldrFila in tablaDatos.Rows)
            {
                Sucursales suc = new Sucursales(ldrFila);

                if (IsCentral || (IsSucursal && suc._codigo == _asistenteOfflineDA.CodigoSucursalActual()))
                {
                    _Sucursales.Add(suc);
                }
            }
        }

        public bool ComprobacionesConfiguradoCentraloSucursal()
        {
            bool ret = true;

            ret = GrupoEmpresaConfiguradoComoCentraloSucursal();
          
            return ret;
        }

        public bool ComprobacionesCreadoConfiguracion(bool lbAsistConf)
        {
            bool ret = true;

            ret = SeHaCreadoConfiguracion(lbAsistConf);
  
            return ret;
        }

        public bool ComprobacionesConfigSoloRecepcion()
        {
            return _asistenteOfflineDA.IsConfigSoloTipoRecepcion();
        }

        public bool ComprobacionesConfigSoloEnvio()
        {
            return _asistenteOfflineDA.IsConfigSoloTipoEnvio();
        }

        public bool ComprobacionesUsuarioConfiguracion()
        {
            string lcUsuario = Convert.ToString(EW_GLOBAL._GetVariable("wc_usuario")).TrimEnd();
            if (lcUsuario != "SUPERVISOR" && lcUsuario != "OFFLINE" && lcUsuario != "SAGESYSTEM")
            {
                return _asistenteOfflineDA.IsUsuarioConfiguracion(lcUsuario);
            }

            return true;

            //if (lcUsuario != "SUPERVISOR" && lcUsuario != "OFFLINE")
            //{
            //    DataTable ldtUsuario = new DataTable();
            //    DB.SQLExec("SELECT USUARIO, IDCONF FROM " + DB.SQLDatabase("OFFLINE", "USERCONF") + " WHERE USUARIO = " + DB.SQLString(lcUsuario) + " AND VALOR = 1",  ref ldtUsuario);

            //    return ldtUsuario.Rows.Count > 0;
            //}
            //return true;
        }

        public bool ValidacionEjercicioPredet()
        {
            string lcAny = _asistenteOfflineDA.GetEjercicioPredeterminado();

            if (lcAny == Convert.ToString(EW_GLOBAL._GetVariable("wc_any")))
            {
                return true;
            }

            return false;
        }

        public string GetEjercicioPredeterminado()
        {
            return _asistenteOfflineDA.GetEjercicioPredeterminado();
        }

        public DataTable GetEjerciciosOffline()
        {
            return _asistenteOfflineDA.GetEjerciciosOffline();
        }

        public DataTable GetClaves(Dictionary<Int32, string> claves, string where = "")
        {
            StringBuilder sb = new StringBuilder();
            int i = 0;
            foreach (KeyValuePair<int, string> item in claves)
            {
                sb.Append("'" + item.Value.TrimEnd() + "'");
                if (i < claves.Count - 1)
                {
                    sb.Append(",");
                }
                i++;
            }
            string sClaves = "(" + sb.ToString() + ")";
            return _asistenteOfflineDA.GetClaves(sClaves, where);
            //DataTable dtRet = new DataTable();
            //string lcSql = "Select * from " + DB.SQLDatabase("offline", "tabrelnet") +
            //     " where clave in " + sClaves;
            //if (!string.IsNullOrEmpty(where))
            //{
            //    lcSql += where;
            //}

            //DB.SQLExec(lcSql, ref dtRet);
            //return dtRet;
        }

        public bool ValidarFechas()
        {
            return _asistenteOfflineDA.IsConfigSoloTipoRecepcion();
        }

        public DataTable Datos_TabNetConf(string codigoConfiguracion)
        {
            return _asistenteOfflineDA.Datos_TabNetConf(codigoConfiguracion);
        }

        public virtual bool AlmenosUnoMarcadaActivaPaso1()
        {
            bool ret = false;
            foreach (DataRow row in dtSucursales.Rows)
            {
                if (row["sel"] != DBNull.Value && Convert.ToBoolean(row["sel"]) && Convert.ToBoolean(row["activa"]))
                {
                    ret = true;
                    break;
                }
            }
            return ret;
        }


        public DataTable GetSucursales()
        {
            DataTable ret = dtSucursales.Clone();

            foreach (DataRow row in dtSucursales.Rows)
            {
                if (row["sel"] != DBNull.Value && Convert.ToBoolean(row["sel"]) && Convert.ToInt32(row["activa"]) != 0)
                {
                    ret.ImportRow(row);
                }
            }

            return ret;
        }

        public Dictionary<int, int> ObtenerPrioridades()
        {
            // Obtenemos las prioridades según selección central o sucursal
            DataTable datos = _asistenteOfflineDA.GetPrioridades();
            Dictionary<int, int> dicPrioridades = new Dictionary<int, int>();

            //string lcSql = " SELECT IDTABREL, PRIO_DATOS FROM " + DB.SQLDatabase("OFFLINE", "PRIORIDAD");

            //DB.SQLExec(lcSql, ref datos);

            foreach (DataRow rowPrioridad in datos.Rows)
            {
                dicPrioridades.Add(Convert.ToInt32(rowPrioridad["IDTABREL"]), Convert.ToInt32(rowPrioridad["PRIO_DATOS"]));
            }

            return dicPrioridades;
        }

        internal DateTime GetDate()
        {
            //DateTime fecha = DateTime.Now;
            //DataTable ldtEjer = new DataTable();
            //string lcSqlEjer = " SELECT MIN(PERIODOINI) AS FECHAINI FROM " + DB.SQLDatabase("COMUNES", "EJERCICI");
            //if (DB.SQLExec(lcSqlEjer, ref ldtEjer) && ldtEjer.Rows.Count > 0)
            //{
            //    fecha = Convert.ToDateTime(ldtEjer.Rows[0]["fechaini"]);
            //}
            return _asistenteOfflineDA.GetFechaIni();
        }

        internal bool SeHaCreadoConfiguracion(bool lbAsistConf)
        {
            //DataTable ldtDatos = new DataTable();
            //string lcSqlMultConf = " SELECT IDCONF, TIPO FROM " + DB.SQLDatabase("OFFLINE", "MULTCONF") + " WHERE TIPO = 0 OR TIPO = 1";            
            //if (DB.SQLExec(lcSqlMultConf, ref ldtDatos) && ldtDatos.Rows.Count > 0)
            //{
            //    DataTable dtTemp = new DataTable();
            //    string lcSql = "Select count(*) as total from " + DB.SQLDatabase("OFFLINE", "TABRELCONF");
            //    DB.SQLExec(lcSql, ref dtTemp);

            //    return dtTemp.Rows.Count > 0 && Convert.ToInt32(dtTemp.Rows[0]["total"]) > 0;
            //}

            return _asistenteOfflineDA.SeHaCreadoConfiguracion(lbAsistConf);
        }

        internal bool GrupoEmpresaConfiguradoComoCentraloSucursal()
        {
            return !string.IsNullOrEmpty(Convert.ToString(ew.db.DB.SQLValor("VARIABLES", "VARIABLE", "TIPOOFFLINE", "VALOR", "OFFLINE")).Trim().ToUpper());
        }

        internal bool Result_LogComunicaciones(ref DataTable table, DateTime startProces, int resultado = 1)
        {
            return _asistenteOfflineDA.Result_LogComunicaciones(ref table, startProces, resultado);
        }

        internal bool Result_LogComunicaciones_Error(ref DataTable table, DateTime startProces)
        {
            return _asistenteOfflineDA.Result_LogComunicaciones_Error(ref table, startProces);
        }

        internal Dictionary<string, int> Result_LogComunicaciones_IdLog(ref DataTable table, string idLog)
        {
            return _asistenteOfflineDA.Result_LogComunicaciones_IdLog(ref table, idLog);
        }

        #region Metodos privados


        private void ActualizarProgresoDetalle()
        {
            if (_Mostrar_Progreso_Async != null)
                _Mostrar_Progreso_Async(_TextStepDetalle);

        }

        private void ActualizarBarraProgreso()
        {
            if (_Porcen_Progreso_Async != null)
                _Porcen_Progreso_Async(_PorcenProgreso, _TextStepDetalle);

        }

        private string GetSerieDefectoCurrentSucursal()
        {
            //DataTable dtSeries = new DataTable();

            //string tcSql = string.Format("SELECT * FROM {0} ", DB.SQLDatabase("OFFLINE", "SUCURLET"));
            //DB.SQLExec(tcSql, ref dtSeries);

            //var res = dtSeries.AsEnumerable().Where(S => S["SUCURSAL"].ToString() == this.CodigoSucursal).FirstOrDefault();

            //if (res != null)
            //    return res["LETRA"].ToString();

            return _asistenteOfflineDA.GetSerieDefectoCurrentSucursal(CodigoSucursal);
        }

        private string GetAlmacenDefectoCurrentSucursal()
        {
            //DataTable dtAlm = new DataTable();

            //string tcSql = string.Format("SELECT * FROM {0} ", DB.SQLDatabase("OFFLINE", "SUCURALM"));
            //DB.SQLExec(tcSql, ref dtAlm);

            //var res = dtAlm.AsEnumerable().Where(S => S["SUCURSAL"].ToString() == this.CodigoSucursal).FirstOrDefault();

            //if (res != null)
            //    return res["ALMACEN"].ToString();

            return _asistenteOfflineDA.GetAlmacenDefectoCurrentSucursal(CodigoSucursal);
        }
        #endregion            
    }
}