Exemple #1
0
        public List <PermisoUsuario> Listar_PermisosUsuario(string S_UserName)
        {
            var listPermission = new List <PermisoUsuario>();

            var oDatabase  = DatabaseFactory.CreateDatabase();
            var oDbCommand = oDatabase.GetStoredProcCommand("up_Login_PermisosUsuario");

            oDatabase.AddInParameter(oDbCommand, "@S_UserName", DbType.String, S_UserName);

            using (var oReader = oDatabase.ExecuteReader(oDbCommand))
            {
                while (oReader.Read())
                {
                    var objPermission = new PermisoUsuario
                    {
                        N_IDPermiso         = DataConvert.ToInt32(oReader["N_IDPermiso"]),
                        S_IDGrupo           = DataConvert.ToString(oReader["S_IDGrupo"]),
                        S_GrupoDescripcion  = DataConvert.ToString(oReader["S_GrupoDescripcion"]),
                        S_IDPagina          = DataConvert.ToString(oReader["S_IDPagina"]),
                        S_PaginaDescripcion = DataConvert.ToString(oReader["S_PaginaDescripcion"]),
                        S_IDAccion          = DataConvert.ToString(oReader["S_IDAccion"]),
                        S_AccionDescripcion = DataConvert.ToString(oReader["S_AccionDescripcion"])
                    };

                    listPermission.Add(objPermission);
                }
                oReader.Close();
            }
            return(listPermission);
        }
Exemple #2
0
    public static void actualizarUsuarioPermiso(PermisoUsuario obj)
    {
        if (obj == null)
        {
            throw new ArgumentException("El objeto a insertar no puede tener un valor nulo");
        }

        if (obj.UsuarioPermisoId <= 0)
        {
            throw new ArgumentException("El objeto a insertar no puede ser menor o igual a 0");
        }

        if (obj.UsuarioId == 0)
        {
            throw new ArgumentException("el Codigo de Usuario es 0");
        }

        if (obj.PermisoId == 0)
        {
            throw new ArgumentException("el Codigo de Permiso es 0");
        }



        UsuarioPermisosDSTableAdapters.UsuarioPermisoTableAdapter adapter = new UsuarioPermisosDSTableAdapters.UsuarioPermisoTableAdapter();
        adapter.Update(obj.UsuarioId, obj.PermisoId, obj.UsuarioPermisoId);
    }
Exemple #3
0
        public async Task <IActionResult> Login(Login login, string returnUrl = null)
        {
            if (!ModelState.IsValid)
            {
                return(RedirectToAction(nameof(LoginController.Index)));
            }

            var response = await apiServicio.ObtenerElementoAsync1 <Response>(login,
                                                                              new Uri(WebApp.BaseAddressSeguridad),
                                                                              "/api/Adscpassws/Login");



            if (!response.IsSuccess)
            {
                return(RedirectToAction(nameof(LoginController.Index), new { mensaje = response.Message }));
            }

            var usuario = JsonConvert.DeserializeObject <Adscpassw>(response.Resultado.ToString());

            var codificar = new Codificar
            {
                Entrada = Convert.ToString(DateTime.Now),
            };

            Guid guidUsuario;

            guidUsuario = Guid.NewGuid();

            var permisoUsuario = new PermisoUsuario
            {
                Usuario = usuario.AdpsLogin,
                Token   = Convert.ToString(guidUsuario),
            };



            var salvarToken = await apiServicio.InsertarAsync <Response>(permisoUsuario, new Uri(WebApp.BaseAddressSeguridad), "/api/Adscpassws/SalvarToken");


            var claims = new[]
            {
                new Claim(ClaimTypes.Name, usuario.AdpsLogin),
                new Claim(ClaimTypes.SerialNumber, Convert.ToString(guidUsuario))
            };



            var principal = new ClaimsPrincipal(new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme));

            await HttpContext.Authentication.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, principal);

            if (string.IsNullOrEmpty(returnUrl))
            {
                return(RedirectToAction(nameof(HomesController.Index), "Homes"));
            }

            return(LocalRedirect(returnUrl));
        }
