public JsonResult Create(Menu entidad)
{
try
{
entidad.SistemaId = _application.GetCurrentSistema().Id;
_menuService.Guardar(entidad);
var menuVista = new
{
entidad.Id,
entidad.Codigo,
entidad.Nombre,
entidad.Descripcion,
Items = getItems(entidad.Items)
};
var result = new JsonResult
{
Data = menuVista,
JsonRequestBehavior = JsonRequestBehavior.AllowGet
};
return(result);
}
catch (Exception ex)
{
var result = ManejadorExcepciones.HandleException(ex);
return(StatusResponseHelper.JsonErrorServidor(result.Message, true));
}
}
public JsonResult Edit(Menu entidad)
{
try
{
var menu = _menuService.Get(entidad.Id);
menu.Codigo = entidad.Codigo;
menu.Nombre = entidad.Nombre;
menu.Descripcion = entidad.Descripcion;
//Actualizados
var actualizados = menu.Items.Where(c => entidad.Items.Any(d => c.Id == d.Id));
foreach (var actualizado in actualizados)
{
var elemento = entidad.Items.FirstOrDefault(i => i.Id == actualizado.Id);
if (elemento != null)
{
actualizado.Nombre = elemento.Nombre;
actualizado.Codigo = elemento.Codigo;
actualizado.Descripcion = elemento.Descripcion;
actualizado.EstadoId = elemento.EstadoId;
actualizado.FuncionalidadId = elemento.FuncionalidadId;
actualizado.Icono = elemento.Icono;
actualizado.Orden = elemento.Orden;
actualizado.PadreCodigo = elemento.PadreCodigo;
actualizado.TipoId = elemento.TipoId;
actualizado.Url = elemento.Url;
}
}
//Nuevos
var nuevos = entidad.Items.Where(c => c.Id == 0);
foreach (var nuevo in nuevos)
{
menu.Items.Add(nuevo);
}
//Eliminados
var eliminados = menu.Items.Where(c => entidad.Items.All(d => c.Id != d.Id)).ToList();
_menuService.EliminarItems(eliminados);
_menuService.Guardar(menu);
var catalogoVista = new
{
menu.Id,
menu.Codigo,
menu.Nombre,
menu.Descripcion,
Items = getItems(menu.Items)
};
return(Json(catalogoVista, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
var result = ManejadorExcepciones.HandleException(ex);
return(StatusResponseHelper.JsonErrorServidor(result.Message, true));
}
}
//[ValidateAntiForgeryToken]
public JsonResult Create(Catalogo catalogo)
{
try
{
catalogo.SistemaId = _application.GetCurrentSistema().Id;
foreach (var item in catalogo.Items)
{
item.CodigoCatalogo = catalogo.Codigo;
item.Estado = true;
}
_catalogoService.Guardar(catalogo, new List <ItemCatalogo>());
var catalogoVista = new
{
catalogo.Id,
catalogo.Codigo,
catalogo.Nombre,
catalogo.Descripcion,
catalogo.FechaCreacion,
Items = getItems(catalogo.Items)
};
var result = new JsonResult
{
Data = catalogoVista,
JsonRequestBehavior = JsonRequestBehavior.AllowGet
};
return(result);
}
catch (Exception ex)
{
var result = ManejadorExcepciones.HandleException(ex);
return(StatusResponseHelper.JsonErrorServidor(result.Message, true));
}
}
public JsonResult DeleteConfirmed(int id)
{
try
{
_menuService.Eliminar(id);
return(Json(true, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
var result = ManejadorExcepciones.HandleException(ex);
return(StatusResponseHelper.JsonErrorServidor(result.Message, true));
}
}
// GET: Catalogo/Delete/5
public JsonResult Delete(int?id)
{
if (id == null)
{
return(StatusResponseHelper.JsonIdNulo());
}
Catalogo entidad = _catalogoService.Get(id.Value);
if (entidad == null)
{
return(StatusResponseHelper.JsonNoExiste(id.Value));
}
return(Json(entidad, JsonRequestBehavior.AllowGet));
}
public JsonResult SeleccionarRol(SeleccionarRolViewModel seleccionarRolViewModel)
{
var tokenHeader = seleccionarRolViewModel.Token;
var claveEncriptar = Base64.Encode(AppSettings.Get <string>(ConstantesWebConfig.CLAVE_ENCRYPTACION));
var tokenResult = Token.DecodeToken(claveEncriptar, tokenHeader);
if (!tokenResult.Validated)
{
var mensaje = string.Empty;
if (tokenResult.Errors[0].Equals(TokenValidationStatus.Expired))
{
mensaje = string.Format("Su sesion ha expirado.");
}
else
{
if (tokenResult.Errors[0].Equals(TokenValidationStatus.WrongToken))
{
mensaje = string.Format("El valor de token es invalido.");
}
}
var result = StatusResponseHelper.JsonNoAutenticado(mensaje, false);
return(result);
}
if (tokenResult.UserId != 0 && !string.IsNullOrWhiteSpace(seleccionarRolViewModel.RolCodigo))
{
//Verificar q la cuenta no este asignada a otro usuario
Usuario usuario = _repository.Get(tokenResult.UserId);
if (usuario != null)
{
var result = AutentificarUsuario(usuario, null, seleccionarRolViewModel.RolCodigo);
return(result);
}
}
return(StatusResponseHelper.JsonNoAutenticado("El usuario o el Rol seleccionado no esta asociado", false));
}
public JsonResult Details(Menu entidad)
{
if (entidad.Id == 0)
{
return(StatusResponseHelper.JsonIdNulo());
}
Menu catalogo = _menuService.Get(entidad.Id);
if (catalogo == null)
{
return(StatusResponseHelper.JsonNoExiste(entidad.Id));
}
var menuVista = new
{
catalogo.Id,
catalogo.Codigo,
catalogo.Nombre,
catalogo.Descripcion,
Items = getItems(catalogo.Items)
};
return(Json(menuVista, JsonRequestBehavior.AllowGet));
}
public JsonResult Details(Catalogo catalogoEntrada)
{
if (catalogoEntrada.Id == 0)
{
return(StatusResponseHelper.JsonIdNulo());
}
Catalogo catalogo = _catalogoService.Get(catalogoEntrada.Id);
if (catalogo == null)
{
return(StatusResponseHelper.JsonNoExiste(catalogoEntrada.Id));
}
var catalogoVista = new
{
catalogo.Id,
catalogo.Codigo,
catalogo.Nombre,
catalogo.Descripcion,
catalogo.FechaCreacion,
Items = getItems(catalogo.Items)
};
return(Json(catalogoVista, JsonRequestBehavior.AllowGet));
}
public void OnAuthentication(AuthenticationContext filterContext)
{
if (filterContext == null)
{
throw new ArgumentNullException("AuthenticationTokenAttribute");
}
//1. Saltar autorizacion, si el controlador o la accion tiene el atributo AllowAnonymousAttribute
bool isAllowAnonymousAttribute =
filterContext.ActionDescriptor.IsDefined(typeof(AllowAnonymousAttribute), inherit: true) ||
filterContext.ActionDescriptor.ControllerDescriptor.IsDefined(
typeof(AllowAnonymousAttribute), inherit: true);
if (isAllowAnonymousAttribute)
{
return;
}
string tokenHeader = filterContext.HttpContext.Request.Headers["token"];
if (tokenHeader == null || tokenHeader.IsEmpty())
{
var error = string.Format("No Autorizado no se encontro un token.");
var result = StatusResponseHelper.JsonNoAutenticado(error, false);
filterContext.Result = result;
return;
}
var claveEncriptar = Base64.Encode(AppSettings.Get <string>(ConstantesWebConfig.CLAVE_ENCRYPTACION));
var tokenResult = Token.DecodeToken(claveEncriptar, tokenHeader);
if (!tokenResult.Validated)
{
var mensaje = string.Empty;
if (tokenResult.Errors[0].Equals(TokenValidationStatus.Expired))
{
mensaje = string.Format("Su sesion ha expirado.");
}
else
{
if (tokenResult.Errors[0].Equals(TokenValidationStatus.WrongToken))
{
mensaje = string.Format("El valor de token es invalido.");
}
}
var result = StatusResponseHelper.JsonNoAutenticado(mensaje, false);
filterContext.Result = result;
return;
}
var _application = ServiceLocator.Current.GetInstance <IApplication>();
var _repository = ServiceLocator.Current.GetInstance <IUsuarioRepository <Usuario> >();
Usuario usuario = _repository.Get(tokenResult.UserId);
//Para indicar que no se ha seleccionado un rol
if (tokenResult.RolId == -1)
{
var _rolesUsuario = usuario.Roles;
var modelRol = new SeleccionarRolViewModel();
foreach (var item in _rolesUsuario)
{
var rolView = new RolViewModel()
{
CodigoRol = item.Codigo, NombreRol = item.Nombre
};
modelRol.Roles.Add(rolView);
}
var usuarioView = new
{
usuId = usuario.Id,
version = usuario.VersionRegistro,
usuNombres = usuario.Nombres,
usuApellidos = usuario.Apellidos,
usuIdentificacion = usuario.PersonaId,
usuDireccion = "",
usuUsuario = usuario.Cuenta,
usuClave = "",
usuCorreo = usuario.Correo,
usuEstado = usuario.Estado
};
var result = StatusResponseHelper.JsonNoSeleccionadoRol("No se ha seleccionado un rol.", modelRol, usuarioView, tokenHeader);
filterContext.Result = result;
return;
}
var _rolService = ServiceLocator.Current.GetInstance <IRolService>();
Rol rol = _rolService.Get(tokenResult.RolId);
var _repositorySesion = ServiceLocator.Current.GetInstance <IRepository <Sesion> >();
var sesion = _repositorySesion.Get(tokenResult.SesionId);
if (usuario == null)
{
var result = StatusResponseHelper.JsonNoAutenticado("No existe usuario para el valor de token", false);
filterContext.Result = result;
return;
}
if (rol == null)
{
var result = StatusResponseHelper.JsonNoAutenticado("No existe rol para el valor de token", false);
filterContext.Result = result;
return;
}
if (sesion == null)
{
var result = StatusResponseHelper.JsonNoAutenticado("No existe sesion para el valor de token", false);
filterContext.Result = result;
return;
}
//Establecer objetos de acceso
_application.SetCurrentUser(usuario);
_application.SetCurrentRol(rol);
_application.SetCurrentSession(sesion);
//TODO: JOR - Generar nuevo token con actualizacion de tiempo de creacion para la expiracion de sesiones
var minutosExpiracionToken = Convert.ToInt32(AppSettings.Get <string>(ConstantesWebConfig.TOKEN_TIEMPOSESION));
var token = Token.GenerateToken(claveEncriptar, usuario.Id, rol.Id, tokenResult.SesionId, minutosExpiracionToken);
//JOR:Token actualizado para nuevas peticiones
filterContext.HttpContext.Response.AppendHeader("token", token);
//base.OnActionExecuting(filterContext);
}
/// <summary>
/// Autentificar usuario
/// </summary>
/// <param name="usuario"></param>
/// <param name="ipClient"></param>
/// <param name="codigoRol"></param>
/// <returns></returns>
private JsonResult AutentificarUsuario(Usuario usuario, string ipClient, string codigoRol)
{
try
{
//TODO. JSA. Revisar el flujo si al momento de seleccionar un rol, este es externo, Por lo tanto no lo va tener asociado
//al usuario. (Fallas Seguridad)
//opcion 1. Sincrionizar rol_usuario, (externoas y internos)
//opcion 2. Pasar informacion en el model de la vista tipo (externo y interno), si es un rol externo pasar si verificacion o
//recuperar de una sesion los roles externos del usuario
JsonResult result;
Rol rol = _rolService.GetList().Where(c => c.Codigo == codigoRol).FirstOrDefault();
if (rol == null)
{
string error = string.Format("No existe el rol con el codigo {0}", codigoRol);
result = StatusResponseHelper.JsonNoAutenticado(error, false);
return(result);
}
if (!rol.EsExterno)
{
rol = usuario.Roles.Where(c => c.Codigo == codigoRol).SingleOrDefault();
if (rol == null)
{
string error = string.Format("El usuario {0}, no tiene asociado el rol con el codigo {1}", usuario.Cuenta, codigoRol);
result = StatusResponseHelper.JsonNoAutenticado(error, false);
return(result);
}
}
//Autentificar usuario
//Obtener la direccion IP del cliente
string ipAddress = ipClient;
if (string.IsNullOrWhiteSpace(ipAddress))
{
ipAddress = RequestHelpers.GetClientIpAddress(this.HttpContext.Request);
}
var claveEncriptar = AppSettings.Get <string>(ConstantesWebConfig.CLAVE_ENCRYPTACION);
var minutosExpiracionToken = Convert.ToInt32(AppSettings.Get <string>(ConstantesWebConfig.TOKEN_TIEMPOSESION));
InitializeUserAccessServiciosWeb initializeUserAccessServiciosWeb = new InitializeUserAccessServiciosWeb();
initializeUserAccessServiciosWeb.usuario = usuario;
initializeUserAccessServiciosWeb.rol = rol;
initializeUserAccessServiciosWeb.ipAddress = ipAddress;
_accessService.InitializeUserAccess(initializeUserAccessServiciosWeb);
var sesion = _application.GetCurrentSession();
var token = Token.GenerateToken(Base64.Encode(claveEncriptar), usuario.Id, rol.Id, sesion.Id, minutosExpiracionToken);
//FormsAuthentication.SetAuthCookie(usuario.Cuenta, false);
var mensaje =
string.Format("El usuario {0}, ingresa de forma exitosa al sistema", usuario);
//Registro Auditoria - Hora de inicio de sesión en el sistema.
logAuditoria.Write(FUNCIONALIDAD_GESTION_USUARIOS.ACCION_LOGIN, mensaje);
//Direccionar a la URL segun la configuración del ROL, o direccionar a URL Default
//string URL = FormsAuthentication.DefaultUrl;
//if (!string.IsNullOrWhiteSpace(rol.Url))
//{
// URL = rol.Url;
//}
/*var miFarmacia = _iFarmaciaService.GetMisFarmacias().Select(mf => mf.Farmacia).FirstOrDefault();
* String fileBase64 = miFarmacia == null || miFarmacia.Logo == null
|| (!rol.Codigo.Equals(ConstantesRoles.ROL_FARMACEUTICO_PROPIETARIO) && !rol.Codigo.Equals(ConstantesRoles.ROL_FARMACEUTICO2)) ?
|| null : DataUrl.FromFileTypeAndBytes(miFarmacia.FileTypeLogo, miFarmacia.Logo);*/
var rolView = new { codigoRol = rol.Codigo, rolNombre = rol.Nombre, rolEsadministrador = rol.EsAdministrador };
var usuarioView = new
{
usuId = usuario.Id,
version = usuario.VersionRegistro,
usuNombres = usuario.Nombres,
usuApellidos = usuario.Apellidos,
usuIdentificacion = usuario.PersonaId,
usuDireccion = "",
usuUsuario = usuario.Cuenta,
usuClave = "",
usuCorreo = usuario.Correo,
usuEstado = usuario.Estado,
//ImagenPerfil = fileBase64
};
result = new JsonResult
{
Data = new
{
mensaje,
rol = rolView,
usuario = usuarioView,
miToken = token,
autenticado = true
},
//ContentType = contentType,
//ContentEncoding = contentEncoding,
JsonRequestBehavior = JsonRequestBehavior.AllowGet
};
return(result);
}
catch (Exception ex)
{
var result = ManejadorExcepciones.HandleException(ex);
//TODO: DEPENDENCIAS DE REINICIAR. MEJOR GUARDAR EN SESSION LA IDENTIDAD
FormsAuthentication.SignOut();
Session.Clear();
var result1 = StatusResponseHelper.JsonErrorServidor(result.Message, true);
return(result1);
}
}
public JsonResult Ingresar(LoginViewModel model)
{
if (model.Usuario != null && !model.Usuario.IsEmpty() && model.Password != null && !model.Password.IsEmpty())
{
//1. Autentificacion contra Membership
var proveedorMembresia = Membership.Provider;
model.Usuario = model.Usuario.Trim();
MembershipUser user = Membership.GetUser(model.Usuario);
if (user == null)
{
Log.DebugFormat("No existe el usuario [{0}]", model.Usuario);
var error = "Usuario ó Clave incorrecta";
var result = StatusResponseHelper.JsonNoAutenticado(error, true);
return(result);
}
if (!user.IsApproved)
{
var error = string.Format("El usuario [{0}], se encuentra pendiente de activación, revice su correo o contáctese con soporte.", model.Usuario);
var result = StatusResponseHelper.JsonNoAutenticado(error, true);
return(result);
}
//1.1. Usuario Bloqueado
//if (user.IsLockedOut)
//{
// var mensaje =
// string.Format("El usuario " + model.Usuario + ", se encuentra bloqueado");
// logAuditoria.Write(FUNCIONALIDAD_GESTION_USUARIOS.ACCION_LOGIN, mensaje);
// ModelState.AddModelError("", string.Format("El usuario [{0}], se encuentra bloqueado", model.Usuario));
// return IntentarIngreso(model);
//}
//TODO: Personalizar mensajes de AD
//try
//{
// var server = ConfigurationManager.AppSettings["Udla.CarpetaLinea.Url.ActiveDirectory"];
// var entry = new DirectoryEntry(server, model.Usuario, model.Password);
// var nativeObject = entry.NativeObject;
//}
//catch (DirectoryServicesCOMException cex)
//{
// //TODO: Capturar por codigos de excepciones.
// if (cex.ExtendedErrorMessage.Contains("532"))
// {
// var mensaje =
// string.Format("La contraseña del usuario " + model.Usuario + ", se encuentra expirada");
// logAuditoria.Write(FUNCIONALIDAD_GESTION_USUARIOS.ACCION_LOGIN, mensaje);
// ModelState.AddModelError("", string.Format("La contraseña del usuario [{0}] está expirada. Por favor utilice la opción 'Cambiar contraseña'", model.Usuario));
// ViewBag.ShowLink = false;
// return IntentarIngreso(model);
// }
// else if (cex.ExtendedErrorMessage.Contains("773"))
// {
// var mensaje =
// string.Format("El usuario " + model.Usuario + ", debe cambiar la contraseña");
// logAuditoria.Write(FUNCIONALIDAD_GESTION_USUARIOS.ACCION_LOGIN, mensaje);
// ModelState.AddModelError("", string.Format("El usuario [{0}] debe cambiar la contraseña", model.Usuario));
// return IntentarIngreso(model);
// }
// else if (cex.ExtendedErrorMessage.Contains("775"))
// {
// //TODO JLA: Personalizar mensaje contra tiempo de duracion de bloqueo
// var minutes = getLockoutDuration(model.Usuario);
// var mensaje =
// string.Format("El usuario " + model.Usuario + ", se encuentra bloqueado");
// logAuditoria.Write(FUNCIONALIDAD_GESTION_USUARIOS.ACCION_LOGIN, mensaje);
// ModelState.AddModelError("", string.Format("El usuario [{0}] se encuentra bloqueado. Por favor intentarlo en [{1}] minutos", model.Usuario, minutes));
// return IntentarIngreso(model);
// }
//}
var membresia = proveedorMembresia.ValidateUser(model.Usuario, model.Password);
if (membresia)
{
Usuario usuario = _repository.Get(model.Usuario);
if (usuario.PersonaId.HasValue)
{
var persona = _repositoryPersona.Get((int)usuario.PersonaId);
usuario.Nombres = persona.PrimerNombre + " " + persona.SegundoNombre;
usuario.Apellidos = persona.PrimerApellido + " " + persona.SegundoApellido;
usuario.Identificacion = persona.Identificacion;
usuario.Correo = persona.Correo;
}
else
{
usuario.Nombres = "Anonimo";
usuario.Apellidos = string.Empty;
usuario.Identificacion = string.Empty;
usuario.Correo = string.Empty;
}
if (usuario == null)
{
//var sincronizar_usuario_externo = _parametroService.GetValor<bool>(CodigosParametros.PARAMETRO_SEGURIDAD_SINCRONIZAR_USUARIOS_EXTERNOS);
//if (sincronizar_usuario_externo)
//{
// usuario = SincronizarUsuarioExterno(model.Usuario, infoExternal, rolesInternosExternos);
//}
//else
//{
var error = string.Format("No existe el usuario [{0}]", model.Usuario);
var result = StatusResponseHelper.JsonNoAutenticado(error, false);
return(result);
//}
}
var modelRol = new SeleccionarRolViewModel();
modelRol.UsuarioId = usuario.Id;
modelRol.NombreUsuario = usuario.ToString();
modelRol.IPClient = model.IPClient;
//Unir Roles asociados al usuario
var _rolesUsuario = usuario.Roles;
foreach (var item in _rolesUsuario)
{
var rolView = new RolViewModel()
{
CodigoRol = item.Codigo, NombreRol = item.Nombre
};
modelRol.Roles.Add(rolView);
}
if (modelRol.Roles.Count == 1)
{
var mensaje =
string.Format("El usuario {0}, ingresa por defecto con el codigo de rol {1}", usuario, modelRol.Roles.FirstOrDefault().NombreRol);
//Registro Auditoria - Hora de inicio de sesión en el sistema.
logAuditoria.Write(FUNCIONALIDAD_GESTION_USUARIOS.ACCION_LOGIN, mensaje);
//Si unicamente existe un rol autentificar
return(AutentificarUsuario(usuario, null, modelRol.Roles.FirstOrDefault().CodigoRol));
}
else if (modelRol.Roles.Count > 1)
{
modelRol.Roles = modelRol.Roles.OrderBy(c => c.NombreRol).ToList();
var usuarioView = new
{
usuId = usuario.Id,
version = usuario.VersionRegistro,
usuNombres = usuario.Nombres,
usuApellidos = usuario.Apellidos,
usuIdentificacion = usuario.PersonaId,
usuDireccion = "",
usuUsuario = usuario.Cuenta,
usuClave = "",
usuCorreo = usuario.Correo,
usuEstado = usuario.Estado
};
var claveEncriptar = AppSettings.Get <string>(ConstantesWebConfig.CLAVE_ENCRYPTACION);
var minutosExpiracionToken = Convert.ToInt32(AppSettings.Get <string>(ConstantesWebConfig.TOKEN_TIEMPOSESION));
//Se fija -1 al rol y sesion actual mientras el usuario elije un rol
var token = Token.GenerateToken(Base64.Encode(claveEncriptar), usuario.Id, -1, -1, minutosExpiracionToken);
var roles = (from x in modelRol.Roles
let label = x.NombreRol
let value = x.CodigoRol
orderby x.NombreRol
select new { label, value });
var result = new JsonResult
{
Data = new
{
roles,
usuario = usuarioView,
miToken = token,
autenticado = true
},
//ContentType = contentType,
//ContentEncoding = contentEncoding,
JsonRequestBehavior = JsonRequestBehavior.AllowGet
};
return(result);
}
else if (modelRol.Roles.Count == 0)
{
string error = string.Format("Usuario {0}, no posee roles establecidos para ingresar al sistema", model.Usuario);
var mensaje =
string.Format("El usuario {0}, no posee roles establecidos para ingresar al sistema", usuario);
//Registro Auditoria - Hora de inicio de sesión en el sistema.
logAuditoria.Write(FUNCIONALIDAD_GESTION_USUARIOS.ACCION_LOGIN, mensaje);
var result = StatusResponseHelper.JsonNoAutenticado(error, true);
return(result);
}
}
else
{
var mensaje =
string.Format("El usuario {0}, ha intentado realizar Loguin en el sistema, usuario no autenticado", model.Usuario);
//Registro Auditoria - Hora de intento de logueo en la aplicación.
logAuditoria.Write(FUNCIONALIDAD_GESTION_USUARIOS.ACCION_LOGIN, mensaje);
var result = StatusResponseHelper.JsonNoAutenticado("Usuario o contraseña incorrecto", true);
return(result);
}
}
var result1 = StatusResponseHelper.JsonNoAutenticado("Usuario o contraseña incorrecto", true);
return(result1);
}
public override void OnAuthorization(AuthorizationContext filterContext)
{
//1. SISTEMA
// 1.1 Funcionalidades
// 1.1.1 Acciones
// 1.2 Roles
// 1.2.1 Permisos => Acciones => Funcionalidades
// 1.3 Menus
// 1.3.1. Items Menu => Funcionalidad
//APLICAR AUTORIZACION BASADO EN EL NOMBRE DEL CONTROLADOR
//controller/accion/parametros
//{controller}/{action}/{id}
//Mapear los nombres de los controllers a los menus y estos a las funcionalidades
if (filterContext == null)
{
throw new ArgumentNullException("AuthorizeFilterAttribute");
}
//1. Saltar autorizacion, si el controlador o la accion tiene el atributo AllowAnonymousAttribute
bool isAllowAnonymousAttribute =
filterContext.ActionDescriptor.IsDefined(typeof(AllowAnonymousAttribute), inherit: true) ||
filterContext.ActionDescriptor.ControllerDescriptor.IsDefined(
typeof(AllowAnonymousAttribute), inherit: true);
if (isAllowAnonymousAttribute)
{
return;
}
//2. Saltar autorizacion.
//2.1 Controladores o acciones que no se debe verificar
//2.2 Atributos explicitos en los controladores que indica que no se debe verificar la autorizacion
if (SecurityControllerHelper.SkipControllerSecurity(filterContext.ActionDescriptor.ControllerDescriptor))
{
//log.InfoFormat("No aplicar autorización al controllador ", filterContext.ActionDescriptor.ControllerDescriptor.ControllerName);
return;
}
if (SecurityControllerHelper.SkipActionSecurity(filterContext.ActionDescriptor))
{
//log.InfoFormat("No aplicar autorización a la action {0} del controller {1}", filterContext.ActionDescriptor.ActionName, filterContext.ActionDescriptor.ControllerDescriptor.ControllerName);
return;
}
//Rol Administrador, tiene todos los permisos
var _application = ServiceLocator.Current.GetInstance <IApplication>();
var rol = _application.GetCurrentRol();
if (rol.EsAdministrador)
{
return;
}
//TODO: JSA, PARA MEJORAR RENDIMIENTO.. SE DEBE GUARDAR
// (Controller/Action => Funcionalidad/accion Asociada), puesto que verifica esta combinacion por cada peticion al sistema.
var servicioFuncionalidad = ServiceLocator.Current.GetInstance <IFuncionalidadService>();
var funcionalidadRelacionada = SecurityControllerHelper.ControllerToFunctionality(servicioFuncionalidad.GetFuncionalidades(),
filterContext.ActionDescriptor.ControllerDescriptor);
if (funcionalidadRelacionada == null)
{
var mensaje = string.Format("No existe funcionalidades asociadas al controlador {0}",
filterContext.ActionDescriptor.ControllerDescriptor.ControllerName);
filterContext.Result = StatusResponseHelper.JsonErrorServidor(mensaje, false);
}
else
{
var accion = SecurityControllerHelper.ActionControllerToActionFunctionality(funcionalidadRelacionada, filterContext.ActionDescriptor);
var servicio = ServiceLocator.Current.GetInstance <IAuthorizationService>();
if (!servicio.Authorize(accion))
{
filterContext.HttpContext.Response.StatusCode = (int)HttpStatusCode.Forbidden;
var mensaje = string.Format("Acceso restringido a la funcionalidad [{0}], en la acción de [{1}]",
funcionalidadRelacionada.Nombre, accion.Nombre);
filterContext.Result = StatusResponseHelper.JsonNoAutorizado(mensaje, true);
}
}
}
