public IActionResult Editar(RolViewModel rolVM)
{
if (ModelState.IsValid)
{
try
{
RolesRepository rolesRepository = new RolesRepository();
var rolResult = rolesRepository.GetRolByNombre(rolVM.Nombre.ToLower());
//Regex regex = new Regex(@"^[a-zA-ZñÑáéíóúÁÉÍÓÚ\s 0-9 ]+$");
Regex regex = new Regex(@"^[a-zA-ZñÑáéíóúÁÉÍÓÚ\s ]+$");
bool resultado = true;
resultado = regex.IsMatch(rolVM.Nombre);
if (!resultado)
{
ModelState.AddModelError("", "No se aceptan números y caracteres especiales en el rol (Solo: a-z, A-Z).");
return(View(rolVM));
}
Regex regexNoNumStart = new Regex(@"[0-9]| $");
bool resultadoNoNumStart = false;
string textoFirstChart = rolVM.Nombre.Substring(0, 1);
resultadoNoNumStart = regexNoNumStart.IsMatch(textoFirstChart);
if (resultadoNoNumStart)
{
ModelState.AddModelError("", "No se permite iniciar con NÚMERO o con ESPACIO.");
return(View(rolVM));
}
if (rolResult == null)
{
rolesRepository.UpdateRolVM(rolVM);
return(RedirectToAction("Rol", "Administrador"));
}
else if (rolResult.IdRol == rolVM.IdRol)
{
rolResult.Nombre = rolVM.Nombre;
rolesRepository.Update(rolResult);
return(RedirectToAction("Rol", "Administrador"));
}
else
{
ModelState.AddModelError("", "Ya existe este rol.");
return(View(rolVM));
}
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
return(View(rolVM));
}
}
else
{
return(View(rolVM));
}
}
public async Task <IActionResult> CrearRol(RolViewModel rolViewModel)
{
if (ModelState.IsValid)
{
IdentityRole rol = new IdentityRole
{
Name = rolViewModel.NombreRol
};
var result = await _roleManager.CreateAsync(rol);
if (result.Succeeded)
{
TempData["Accion"] = "CrearRol";
TempData["Mensaje"] = "Rol " + rol.Name + " creado";
return(RedirectToAction("ListarRoles", "Admin"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(rolViewModel));
}
public JsonResult GetRols()
{
List <Rol> list = new List <Rol>();
try
{
list = db.Rols.ToList();
List <RolViewModel> rolViewModels = new List <RolViewModel>();
foreach (var item in list)
{
RolViewModel rolViewModel = new RolViewModel
{
Descripcion = item.Descripcion,
IsAdmin = item.IsAdmin == true?"SI":"NO",
Nombre = item.Nombre,
Window = item.Window?.Descripcion,
RolId = item.RolId
};
rolViewModels.Add(rolViewModel);
}
return(Json(rolViewModels, JsonRequestBehavior.AllowGet));
}
catch (Exception)
{
throw;
}
}
public async Task <ActionResult> ObtenerRol(string id)
{
if (string.IsNullOrEmpty(id))
{
return(NotFound(new ApiResponseFormat()
{
Estado = StatusCodes.Status404NotFound, Mensaje = "Rol invalido"
}));
}
IdentityRole role = await _roleManager.FindByIdAsync(id);
List <Usuario> members = new List <Usuario>();
List <Usuario> nonMembers = new List <Usuario>();
foreach (Usuario user in _userManager.Users.ToList())
{
List <Usuario> list = await _userManager.IsInRoleAsync(user, role.Name) ? members : nonMembers;
list.Add(user);
}
var rolyusuarios = new RolViewModel {
Rol = role, Asignados = members, NoAsignados = nonMembers, Permisos = await _roleManager.GetClaimsAsync(role)
};
return(Ok(new ApiResponseFormat()
{
Estado = StatusCodes.Status200OK, Dato = rolyusuarios
}));
}
public IActionResult ObtenerRol(int id)
{
using (var db = new smafacpyaContext())
{
var valido = ValidarLogin();
if (valido != HttpStatusCode.OK)
{
if (valido == HttpStatusCode.Unauthorized)
{
return(Unauthorized(constantes.mensajes.sesionExpirada));
}
else
{
return(BadRequest(constantes.mensajes.error));
}
}
var rol = db.Rol.Include(x => x.RolModuloPantallaPermiso).FirstOrDefault(x => x.Id == id);
if (rol == null)
{
return(BadRequest(constantes.seguridad.mensajes.usuarioNoEncontrado));
}
var resultado = new RolViewModel
{
Id = rol.Id,
Nombre = rol.Nombre,
Descripcion = rol.Descripcion,
Activo = (bool)rol.Activo,
Menu = ObtenerMenuPorRol(rol.Id)
};
return(Ok(resultado));
}
}
public JsonResult ConsultaRoles(string [] data)
{
RolDALImpl rolDAL = new RolDALImpl();
Roles rol_temporal;
RolViewModel rolViewModel;
if (data != null)
{
int data1 = int.Parse(data[0]);
rol_temporal = rolDAL.GetRolById(data1);
rolViewModel = new RolViewModel
{
RoleId = rol_temporal.RoleId,
RoleName = rol_temporal.RoleName
};
return(Json(rolViewModel));
}
else
{
return(Json(String.Format("'Success':'false','Error':'Ha habido un error al mapear los datos.'")));
}
}
public Form_Permiso_Add(OnAddSuccessDelegate <RolViewModel> onAddSuccess)
{
InitializeComponent();
_OnAddSuccess = onAddSuccess;
_ViewModel = new RolViewModel();
LoadPermisos();
BindViewModel();
}
public ActionResult EditarRol(RolViewModel rol)
{
if (!ModelState.IsValid)
{
return(View(rol));
}
var rolExistente = _context.Roles.SingleOrDefault(r => r.Name == rol.OriginalRoleName);
ApplicationRole role = (ApplicationRole)rolExistente;
_context.Entry(role).Collection(r => r.Permisos).Load();
if (rolExistente == null)
{
return(HttpNotFound());
}
List <Permisos> permisos = new List <Permisos>();
foreach (var permiso in rol.Permisos)
{
if (permiso.Selected)
{
permisos.Add(new Permisos
{
Id = int.Parse(permiso.Value),
Descripcion = permiso.Text
});
}
}
var permisosAgregados = permisos.Where(p => !role.Permisos.Any(p2 => p2.Id == p.Id)).ToList();
var permisosEliminados = role.Permisos.Where(p => !permisos.Any(p2 => p2.Id == p.Id)).ToList();
foreach (var item in permisosAgregados)
{
if (_context.Entry(item).State == EntityState.Detached)
{
_context.Permisos.Attach(item);
}
role.Permisos.Add(item);
}
if (permisosEliminados.Count > 0)
{
permisosEliminados.ForEach(c => role.Permisos.Remove(c));
}
role.Name = rol.Name;
role.Descripcion = rol.Descripcion;
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public void InsertRolVM(RolViewModel rol_VM)
{
Rol rol = new Rol()
{
Nombre = rol_VM.Nombre
};
Insert(rol);
}
public void UpdateRolVM(RolViewModel rol_VM)
{
var rolResult = GetById(rol_VM.IdRol);
if (rolResult != null)
{
rolResult.Nombre = rol_VM.Nombre;
Update(rolResult);
}
}
// GET: roles/Details/5
public ActionResult Details(int id)
{
ROLES rolesEntity;
using (UnidadDeTrabajo <ROLES> Unidad = new UnidadDeTrabajo <ROLES>(new BDContext()))
{
rolesEntity = Unidad.genericDAL.Get(id);
}
RolViewModel roles = this.Convertir(rolesEntity);
return(View(roles));
}
public IActionResult Eliminar(RolViewModel rolVM)
{
RolesRepository rolesRepository = new RolesRepository();
var rolResult = rolesRepository.GetById(rolVM.IdRol);
if (rolResult != null)
{
rolesRepository.Delete(rolResult);
}
return(RedirectToAction("Rol", "Administrador"));
}
public ActionResult <RolViewModel> Get(int id)
{
var rol = rolService.Consultar(id);
if (rol == null)
{
return(NotFound());
}
var rolViewModel = new RolViewModel(rol);
return(rolViewModel);
}
public ActionResult EditarRol(string id)
{
if (id == "c2625e46-98d0-42ee-9aec-d38a408ee62c")
{
return(RedirectToAction("Index"));
}
var thisRole = _context.Roles
.Where(r => r.Id.Equals(id, StringComparison.CurrentCultureIgnoreCase))
.FirstOrDefault();
List <SelectListItem> listPermisos = new List <SelectListItem>();
var permisos = _context.Permisos.ToList();
var permisosRoles = _context.Permisos.Where(p => p.Roles.Any(r => r.Id == id)).ToList();
bool bandera = false;
if (thisRole == null)
{
return(RedirectToAction("Index"));
}
foreach (var item in permisos)
{
foreach (var permiso in permisosRoles)
{
if (item.Id == permiso.Id)
{
bandera = true;
listPermisos.Add(new SelectListItem
{
Value = permiso.Id.ToString(),
Text = permiso.Descripcion,
Selected = true
});
}
}
if (!bandera)
{
listPermisos.Add(new SelectListItem
{
Value = item.Id.ToString(),
Text = item.Descripcion,
Selected = false
});
}
bandera = false;
}
var viewModel = new RolViewModel((ApplicationRole)thisRole, listPermisos);
return(View(viewModel));
}
public ActionResult EditarRol(string id)
{
if (id == "4cc9d923-926d-428c-8f45-2bb6e4b215f0")
{
return(RedirectToAction("Index"));
}
var thisRole = _context.Roles
.Where(r => r.Id.Equals(id, StringComparison.CurrentCultureIgnoreCase))
.FirstOrDefault();
var viewModel = new RolViewModel(thisRole);
return(View(viewModel));
}
public async Task <ActionResult> NuevoRol(RolViewModel model)
{
if (ModelState.IsValid)
{
var result = await roleManager.CreateAsync(new IdentityRole(model.Name));
if (result.Succeeded)
{
return(RedirectToAction("IndexRoles", "Account"));
}
AddErrors(result);
}
return(View(model));
}
public Form_Rol_Edit(OnEditSuccessDelegate <RolViewModel> onEditSuccess, int idRol)
{
InitializeComponent();
_OnEditSuccess = onEditSuccess;
//obtengo el rol de la base y lo mapeo a un viewmodel
_ViewModel = new RolViewModel(RolDAO.GetByID(idRol));
//inicializo la lista de seleccionados con sus respectivos ids
_ViewModel.IdsPermisosSeleccionados = _ViewModel.Permisos.Select(p => p.IDPermiso).ToList();
//bindeo las propiedades del viewmodel a los controles
BindViewModel();
}
private async Task PersistAsync(RolViewModel value, bool isNew)
{
var role = new Role {
Name = value.Name, Active = value.Active
};
if (isNew)
{
await _roleRules.CreateAsync(role, value.Access);
}
else
{
await _roleRules.EditAsync(role, value.Access);
}
}
public ActionResult EditRol(string id)
{
var role = roleManager.FindById(id);
if (role == null)
{
ViewBag.ErrorMessage = "El rol no existe";
return(View());
}
var model = new RolViewModel
{
Id = role.Id,
Name = role.Name
};
return(View(model));
}
public ActionResult CrearRol()
{
var permisos = _context.Permisos.ToList().OrderBy(p => p.Id);
var viewModel = new RolViewModel();
viewModel.Permisos = new List <SelectListItem>();
foreach (var permiso in permisos)
{
viewModel.Permisos.Add(new SelectListItem
{
Text = permiso.Descripcion,
Value = permiso.Id.ToString()
});
}
return(View(viewModel));
}
public ActionResult EditarRol(RolViewModel rol)
{
if (!ModelState.IsValid)
{
return(View(rol));
}
var rolBD = _context.Roles.SingleOrDefault(r => r.Name == rol.OriginalRoleName);
if (rolBD == null)
{
return(HttpNotFound());
}
rolBD.Name = rol.Name;
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> CrearRol(RolViewModel rol)
{
RolDto _rol = new RolDto
{
Name = rol.Name
};
var rest = await _services.Create(_rol);
if (rest.Succesfull)
{
HttpJsonResModel <RolDto> res = JsonConvert.DeserializeObject <HttpJsonResModel <RolDto> >(rest.Body);
res.Objeto = _rol;
return(Ok(res));
}
return(BadRequest(rest));
}
public JsonResult GetAllRoles()
{
List <RolViewModel> Lista = new List <RolViewModel>();
RolViewModel rol;
List <BERol> oListaRol;
BLRol oBlRol = new BLRol();
oListaRol = oBlRol.ListarRol();
foreach (BERol item in oListaRol)
{
rol = new RolViewModel();
rol.codigo = item.cod_rol;
rol.descripcion = item.gls_rol;
rol.estado = item.cod_estado_registro;
Lista.Add(rol);
}
return(Json(Lista, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> CrearRol(RolViewModel roleViewModel)
{
if (ModelState.IsValid)
{
IdentityRole identityRole = new IdentityRole {
Name = roleViewModel.RoleName
};
IdentityResult result = await _roleManager.CreateAsync(identityRole);
if (result.Succeeded)
{
return(RedirectToAction("roles", "admin"));
}
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(roleViewModel));
}
public ActionResult CrearRol(RolViewModel rol)
{
if (!ModelState.IsValid)
{
return(View(rol));
}
var role = new ApplicationRole {
Name = rol.Name, Descripcion = rol.Descripcion
};
var idManager = new IdentityManager();
if (idManager.RoleExists(rol.Name))
{
return(View(rol));
}
List <Permisos> permisos = new List <Permisos>();
int id = 0;
foreach (var permiso in rol.Permisos)
{
if (permiso.Selected)
{
id = int.Parse(permiso.Value);
var context = _context.Permisos.Where(p => p.Id == id).SingleOrDefault();
permisos.Add(context);
}
}
try
{
role.Permisos = permisos;
_context.Roles.Add(role);
_context.SaveChanges();
}
catch (Exception ex) { }
return(RedirectToAction("Index"));
}
public async Task <IActionResult> CrearRol(RolViewModel rolViewModel)
{
if (ModelState.IsValid)
{
IdentityRole rol = new IdentityRole
{
Name = rolViewModel.NombreRol
};
var result = await _roleManager.CreateAsync(rol);
if (result.Succeeded)
{
return(RedirectToAction("ListarRoles"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(rolViewModel));
}
public async Task <ActionResult> EditRol(RolViewModel model)
{
var role = await roleManager.FindByIdAsync(model.Id);
if (role == null)
{
ViewBag.ErrorMessage = "El rol no existe";
return(View());
}
else
{
role.Name = model.Name;
var result = await roleManager.UpdateAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("IndexRoles", "Account"));
}
AddErrors(result);
}
return(View(model));
}
public async Task <IActionResult> CrearRol(RolViewModel model)
{
if (ModelState.IsValid)
{
IdentityRole rol = new IdentityRole
{
Name = model.NombreRol
};
var result = await _gestionRoles.CreateAsync(rol);
if (result.Succeeded)
{
return(RedirectToAction("ListarRoles", "Rol"));
}
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
return(View(model));
}
public ActionResult CrearRol(RolViewModel rol)
{
ViewBag.Message = "Nombre de rol ya existe!";
if (!ModelState.IsValid)
{
return(View(rol));
}
var role = new IdentityRole {
Name = rol.Name
};
var idManager = new IdentityManager();
if (idManager.RoleExists(rol.Name))
{
return(View(rol));
}
_context.Roles.Add(role);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
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);
}