Exemple #4
0
        /// <summary>
        /// Método que válida si el usuario actual tiene permiso para realizar la acción solicitada en el contecto
        /// El usuario debe tener los permisos en la base de datos
        /// </summary>
        /// <param name="context"></param>
        /// <param name="requirement"></param>
        /// <returns>Si la acción solicitada es o no satisfactoria</returns>
        protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, RolesRequirement requirement)
        {
            try
            {
                /// <summary>
                /// Se obtiene el contexto de datos
                /// </summary>
                /// <returns></returns>
                var recurso     = context.Resource as Microsoft.AspNetCore.Mvc.Filters.AuthorizationFilterContext;
                var httpContext = recurso.HttpContext;

                /// <summary>
                /// Se obtiene el path solicitado
                /// </summary>
                /// <returns></returns>
                var request = httpContext.Request;


                /// <summary>
                /// Se obtiene información del usuario autenticado
                /// </summary>
                /// <returns></returns>
                var claim         = context.User.Identities.Where(x => x.NameClaimType == ClaimTypes.Name).FirstOrDefault();
                var token         = claim.Claims.Where(c => c.Type == ClaimTypes.SerialNumber).FirstOrDefault().Value;
                var NombreUsuario = claim.Claims.Where(c => c.Type == ClaimTypes.Name).FirstOrDefault().Value;

                var permiso = new PermisoUsuario
                {
                    Contexto = request.Path,
                    Token    = token,
                    Usuario  = NombreUsuario,
                };

                /// <summary>
                /// Se valida que la información del usuario actual tenga permiso para acceder al path solicitado...
                /// </summary>
                /// <returns></returns>
                var respuesta = apiServicio.ObtenerElementoAsync1 <Response>(permiso, new Uri(WebApp.BaseAddress), "api/Adscpassws/TienePermiso");

                //respuesta.Result.IsSuccess = true;
                if (respuesta.Result.IsSuccess)
                {
                    context.Succeed(requirement);
                }
                else
                {
                    context.Fail();
                }
            }
            catch (Exception)
            {
                context.Fail();
                return(Task.CompletedTask);
            }

            return(Task.FromResult(0));
        }
