示例#1
0
        public async Task <RolDTO> Create(RolDTO dto, UsuarioDTO userLogged)
        {
            var rol = _mapper.Map <Rol>(dto);

            rol.Active         = true;
            rol.CreationDate   = DateTime.Now;
            rol.UpdateDate     = DateTime.Now;
            rol.CreationUserId = userLogged.Id;
            rol.UpdateUserId   = userLogged.Id;
            rol.IdEmpresa      = userLogged.IdEmpresa;
            rol = await _rolRepository.Insert(rol);

            foreach (var item in dto.Permisos)
            {
                PermisoRol entity = new PermisoRol
                {
                    RolId          = rol.Id,
                    PermisoId      = (int)item,
                    Active         = true,
                    CreationDate   = DateTime.Now,
                    UpdateDate     = DateTime.Now,
                    CreationUserId = userLogged.Id,
                    UpdateUserId   = userLogged.Id
                };
                await _permisoRolRepository.Insert(entity);
            }

            var rolDTO        = _mapper.Map <RolDTO>(rol);
            var permisosRoles = await _permisoRolRepository.ListBy(s => s.RolId == rol.Id);

            rolDTO.Permisos = permisosRoles.Select(s => s.Id).ToArray();
            return(rolDTO);
        }
示例#2
0
        public static String TipoPermiso(PermisoRol permisorol)
        {
            Permiso per     = permisorol.Permiso;
            String  permiso = "Acciones permitidas: ";

            if (per.Crear && per.Editar && per.Eliminar && per.Mostrar)
            {
                return("Autorizado");
            }
            if (!per.Crear && !per.Editar && !per.Eliminar && !per.Mostrar)
            {
                return("No Autorizado");
            }
            if (per.Crear)
            {
                permiso += "Crear ";
            }
            if (per.Editar)
            {
                permiso += "Editar ";
            }
            if (per.Mostrar)
            {
                permiso += "Mostrar ";
            }
            if (per.Eliminar)
            {
                permiso += "Eliminar ";
            }
            return(permiso.Trim());
        }
示例#3
0
        private static PermisoRol ConvertToPermisoRolViewModel(this PermisoRolViewModel permisoRolViewModel)
        {
            var permisoRol = new PermisoRol()
            {
                PermisoId = permisoRolViewModel.PermisoId,
                RolId     = permisoRolViewModel.RolId
            };

            return(permisoRol);
        }
