public UsuarioModelo ValidarInicioSesionAsync <T>(object objeto)
        {
            List <Dictionary <string, string> > respuesta = new List <Dictionary <string, string> >();
            UsuarioModelo usuario = new UsuarioModelo();

            usuario = objeto as UsuarioModelo;
            try
            {
                Dictionary <string, object> parametros = new Dictionary <string, object>
                {
                    { "us_correo_electronico", usuario.Correo },
                    { "us_password", usuario.Contrasenia }
                };

                string storeProcedure = "sps_consulta_usuario_catastro";
                respuesta = gestionConexiones.EjecutaStoreProcedureConsulta(Utilitario.SerializarIdentado(parametros), string.Empty, storeProcedure);
                if (respuesta.Count >= 1)
                {
                    string respuestaStr = Utilitario.SerializarIdentado(respuesta[0]);
                    return(Utilitario.Deserializar <UsuarioModelo>(respuestaStr));
                }
                else
                {
                    return(null);
                }
            }
            catch (Exception ex)
            {
                //respuesta = conexionGestion.AsignarDatosRespuesta(Enumerador.EnumTipoRespuesta.ErrorException, Constantes.RESPUESTA_MENSAJE_ERROR);
                //UtilitarioLogs.PreparaGuardaLogsBase(ex, Enumerador.EnumTipoRespuesta.ErrorException, datosMetodo);
            }
            return(null);
        }
        //public RespuestaComun GuardaLogsBase(string parametrosSP, string spNombre, DatosMetodo metodo)
        //{
        //    this.abrirConexion();
        //    RespuestaComun respuesta = new RespuestaComun();
        //    try
        //    {
        //        SqlCommand cm = new SqlCommand(spNombre, this.con)
        //        {
        //            CommandType = CommandType.StoredProcedure
        //        };
        //        SqlCommandBuilder.DeriveParameters(cm);

        //        var parametrosJsonSp = UtilitarioRest.Deserializar<Dictionary<string, string>>(parametrosSP);
        //        foreach (SqlParameter param in cm.Parameters)
        //        {
        //            if (param.Direction == ParameterDirection.Input)
        //            {
        //                foreach (var parametroJson in parametrosJsonSp)
        //                {
        //                    if (parametroJson.Value != null && parametroJson.Value.GetType().Name == Constantes.TIPO_DATO_JOBJECT)
        //                    {
        //                        var dictionary = ToDictionary<string>(parametroJson.Value);
        //                        foreach (var parametrosInternos in dictionary)
        //                            param.Value = SeteaParametrosSql(param, parametrosInternos.Key,
        //                                parametrosInternos.Value == null ? string.Empty : parametrosInternos.Value.ToString()).Value;
        //                    }
        //                    else
        //                        param.Value = SeteaParametrosSql(param, parametroJson.Key,
        //                            parametroJson.Value == null ? string.Empty : parametroJson.Value.ToString()).Value;
        //                }
        //            }
        //        }

        //        int filasAfectadas = cm.ExecuteNonQuery();
        //        cm.Dispose();
        //        this.cerrarConexion();
        //        respuesta = AsignarDatosRespuesta(Enumerador.EnumTipoRespuesta.RespuestaOk, Constantes.RESPUESTA_MENSAJE_OK);
        //    }
        //    catch (SqlException sqlex)
        //    {
        //        UtilitarioLogs.PreparaLogsBaseArchivo(sqlex, Enumerador.EnumTipoRespuesta.ErrorException, metodo);
        //        respuesta = AsignarDatosRespuesta(Enumerador.EnumTipoRespuesta.ErrorSqlException, Constantes.RESPUESTA_MENSAJE_ERROR);
        //    }
        //    catch (Exception ex)
        //    {
        //        UtilitarioLogs.PreparaLogsBaseArchivo(ex, Enumerador.EnumTipoRespuesta.ErrorException, metodo);
        //        respuesta = AsignarDatosRespuesta(Enumerador.EnumTipoRespuesta.ErrorException, Constantes.RESPUESTA_MENSAJE_ERROR);
        //    }
        //    finally
        //    {
        //        if (this.con.State == ConnectionState.Open)
        //        {
        //            this.con.Close();
        //        }
        //    }
        //    return respuesta;
        //}

        public static Dictionary <string, TValue> ToDictionary <TValue>(object obj)
        {
            var json       = Utilitario.SerializarIdentado(obj);
            var dictionary = Utilitario.Deserializar <Dictionary <string, TValue> >(json);

            return(dictionary);
        }
        public List <FichaCatastroModel> ListadoRegistroCatastro()
        {
            string subProductosEmail = string.Empty;
            List <Dictionary <string, string> > respuesta = new List <Dictionary <string, string> >();
            List <FichaCatastroModel>           oFicha    = null;

            try
            {
                string storeProcedure = "sps_listado_fichas_catastro";
                respuesta = gestionConexiones.EjecutaStoreProcedureConsulta(null, string.Empty, storeProcedure);

                if (respuesta.Count >= 1)
                {
                    string respuestaStr = Utilitario.SerializarIdentado(respuesta);
                    oFicha = Utilitario.Deserializar <List <FichaCatastroModel> >(respuestaStr);
                }
                else
                {
                    return(null);
                }
            }
            catch (Exception ex)
            {
                //respuesta = conexionGestion.AsignarDatosRespuesta(Enumerador.EnumTipoRespuesta.ErrorException, Constantes.RESPUESTA_MENSAJE_ERROR);
                //UtilitarioLogs.PreparaGuardaLogsBase(ex, Enumerador.EnumTipoRespuesta.ErrorException, datosMetodo);
            }
            return(oFicha);
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="oFicha"></param>
        /// <param name="accion"></param>
        /// <returns></returns>
        public FichaCatastroModel ConsultarFichaCatastro(FichaCatastroModel oFicha, string accion)
        {
            string subProductosEmail = string.Empty;
            List <Dictionary <string, string> > respuesta = new List <Dictionary <string, string> >();

            try
            {
                Dictionary <string, object> parametros = new Dictionary <string, object>
                {
                    { "CodigoCatastral", oFicha.CodigoCatastral }
                };

                string storeProcedure = "sps_ficha_catastro_x_codigo_catastro";
                respuesta = gestionConexiones.EjecutaStoreProcedureConsulta(Utilitario.SerializarIdentado(parametros), string.Empty, storeProcedure);
                if (respuesta.Count >= 1)
                {
                    string respuestaStr = Utilitario.SerializarIdentado(respuesta[0]);
                    oFicha = Utilitario.Deserializar <FichaCatastroModel>(respuestaStr);
                }
                else
                {
                    return(null);
                }
            }
            catch (Exception ex)
            {
                //respuesta = conexionGestion.AsignarDatosRespuesta(Enumerador.EnumTipoRespuesta.ErrorException, Constantes.RESPUESTA_MENSAJE_ERROR);
                //UtilitarioLogs.PreparaGuardaLogsBase(ex, Enumerador.EnumTipoRespuesta.ErrorException, datosMetodo);
            }
            return(oFicha);
        }
        public T ValidarInicioSesion <T>(object objeto)
        {
            string respuestaJson = VelbyRest.PostRest <T>("Usuario/InicioSesion", objeto, Constantes.TOKEN);
            T      respuesta     = default(T);

            respuesta = Utilitario.Deserializar <T>(respuestaJson);
            return(respuesta);
        }
        public List <Dictionary <string, string> > EjecutaStoreProcedureConsulta(string parametrosSP, string parametroDatoMetodo, string spNombre)
        {
            //DatosMetodo Metodo = Utilitario.Deserializar<DatosMetodo>(parametroDatoMetodo);
            List <Dictionary <string, string> > lstOpenWith = new List <Dictionary <string, string> >();

            try
            {
                abrirConexion();
                SqlCommand cm = new SqlCommand(spNombre, this.con)
                {
                    CommandType = CommandType.StoredProcedure
                };
                SqlCommandBuilder.DeriveParameters(cm);

                var parametrosJsonSp = Utilitario.Deserializar <Dictionary <string, string> >(parametrosSP);
                foreach (SqlParameter param in cm.Parameters)
                {
                    if (param.Direction == ParameterDirection.Input)
                    {
                        if (parametrosJsonSp != null)
                        {
                            foreach (var parametroJson in parametrosJsonSp)
                            {
                                if (param.ParameterName.Replace("@_", "").ToUpper() == parametroJson.Key.ToUpper())
                                {
                                    switch (param.SqlDbType.ToString().ToUpper())
                                    {
                                    case "INT":
                                    case "INT32":
                                    case "INT64":
                                        if (string.IsNullOrEmpty(parametroJson.Value))
                                        {
                                            param.Value = 0;
                                        }
                                        else
                                        {
                                            param.Value = int.Parse(parametroJson.Value);
                                        }
                                        break;

                                    case "DECIMAL":
                                        if (string.IsNullOrEmpty(parametroJson.Value))
                                        {
                                            param.Value = 0.0;
                                        }
                                        else
                                        {
                                            param.Value = int.Parse(parametroJson.Value);
                                        }
                                        break;

                                    case "VARCHAR":
                                    case "NVARCHAR":
                                        if (string.IsNullOrEmpty(parametroJson.Value))
                                        {
                                            param.Value = string.Empty;
                                        }
                                        else
                                        {
                                            param.Value = parametroJson.Value;
                                        }
                                        break;

                                    case "DATETIME":
                                    case "TIME":

                                        //string fecha = parametroJson.Value;
                                        //fecha = "[\"" + fecha.Replace("/", "\\/") + "\"]";
                                        //DateTime dt = ser.Deserialize<DateTime[]>(fecha).Single();
                                        //param.Value = dt;
                                        //DateTime.ParseExact(parametroJson.Value, "dd/MM/yyyy", CultureInfo.InvariantCulture);
                                        if (string.IsNullOrEmpty(parametroJson.Value))
                                        {
                                            param.Value = DateTime.Now;
                                        }
                                        else
                                        {
                                            param.Value = DateTime.Parse(parametroJson.Value);
                                        }
                                        //param.Value = DateTime.ParseExact(parametroJson.Value, "yyyy-MM-dd", CultureInfo.InvariantCulture);
                                        break;

                                    case "BIT":
                                        if (string.IsNullOrEmpty(parametroJson.Value))
                                        {
                                            param.Value = 0;
                                        }
                                        else
                                        {
                                            param.Value = int.Parse(parametroJson.Value);
                                        }

                                        break;

                                    case "IMAGE":
                                        if (string.IsNullOrEmpty(parametroJson.Value))
                                        {
                                            param.Value = string.Empty;
                                        }
                                        else
                                        {
                                            param.Value = parametroJson.Value;
                                        }
                                        break;
                                    }
                                    break;
                                }
                            }
                        }
                    }
                }

                SqlDataReader reader = cm.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
                while (reader.Read())
                {
                    Dictionary <string, string> openWith = new Dictionary <string, string>();
                    int numeroColumnas = reader.FieldCount;
                    for (int x = 0; x < numeroColumnas; x++)
                    {
                        string valor = reader.GetValue(x).ToString();
                        //Modificar este metodo para que no este aqui y hacer algo generico
                        if (reader.GetName(x) == "Latitud" || reader.GetName(x) == "Longitud")
                        {
                            valor = reader.GetValue(x).ToString().Replace(Constantes.CHAR_COMA, Constantes.CHAR_PUNTO);
                        }
                        else
                        {
                            switch (reader.GetDataTypeName(x).ToUpper())
                            {
                            case "INT":
                            case "INT32":
                            case "INT64":
                                if (string.IsNullOrEmpty(reader.GetValue(x).ToString()))
                                {
                                    valor = "0";
                                }
                                break;

                            case "DECIMAL":
                                if (string.IsNullOrEmpty(reader.GetValue(x).ToString()))
                                {
                                    valor = "0";
                                }
                                else
                                {
                                    valor = reader.GetValue(x).ToString().Replace(Constantes.CHAR_COMA, Constantes.CHAR_PUNTO);
                                }
                                break;

                            case "DOUBLE":
                                if (string.IsNullOrEmpty(reader.GetValue(x).ToString()))
                                {
                                    valor = "0";
                                }
                                else
                                {
                                    valor = reader.GetValue(x).ToString().Replace(Constantes.CHAR_COMA, Constantes.CHAR_PUNTO);
                                }
                                break;
                            }
                        }

                        openWith.Add(reader.GetName(x), valor);
                    }
                    lstOpenWith.Add(openWith);
                }
                //UtilitarioLogs.PreparaGuardaLogsBase(null, Enumerador.EnumTipoRespuesta.RespuestaOk, Metodo);
            }
            catch (SqlException)
            {
                AsignarDatosRespuesta(Enumerador.EnumTipoRespuesta.ErrorSqlException, Constantes.RESPUESTA_MENSAJE_ERROR);
                //UtilitarioLogs.PreparaGuardaLogsBase(sqlex, Enumerador.EnumTipoRespuesta.RespuestaOk, Metodo);
            }
            catch (Exception ex)
            {
                AsignarDatosRespuesta(Enumerador.EnumTipoRespuesta.ErrorException, Constantes.RESPUESTA_MENSAJE_ERROR);
                //UtilitarioLogs.PreparaGuardaLogsBase(ex, Enumerador.EnumTipoRespuesta.RespuestaOk, Metodo);
                throw ex;
            }
            finally
            {
                if (this.con.State == ConnectionState.Open)
                {
                    this.con.Close();
                }
            }
            return(lstOpenWith);
        }
        public RespuestaComun EjecutaStoreProcedure(string parametrosSP, string parametroDatoMetodo, string spNombre)
        {
            this.abrirConexion();
            RespuestaComun respuesta = new RespuestaComun();

            try
            {
                SqlCommand cm = new SqlCommand(spNombre, this.con)
                {
                    CommandType = CommandType.StoredProcedure
                };
                SqlCommandBuilder.DeriveParameters(cm);

                var parametrosJsonSp = Utilitario.Deserializar <Dictionary <string, object> >(parametrosSP);
                foreach (SqlParameter param in cm.Parameters)
                {
                    if (param.Direction == ParameterDirection.Input)
                    {
                        foreach (var parametroJson in parametrosJsonSp)
                        {
                            if (parametroJson.Value != null && parametroJson.Value.GetType().Name == Constantes.TIPO_DATO_JOBJECT)
                            {
                                var dictionary = ToDictionary <string>(parametroJson.Value);
                                foreach (var parametrosInternos in dictionary)
                                {
                                    param.Value = SeteaParametrosSql(param, parametrosInternos.Key,
                                                                     parametrosInternos.Value == null ? string.Empty : parametrosInternos.Value.ToString()).Value;
                                }
                            }
                            else
                            {
                                param.Value = SeteaParametrosSql(param, parametroJson.Key,
                                                                 parametroJson.Value == null ? string.Empty : parametroJson.Value.ToString()).Value;
                            }
                        }
                    }
                    if (param.Direction == ParameterDirection.InputOutput)
                    {
                        param.Value     = "0";
                        param.SqlDbType = SqlDbType.SmallInt;
                        param.Direction = ParameterDirection.Output;
                        param.Size      = 4;
                    }
                }
                string valorRetorno   = string.Empty;
                int    filasAfectadas = cm.ExecuteNonQuery();
                cm.Dispose();
                this.cerrarConexion();

                respuesta = AsignarDatosRespuesta(Enumerador.EnumTipoRespuesta.RespuestaOk, Constantes.RESPUESTA_MENSAJE_OK);
                respuesta.FilasAfectadas = filasAfectadas;
                //UtilitarioLogs.PreparaGuardaLogsBase(null, Enumerador.EnumTipoRespuesta.RespuestaOk, Metodo);
                respuesta.ValorRetorno = valorRetorno;
            }
            catch (SqlException sqlex)
            {
                //UtilitarioLogs.PreparaGuardaLogsBase(sqlex, Enumerador.EnumTipoRespuesta.ErrorSqlException, Metodo);
                respuesta = AsignarDatosRespuesta(Enumerador.EnumTipoRespuesta.ErrorSqlException, Constantes.RESPUESTA_MENSAJE_ERROR);
            }
            catch (Exception ex)
            {
                //UtilitarioLogs.PreparaGuardaLogsBase(ex, Enumerador.EnumTipoRespuesta.ErrorException, Metodo);
                respuesta = AsignarDatosRespuesta(Enumerador.EnumTipoRespuesta.ErrorException, Constantes.RESPUESTA_MENSAJE_ERROR);
            }
            finally
            {
                if (this.con.State == ConnectionState.Open)
                {
                    this.con.Close();
                }
            }
            return(respuesta);
        }
        public List <modFicha> ListaRegistroCatastro()
        {
            string subProductosEmail = string.Empty;
            List <Dictionary <string, string> > respuesta = new List <Dictionary <string, string> >();
            List <modFicha> oFicha = null;

            //string pathFile = AppDomain.CurrentDomain.BaseDirectory + "miExcel.xlsx";
            try
            {
                string storeProcedure = "sps_fichas_catastro";
                respuesta = gestionConexiones.EjecutaStoreProcedureConsulta(null, string.Empty, storeProcedure);

                if (respuesta.Count >= 1)
                {
                    string respuestaStr = Utilitario.SerializarIdentado(respuesta);
                    oFicha = Utilitario.Deserializar <List <modFicha> >(respuestaStr);

                    //string pathFile = AppDomain.CurrentDomain.BaseDirectory + "miExcel.xlsx";
                    //SLDocument oSLDocument = new SLDocument();

                    //System.Data.DataTable dt = new System.Data.DataTable();

                    ////columnas
                    //dt.Columns.Add("CodigoUnico", typeof(string));
                    //dt.Columns.Add("CodigoCatastral", typeof(string));
                    //dt.Columns.Add("ClaveAnterior", typeof(string));
                    //dt.Columns.Add("TipoIdentificacion", typeof(string));
                    //dt.Columns.Add("TextoTipoIdentificacion", typeof(string));
                    //dt.Columns.Add("NumeroIdentificacion", typeof(string));
                    //dt.Columns.Add("NombrePropietario", typeof(string));
                    //dt.Columns.Add("PropietarioAnterior", typeof(string));
                    //dt.Columns.Add("Direccion", typeof(string));
                    //dt.Columns.Add("Barrio", typeof(string));
                    //dt.Columns.Add("UsoPredio", typeof(string));
                    //dt.Columns.Add("TextoUsoPredio", typeof(string));
                    //dt.Columns.Add("Escritura", typeof(string));
                    //dt.Columns.Add("TextoEscritura", typeof(string));
                    //dt.Columns.Add("Ocupacion", typeof(string));
                    //dt.Columns.Add("TextoOcupacion", typeof(string));
                    //dt.Columns.Add("Localizacion", typeof(string));
                    //dt.Columns.Add("TextoLocalizacion", typeof(string));
                    //dt.Columns.Add("NumeroPiso", typeof(string));
                    //dt.Columns.Add("Abastecimiento", typeof(string));
                    //dt.Columns.Add("TextoAbastecimiento", typeof(string));
                    //dt.Columns.Add("AguaRecib", typeof(string));
                    //dt.Columns.Add("TextoAguaRecib", typeof(string));
                    //dt.Columns.Add("Alcantarillado", typeof(string));
                    //dt.Columns.Add("TextoAlcantarillado", typeof(string));
                    //dt.Columns.Add("CodigoLocalizacion", typeof(string));
                    //dt.Columns.Add("TieneMedidor", typeof(string));
                    //dt.Columns.Add("UsuarioRegistro", typeof(string));
                    //dt.Columns.Add("Observacion", typeof(string));
                    //int i = 0;
                    //foreach (modFicha item in oFicha)
                    //{
                    //    i++;
                    //    //registros , rows
                    //    dt.Rows.Add(
                    //    item.CodigoUnico
                    //    , item.CodigoCatastral
                    //    , item.ClaveAnterior
                    //    , item.TipoIdentificacion
                    //    , item.TextoTipoIdentificacion
                    //    , item.NumeroIdentificacion
                    //    , item.NombrePropietario
                    //    , item.PropietarioAnterior
                    //    , item.Direccion
                    //    , item.Barrio
                    //    , item.UsoPredio
                    //    , item.TextoUsoPredio
                    //    , item.Escritura
                    //    , item.TextoEscritura
                    //    , item.Ocupacion
                    //    , item.TextoOcupacion
                    //    , item.Localizacion
                    //    , item.TextoLocalizacion
                    //    , item.NumeroPiso
                    //    , item.Abastecimiento
                    //    , item.TextoAbastecimiento
                    //    , item.AguaRecib
                    //    , item.TextoAguaRecib
                    //    , item.Alcantarillado
                    //    , item.TextoAlcantarillado
                    //    , item.CodigoLocalizacion
                    //    , item.TieneMedidor
                    //    , item.UsuarioRegistro
                    //    , item.Observacion);

                    //}



                    //oSLDocument.ImportDataTable(1, 1, dt, true);

                    //oSLDocument.SaveAs(pathFile);
                }
                else
                {
                    return(null);
                }
            }
            catch (Exception ex)
            {
                //respuesta = conexionGestion.AsignarDatosRespuesta(Enumerador.EnumTipoRespuesta.ErrorException, Constantes.RESPUESTA_MENSAJE_ERROR);
                //UtilitarioLogs.PreparaGuardaLogsBase(ex, Enumerador.EnumTipoRespuesta.ErrorException, datosMetodo);
            }
            return(oFicha);
        }