Exemple #5
0
 public PermisoUsuario Add(PermisoUsuario entity)
 {
     try
     {
         return(repository.Add(entity));
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Exemple #6
0
    public static void insertUsuarioPermiso(PermisoUsuario obj)
    {
        if (obj == null)
        {
            throw new ArgumentException("El objeto UsuarioPermiso no debe ser nulo");
        }

        int?usuarioPermisoId = 0;

        UsuarioPermisosDSTableAdapters.UsuarioPermisoTableAdapter adapter = new UsuarioPermisosDSTableAdapters.UsuarioPermisoTableAdapter();
        adapter.Insert(obj.UsuarioId, obj.PermisoId, ref usuarioPermisoId);
    }
Exemple #7
0
    public static void eliminarUsuarioPermisoByUsuarioIdPermisoId(int usuarioId, int permisoId)
    {
        UsuarioPermisosDSTableAdapters.UsuarioPermisoTableAdapter adapter = new UsuarioPermisosDSTableAdapters.UsuarioPermisoTableAdapter();
        UsuarioPermisosDS.UsuarioPermisoDataTable table = adapter.GetIdByUserPerm(usuarioId, permisoId);

        var row = table[0];

        PermisoUsuario obj = new PermisoUsuario();

        obj.UsuarioPermisoId = row.usuarioPermisoId;

        eliminarUsuarioPermisoById(obj.UsuarioPermisoId);
    }
        public async Task <ActionResult> AbrirSistema(string host)
        {
            try
            {
                var a = new Guid();
                /// <summary>
                /// Se obtiene información del usuario autenticado
                /// </summary>
                var claim         = HttpContext.User.Identities.Where(x => x.NameClaimType == ClaimTypes.Name).FirstOrDefault();
                var token         = claim.Claims.Where(c => c.Type == ClaimTypes.SerialNumber).FirstOrDefault().Value;
                var NombreUsuario = claim.Claims.Where(c => c.Type == ClaimTypes.Name).FirstOrDefault().Value;

                var permiso = new PermisoUsuario
                {
                    Token   = token,
                    Usuario = NombreUsuario,
                };

                /// <summary>
                /// Se válida si el usuario tiene el token válido para realizar la acción de abrir el sistema
                /// </summary>
                var respuesta = apiServicio.ObtenerElementoAsync1 <Response>(permiso, new Uri(WebApp.BaseAddressSeguridad), "api/Adscpassws/TienePermisoTemp");
                //respuesta.Result.IsSuccess = true;
                if (respuesta.Result.IsSuccess)
                {
                    a = Guid.NewGuid();

                    var permisoTemp = new PermisoUsuario
                    {
                        Token   = Convert.ToString(a),
                        Usuario = NombreUsuario,
                    };
                    /// <summary>
                    /// Se salva un Token temporal en la base de datos por usuario para que al abrir el otro sistema este válide
                    /// el token fue generado por esta aplicación
                    /// </summary>
                    var salvarToken = await apiServicio.InsertarAsync <Response>(permisoTemp, new Uri(WebApp.BaseAddressSeguridad), "api/Adscpassws/SalvarTokenTemp");

                    return(Redirect(host + "/Login/Login" + "?miembro=" + NombreUsuario + "&token=" + a.ToString()));
                }
                else
                {
                    return(null);
                }
            }
            catch (Exception)
            {
                return(RedirectToAction(nameof(LoginController.Index), "Login"));
            }
            //return  Redirect(host+"?miembro=" + NombreUsuario);
        }
Exemple #9
0
    public static void eliminarUsuarioPermiso(int usuarioId)
    {
        int usuarioPermisoId = 0;

        UsuarioPermisosDSTableAdapters.UsuarioPermisoTableAdapter adapter = new UsuarioPermisosDSTableAdapters.UsuarioPermisoTableAdapter();
        UsuarioPermisosDS.UsuarioPermisoDataTable table = adapter.GetUsuarioPermisoIdByUsuarioId(usuarioId);

        foreach (var row in table)
        {
            PermisoUsuario obj = new PermisoUsuario();
            usuarioPermisoId = row.usuarioPermisoId;
            adapter.Delete(usuarioPermisoId);
        }
    }
        public async Task <Response> TienePermisoTemp([FromBody] PermisoUsuario permiso)
        {
            try
            {
                var token = await db.Adscpassw.Where(x => x.AdpsToken == permiso.Token && x.AdpsLogin.ToUpper() == permiso.Usuario.ToUpper()).FirstOrDefaultAsync();

                return(new Response {
                    IsSuccess = true
                });
            }
            catch (Exception)
            {
                throw;
            }
        }
        public async Task <Response> SalvarToken([FromBody]  PermisoUsuario permisoUsuario)
        {
            try
            {
                var usuario = db.Adscpassw.Where(x => x.AdpsLogin.ToUpper() == permisoUsuario.Usuario.ToUpper()).FirstOrDefault();

                if (usuario == null)
                {
                    return(new Response
                    {
                        IsSuccess = false,
                        Message = Mensaje.RegistroNoEncontrado
                    });
                }



                usuario.AdpsToken = permisoUsuario.Token;
                db.Adscpassw.Update(usuario);
                await db.SaveChangesAsync();

                return(new Response
                {
                    IsSuccess = true,
                });
            }
            catch (Exception ex)
            {
                await GuardarLogService.SaveLogEntry(new LogEntryTranfer
                {
                    ApplicationName      = Convert.ToString(Aplicacion.SwSeguridad),
                    ExceptionTrace       = ex,
                    LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
                    LogLevelShortName    = Convert.ToString(LogLevelParameter.ERR),
                    Message  = ex.Message,
                    UserName = permisoUsuario.Usuario,
                });

                return(new Response
                {
                    IsSuccess = false,
                    Message = ex.Message,
                });

                throw;
            }
        }
Exemple #12
0
        protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, RolesRequirement requirement)
        {
            try
            {
                //Obtención del Context
                var recurso = context.Resource as Microsoft.AspNetCore.Mvc.Filters.AuthorizationFilterContext;

                var httpContext   = recurso.HttpContext;
                var request       = httpContext.Request;
                var claim         = context.User.Identities.Where(x => x.NameClaimType == ClaimTypes.Name).FirstOrDefault();
                var token         = claim.Claims.Where(c => c.Type == ClaimTypes.SerialNumber).FirstOrDefault().Value;
                var NombreUsuario = claim.Claims.Where(c => c.Type == ClaimTypes.Name).FirstOrDefault().Value;

                var permiso = new PermisoUsuario
                {
                    Contexto = request.Path,
                    Token    = token,
                    Usuario  = NombreUsuario,
                };

                var respuesta = apiServicio.ObtenerElementoAsync1 <Response>(permiso, new Uri(WebApp.BaseAddressSeguridad), "api/Adscpassws/TienePermiso");

                //respuesta.Result.IsSuccess = true;
                if (respuesta.Result.IsSuccess)
                {
                    context.Succeed(requirement);
                }
                else
                {
                    httpContext.Authentication.SignOutAsync("Cookies");
                    foreach (var cookie in httpContext.Request.Cookies.Keys)
                    {
                        httpContext.Response.Cookies.Delete(cookie);
                    }
                    context.Fail();
                }
            }
            catch (Exception)
            {
                context.Fail();
                return(Task.CompletedTask);
            }

            return(Task.FromResult(0));
        }
        public async Task <Response> TienePermiso([FromBody] PermisoUsuario permiso)
        {
            try
            {
                var path = NormalizarPathContexto(permiso.Contexto);

                var token = await db.Adscpassw.Where(x => x.AdpsToken == permiso.Token && x.AdpsLogin.ToUpper() == permiso.Usuario.ToUpper()).FirstOrDefaultAsync();

                if (token != null)
                {
                    var grupos = await db.Adscmiem.Where(m => m.AdmiEmpleado.ToUpper() == permiso.Usuario.ToUpper()).ToListAsync();

                    foreach (var item in grupos)
                    {
                        var a = await db.Adscexe.Where(x => x.AdexGrupo == item.AdmiGrupo).ToListAsync();

                        foreach (var s in a)
                        {
                            var ds = await db.Adscmenu.Where(x => x.AdmeSistema == s.AdexSistema && x.AdmeAplicacion == s.AdexAplicacion).FirstOrDefaultAsync();

                            if (ds.AdmeControlador != null)
                            {
                                if (path.ToUpper().StartsWith(ds.AdmeControlador.ToUpper()))
                                {
                                    return(new Response {
                                        IsSuccess = true
                                    });
                                }
                            }
                        }
                    }
                }

                return(new Response {
                    IsSuccess = false
                });
            }
            catch (Exception)
            {
                throw;
            }
        }
Exemple #14
0
        public JsonResult GuardarPermisos(string id, IList <Usuario> usuarios)
        {
            var jsonResponse = new JsonResponse();

            try
            {
                var idFormulario    = Convert.ToInt32(id);
                var permisosUsuario = new List <PermisoUsuario>();

                foreach (var user in usuarios)
                {
                    foreach (var permiso in user.Permisos)
                    {
                        if (!permiso.Seleccionado)
                        {
                            continue;
                        }

                        var permisoRol = new PermisoUsuario
                        {
                            IdEmpleado    = user.IdEmpleado,
                            IdFormulario  = idFormulario,
                            IdTipoPermiso = permiso.IdTipoPermiso,
                        };

                        permisosUsuario.Add(permisoRol);
                    }
                }

                PermisoUsuarioBL.Instancia.Guardar(idFormulario, permisosUsuario);

                jsonResponse.Success = true;
                jsonResponse.Message = "Se Proceso con exito.";
            }
            catch (Exception ex)
            {
                jsonResponse.Message = ex.Message;
            }

            return(Json(jsonResponse, JsonRequestBehavior.AllowGet));
        }
        public async Task <Response> ExisteToken([FromBody] PermisoUsuario permiso)
        {
            try
            {
                var path = NormalizarPathContexto(permiso.Contexto);

                var token = await db.Adscpassw.Where(x => x.AdpsToken == permiso.Token && x.AdpsLogin.ToUpper() == permiso.Usuario.ToUpper()).FirstOrDefaultAsync();

                if (token != null)
                {
                    return(new Response {
                        IsSuccess = true
                    });
                }

                return(new Response {
                    IsSuccess = false
                });
            }
            catch (Exception)
            {
                throw;
            }
        }
Exemple #16
0
    protected void BtnSave_Click(object sender, EventArgs e)
    {
        panelError.Visible = false;

        try
        {
            int    id           = Convert.ToInt32(UsuarioID.Value);
            string nombre       = txtNombre.Text;
            string apellido     = txtApellido.Text;
            string email        = txtEmail.Text;
            string contraseña   = txtContraseña.Text;
            string tipoUsuario  = "admin";
            string estado       = "activo";
            string estadoActual = "off";

            Usuario obj = new Usuario()
            {
                Nombre       = nombre,
                Apellido     = apellido,
                Email        = email,
                Contraseña   = contraseña,
                TipoUsuario  = tipoUsuario,
                Estado       = estado,
                EstadoActual = estadoActual,
                UsuarioId    = id
            };

            string strId = Request.Params["Id"];

            //Insertar Nuevo Usuario
            if (string.IsNullOrEmpty(strId))
            {
                int userId = UsuarioBRL.insertarUsuario(obj);

                PermisoUsuario usuarioPermiso;
                Permiso        tempPerm;
                //Le inserto los permisos

                for (int i = 0; i < checkPermisos.Items.Count; i++)
                {
                    if (checkPermisos.Items[i].Selected)
                    {
                        tempPerm       = PermisoBRL.getPermisoByDescription(checkPermisos.Items[i].Text);
                        usuarioPermiso = new PermisoUsuario()
                        {
                            UsuarioId = userId,
                            PermisoId = tempPerm.PermisoID
                        };
                        UsuarioPermisoBRL.insertUsuarioPermiso(usuarioPermiso);
                    }
                }
            }
            //Actualizar Usuario
            else
            {
                string Id            = Request.Params["Id"];
                int    codigoUsuario = Int32.Parse(Id);
                UsuarioBRL.actualizarUsuario(nombre, apellido, codigoUsuario);

                //Actualizar Permisos
                Permiso perm1;
                Permiso perm2;
                for (int i = 0; i < checkPermisos.Items.Count; i++)
                {
                    if (checkPermisos.Items[i].Selected)
                    {
                        perm1 = PermisoBRL.getPermisoByDescription(checkPermisos.Items[i].Text);
                        if (!UsuarioPermisoBRL.tienePermiso(obj.UsuarioId, perm1.PermisoID))
                        {
                            //Agregar
                            PermisoUsuario admPerm = new PermisoUsuario()
                            {
                                UsuarioId = obj.UsuarioId,
                                PermisoId = perm1.PermisoID
                            };
                            UsuarioPermisoBRL.insertUsuarioPermiso(admPerm);
                        }
                    }
                    else
                    {
                        perm2 = PermisoBRL.getPermisoByDescription(checkPermisos.Items[i].Text);
                        if (UsuarioPermisoBRL.tienePermiso(obj.UsuarioId, perm2.PermisoID))
                        {
                            //Eliminar
                            UsuarioPermisoBRL.eliminarUsuarioPermisoByUsuarioIdPermisoId(obj.UsuarioId, perm2.PermisoID);
                        }
                    }
                }
            }
        }
        catch (Exception ex)
        {
            panelError.Visible = true;
            return;
        }
        Response.Redirect("~/Administrador/AdminLista.aspx");
    }
Exemple #17
0
        public void OnActionExecuting(ActionExecutingContext context)
        {
            try
            {
                /// <summary>
                /// Se obtiene el contexto de datos
                /// </summary>
                /// <returns></returns>
                /// con
                var httpContext = context.HttpContext;

                /// <summary>
                /// Se obtiene el path solicitado
                /// </summary>
                /// <returns></returns>
                var request = httpContext.Request;

                /// <summary>
                /// Se obtiene información del usuario autenticado
                /// </summary>
                /// <returns></returns>
                var claim         = context.HttpContext.User.Identities.Where(x => x.NameClaimType == ClaimTypes.Name).FirstOrDefault();
                var token         = claim.Claims.Where(c => c.Type == ClaimTypes.SerialNumber).FirstOrDefault().Value;
                var NombreUsuario = claim.Claims.Where(c => c.Type == ClaimTypes.Name).FirstOrDefault().Value;

                var permiso = new PermisoUsuario
                {
                    Contexto = request.Path,
                    Token    = token,
                    Usuario  = NombreUsuario
                };

                /// <summary>
                /// Se valida que la información del usuario actual tenga permiso para acceder al path solicitado...
                /// </summary>
                /// <returns></returns>
                var respuestaToken = apiServicio.ObtenerElementoAsync <Response>(permiso, new Uri(WebApp.BaseAddressSeguridad), "api/Adscpassws/ExisteToken");

                if (!respuestaToken.Result.IsSuccess)
                {
                    context.HttpContext.Authentication.SignOutAsync("Cookies");

                    foreach (var cookie in context.HttpContext.Request.Cookies.Keys)
                    {
                        context.HttpContext.Response.Cookies.Delete(cookie);
                    }

                    var result = new ViewResult {
                        ViewName = "SeccionCerrada"
                    };
                    context.Result = result;
                }
                else
                {
                    var respuesta = apiServicio.ObtenerElementoAsync <Response>(permiso, new Uri(WebApp.BaseAddressSeguridad), "api/Adscpassws/TienePermiso");
                    if (!respuesta.Result.IsSuccess)
                    {
                        var result = new ViewResult {
                            ViewName = "AccesoDenegado"
                        };
                        context.Result = result;
                    }
                    else
                    {
                        var claimTransfer = claimsTransfer.ObtenerClaimsTransferHttpContext();
                        if (claimTransfer == null || claimTransfer.IdSucursal == 0 || String.IsNullOrEmpty(claimTransfer.NombreSucursal))
                        {
                            var result = new ViewResult {
                                ViewName = "AccesoDenegadoEmpleadosClaims"
                            };
                            context.Result = result;
                        }
                    }
                }
            }
            catch (Exception)
            {
                var result = new RedirectResult(WebApp.BaseAddressWebAppLogin);
                context.Result = result;
            }
        }
        /// <summary>
        /// Método que es invocado desde la aplicaciín de Login
        /// Donde se valida el token temporal que el generado por la aplicación de Login para el usuario actual
        /// Si el token temporal es válido se elimina sino lo enviá a la aplicación de Login
        /// Si todo es satisfactorio se autentica a la cookie...
        /// </summary>
        /// <returns></returns>
        public async Task <IActionResult> Login()

        {
            try
            {
                var claim         = HttpContext.User.Identities.Where(x => x.NameClaimType == ClaimTypes.Name).FirstOrDefault();
                var token         = claim.Claims.Where(c => c.Type == ClaimTypes.SerialNumber).FirstOrDefault().Value;
                var NombreUsuario = claim.Claims.Where(c => c.Type == ClaimTypes.Name).FirstOrDefault().Value;

                var permiso = new PermisoUsuario
                {
                    Contexto = HttpContext.Request.Path,
                    Token    = token,
                    Usuario  = NombreUsuario,
                };

                /// <summary>
                /// Se valida que la información del usuario actual tenga permiso para acceder al path solicitado...
                /// </summary>
                /// <returns></returns>
                var respuesta = apiServicio.ObtenerElementoAsync1 <Response>(permiso, new Uri(WebApp.BaseAddress), "api/Adscpassws/TienePermiso");

                if (!respuesta.Result.IsSuccess)
                {
                    return(Redirect(WebApp.BaseAddressWebAppLogin));
                }

                if (Request.Query.Count != 2)
                {
                    return(Redirect(WebApp.BaseAddressWebAppLogin));
                }

                Adscpassw adscpassw    = new Adscpassw();
                var       queryStrings = Request.Query;
                var       qsList       = new List <string>();
                foreach (var key in queryStrings.Keys)
                {
                    qsList.Add(queryStrings[key]);
                }
                var adscpasswSend = new Adscpassw
                {
                    AdpsLogin     = qsList[0],
                    AdpsTokenTemp = qsList[1]
                };
                adscpassw = await GetAdscPassws(adscpasswSend);

                if (adscpassw != null)
                {
                    var response = await EliminarTokenTemp(adscpassw);

                    if (response.IsSuccess)
                    {
                        var responseLog = new EntradaLog
                        {
                            ExceptionTrace       = null,
                            LogCategoryParametre = Convert.ToString(LogCategoryParameter.Permission),
                            LogLevelShortName    = Convert.ToString(LogLevelParameter.INFO),
                            ObjectPrevious       = null,
                            ObjectNext           = JsonConvert.SerializeObject(response.Resultado),
                        };
                        await apiServicio.SalvarLog <entidades.Utils.Response>(HttpContext, responseLog);

                        return(RedirectToActionPermanent(nameof(HomeController.Index), "Home"));
                    }
                    else
                    {
                        return(Redirect(WebApp.BaseAddressWebAppLogin));
                    }
                }

                return(Redirect(WebApp.BaseAddressWebAppLogin));
            }
            catch (Exception ex)
            {
                var responseLog = new EntradaLog
                {
                    ExceptionTrace       = ex.Message,
                    LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
                    LogLevelShortName    = Convert.ToString(LogLevelParameter.ERR),
                    ObjectPrevious       = null,
                    ObjectNext           = null,
                };
                await apiServicio.SalvarLog <entidades.Utils.Response>(HttpContext, responseLog);

                return(Redirect(WebApp.BaseAddressWebAppLogin));
            }
        }
        public async Task <IActionResult> Login(Login login, string returnUrl = null)
        {
            if (!ModelState.IsValid)
            {
                return(RedirectToAction(nameof(LoginController.Index)));
            }

            var response = await apiServicio.ObtenerElementoAsync1 <Response>(login,
                                                                              new Uri(WebApp.BaseAddressSeguridad),
                                                                              "api/Adscpassws/Login");

            UsuarioBloqueado(response, login);

            if (!response.IsSuccess)
            {
                return(this.Redireccionar("Login", "Index", $"{Mensaje.Aviso}|{response.Message}|{TiempoMensaje.Tiempo1}"));
            }

            // var usuario = JsonConvert.DeserializeObject<Adscpassw>(response.Resultado.ToString());

            var codificar = new Codificar
            {
                Entrada = Convert.ToString(DateTime.Now),
            };

            Guid guidUsuario;

            guidUsuario = Guid.NewGuid();

            var permisoUsuario = new PermisoUsuario
            {
                Usuario = login.Usuario,
                Token   = Convert.ToString(guidUsuario)
            };
            var salvarToken = await apiServicio.InsertarAsync <Response>(permisoUsuario, new Uri(WebApp.BaseAddressSeguridad), "api/Adscpassws/SalvarToken");

            var dependenciaDatosViewModel = await apiServicio.ObtenerElementoAsync1 <DependenciaDatosViewModel>(new IdFiltrosViewModel { NombreUsuario = login.Usuario }, new Uri(WebApp.BaseAddressTH), "api/Dependencias/ObtenerDependenciaDatosViewModelPorUsuarioActual");

            var empleado = await apiServicio.ObtenerElementoAsync1 <Empleado>(login.Usuario, new Uri(WebApp.BaseAddressTH), "api/Empleados/EmpleadoSegunNombreUsuario");

            var listadoAdscmiems = (await apiServicio.Listar <Adscmiem>(new Uri(WebApp.BaseAddressSeguridad), "api/Adscmiems/ListarAdscmiem")).Where(c => c.AdmiEmpleado == login.Usuario);

            var claims = new List <Claim>
            {
                new Claim(ClaimTypes.Name, login.Usuario),
                new Claim(ClaimTypes.SerialNumber, Convert.ToString(guidUsuario))
            };

            if (dependenciaDatosViewModel != null)
            {
                if (dependenciaDatosViewModel.IdSucursal > 0)
                {
                    claims.Add(new Claim("IdSucursal", dependenciaDatosViewModel.IdSucursal.ToString()));
                }

                if (!String.IsNullOrEmpty(dependenciaDatosViewModel.NombreSucursal))
                {
                    claims.Add(new Claim("NombreSucursal", dependenciaDatosViewModel.NombreSucursal));
                }

                if (dependenciaDatosViewModel.IdDependencia > 0)
                {
                    claims.Add(new Claim("IdDependencia", dependenciaDatosViewModel.IdDependencia.ToString()));
                }

                if (!String.IsNullOrEmpty(dependenciaDatosViewModel.NombreDependencia))
                {
                    claims.Add(new Claim("NombreDependencia", dependenciaDatosViewModel.NombreDependencia));
                }
            }

            if (empleado != null)
            {
                if (empleado.IdEmpleado > 0)
                {
                    claims.Add(new Claim("IdEmpleado", empleado.IdEmpleado.ToString()));
                }

                if (empleado.Persona != null)
                {
                    claims.Add(new Claim("NombreEmpleado", $"{empleado.Persona.Nombres} {empleado.Persona.Apellidos}"));
                }
            }

            foreach (var item in listadoAdscmiems)
            {
                claims.Add(new Claim("ADMI_Grupo", item.AdmiGrupo));
            }

            var principal = new ClaimsPrincipal(new ClaimsIdentity(claims, "Cookies"));
            await HttpContext.Authentication.SignInAsync("Cookies", principal, new Microsoft.AspNetCore.Http.Authentication.AuthenticationProperties {
                IsPersistent = true
            });

            if (string.IsNullOrEmpty(returnUrl))
            {
                return(this.Redireccionar("Homes", "Menu", $"{Mensaje.Informacion}|{login.Usuario}:{Mensaje.Bienvenido}|{TiempoMensaje.Tiempo1}"));
            }

            return(LocalRedirect(returnUrl));
        }
Exemple #20
0
        public void OnActionExecuting(ActionExecutingContext context)
        {
            try
            {
                /// <summary>
                /// Se obtiene el contexto de datos
                /// </summary>
                /// <returns></returns>
                /// con
                var httpContext = context.HttpContext;

                /// <summary>
                /// Se obtiene el path solicitado
                /// </summary>
                /// <returns></returns>
                var request = httpContext.Request;


                /// <summary>
                /// Se obtiene información del usuario autenticado
                /// </summary>
                /// <returns></returns>
                var claim         = context.HttpContext.User.Identities.Where(x => x.NameClaimType == ClaimTypes.Name).FirstOrDefault();
                var token         = claim.Claims.Where(c => c.Type == ClaimTypes.SerialNumber).FirstOrDefault().Value;
                var NombreUsuario = claim.Claims.Where(c => c.Type == ClaimTypes.Name).FirstOrDefault().Value;

                var permiso = new PermisoUsuario
                {
                    Contexto = request.Path,
                    Token    = token,
                    Usuario  = NombreUsuario,
                };

                if (request.Path == "/")
                {
                    var result = new RedirectResult(WebApp.BaseAddressWebAppLogin);
                }
                else
                {
                    ApiServicio a = new ApiServicio();
                    var         respuestaToken = a.ObtenerElementoAsync1 <Response>(permiso, new Uri(WebApp.BaseAddressSeguridad), "api/Adscpassws/ExisteToken");

                    if (!respuestaToken.Result.IsSuccess)
                    {
                        var result = new ViewResult {
                            ViewName = "SeccionCerrada"
                        };
                        context.Result = result;
                    }
                    else
                    {
                        var respuesta = a.ObtenerElementoAsync1 <Response>(permiso, new Uri(WebApp.BaseAddressSeguridad), "api/Adscpassws/TienePermiso");

                        //respuesta.Result.IsSuccess = true;
                        if (!respuesta.Result.IsSuccess)
                        {
                            var result = new ViewResult {
                                ViewName = "AccesoDenegado"
                            };
                            context.Result = result;
                        }
                    }
                }

                /// <summary>
                /// Se valida que la información del usuario actual tenga permiso para acceder al path solicitado...
                /// </summary>
                /// <returns></returns>
            }
            catch (Exception ex)
            {
                //RedirectToActionResult a = new RedirectToActionResult("Index","Login","");
                //context.Result = a;

                var result = new RedirectResult(WebApp.BaseAddressWebAppLogin);

                context.Result = result;
            }
        }