示例#4
0
 public PermisoRol Add(PermisoRol entity)
 {
     try
     {
         return(repository.Add(entity));
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
        public ActionResult detalle(RolPermiso rolpermiso)
        {
            PermisoRol permisoRol = new PermisoRol();
            permisoRol.id_rol = rolpermiso.id_rol;
            permisoRol.id_permiso = rolpermiso.id_permiso;

            _db.PermisoRol.Add(permisoRol);
            _db.SaveChanges();

            return RedirectToAction("Detalle", new { id = rolpermiso.id_rol });

        }
示例#6
0
        private static PermisoRolViewModel ConvertToUsuarioPermisoToViewModel(this PermisoRol permisoRol)
        {
            var permisoRolViewModel = new PermisoRolViewModel()
            {
                ContienePermiso = true,
                PermisoId       = permisoRol.PermisoId,
                PermisoNombre   = permisoRol.Permiso.Nombre,
                RolId           = permisoRol.RolId
            };

            return(permisoRolViewModel);
        }
示例#7
0
 public JsonResult Update(string permisos, int id)
 {
     try
     {
         List <AsigPermiso> list         = new JavaScriptSerializer().Deserialize <List <AsigPermiso> >(permisos);
         List <PermisoRol>  listpermisos = new List <PermisoRol>();
         list.ForEach(p => { PermisoRol per = p.PermisoRol; per.Id_Rol = id; listpermisos.Add(per); });
         db.PermisoRol.RemoveRange(db.PermisoRol.Where(p => p.Id_Rol == id).ToList());
         db.PermisoRol.AddRange(listpermisos);
         db.SaveChanges();
         return(Json("/Rols/Index", JsonRequestBehavior.AllowGet));
     }
     catch
     {
         return(Json("/Rols/Index", JsonRequestBehavior.AllowGet));
     }
 }
示例#8
0
        public JsonResult GuardarPermisos(string id, IList <Rol> roles)
        {
            var jsonResponse = new JsonResponse();

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

                foreach (var rol in roles)
                {
                    foreach (var permiso in rol.Permisos)
                    {
                        if (!permiso.Seleccionado)
                        {
                            continue;
                        }

                        var permisoRol = new PermisoRol
                        {
                            IdRol               = rol.IdRol,
                            IdFormulario        = idFormulario,
                            IdTipoPermiso       = permiso.IdTipoPermiso,
                            FechaCreacion       = FechaCreacion,
                            FechaModificacion   = FechaModificacion,
                            UsuarioCreacion     = UsuarioActual.IdEmpleado,
                            UsuarioModificacion = UsuarioActual.IdEmpleado
                        };

                        permisosRol.Add(permisoRol);
                    }
                }

                PermisoRolBL.Instancia.Guardar(idFormulario, permisosRol);

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

            return(Json(jsonResponse, JsonRequestBehavior.AllowGet));
        }
 public ActionResult PermisosParaRol(Guid id, IList <Guid> idsAcciones, List <Guid> permitidos)
 {
     try
     {
         var rol           = _rolesRepository.ObtenerPorId(id);
         var seleccionados = permitidos ?? new List <Guid>();
         foreach (var idAccion in idsAcciones)
         {
             var seleccionado = seleccionados.Contains(idAccion);
             var permiso      = _permisosRolRepository.ObtenerPorAccionRol(idAccion, id);
             if (permiso == null)
             {
                 permiso = new PermisoRol()
                 {
                     IdAccion  = idAccion,
                     IdRol     = id,
                     Permitido = seleccionado
                 };
                 _permisosRolRepository.Guardar(permiso);
                 _auditorRepository.GuardarRegistroCreacion(permiso);
             }
             else
             {
                 permiso.Permitido = seleccionado;
                 _permisosRolRepository.Actualizar(permiso);
             }
         }
         TempData["Message"] = "El rol " + rol.Nombre + " ha sido actualizado correctamente";
         return(RedirectToAction("Index", "Rol"));
     }
     catch (Exception ex)
     {
         TempData["ErrorMessage"] = "Ha ocurrido un error:<br/>" + ex.Message;
         var rol      = _rolesRepository.ObtenerPorId(id);
         var acciones = _accionesRepository.ObtenerTodos();
         TempData["AccionesDisponibles"] = acciones.Where(x => !x.EsEtapa).OrderBy(x => x.NombreAccion).ToList();
         var accioneEnRol = rol.PermisosRol.Where(a => a.Permitido == true).Select(a => a.Accion);
         TempData["AccionesEnRol"] = accioneEnRol.ToList();
         Utilidades.ColocarMensaje(ex.Message, ErrorType.Error, Request);
         return(View(rol));
     }
 }
示例#10
0
        public async Task <ActionResult> Create([Bind(Include = "Nombre")] Rol rol)
        {
            if (AccountController.Account.GetUser == null)
            {
                return(RedirectPermanent("Login/Index"));
            }
            if (ModelState.IsValid)
            {
                db.Rol.Add(rol);
                await db.SaveChangesAsync();

                List <PermisoRol> listpermisos = new List <PermisoRol>();
                Permisos().ForEach(p => { PermisoRol per = p.PermisoRol; per.Id_Rol = rol.Id; listpermisos.Add(per); });
                db.PermisoRol.AddRange(listpermisos);
                await db.SaveChangesAsync();

                ViewBag.Permisos = Permisos();
                ViewBag.Id       = rol.Id;
                return(View("CreatePermiso"));
            }

            return(View(rol));
        }
示例#11
0
        public async Task <RolDTO> Update(int id, RolDTO dto, UsuarioDTO userLogged)
        {
            Rol entity    = _mapper.Map <Rol>(dto);
            var oldentity = await _rolRepository.GetById(id);

            entity.UpdateDate     = DateTime.Now;
            entity.CreationDate   = oldentity.CreationDate;
            entity.UpdateUserId   = userLogged.Id;
            entity.CreationUserId = userLogged.Id;
            entity = await _rolRepository.Update(id, entity);

            var dtos = _mapper.Map <RolDTO>(entity);

            var permisosRolesAntiguos = await _permisoRolRepository.ListBy(s => s.RolId == id);

            foreach (var item in permisosRolesAntiguos)
            {
                await _permisoRolRepository.Remove(item.Id);
            }

            foreach (var item in dto.Permisos)
            {
                PermisoRol permisoRol = new PermisoRol
                {
                    RolId          = id,
                    PermisoId      = (int)item,
                    Active         = true,
                    CreationDate   = DateTime.Now,
                    UpdateDate     = DateTime.Now,
                    CreationUserId = userLogged.Id,
                    UpdateUserId   = userLogged.Id
                };
                await _permisoRolRepository.Insert(permisoRol);
            }

            return(dtos);
        }
示例#12
0
 public bool Insert(PermisoRol roles)
 {
     return(crud.Insert(roles));
 }
示例#13
0
 public void Delete(PermisoRol entity)
 {
     _permisoRolRepository.Delete(entity);
 }
 public void Actualizar(PermisoRol permisoRol)
 {
     _db.PermisosRol.ApplyCurrentValues(permisoRol);
     _db.SaveChanges();
 }
 public void Eliminar(PermisoRol permisoRol)
 {
     _db.PermisosRol.DeleteObject(permisoRol);
     _db.SaveChanges();
 }
 public void Guardar(PermisoRol permisoRol)
 {
     _db.PermisosRol.AddObject(permisoRol);
     _db.SaveChanges();
 }