Beispiel #1
0
        public async Task <IActionResult> Crear([FromBody] UsuarioModulo item)
        {
            try
            {
                var r = await this.Repositorio.UsuarioModulos.AddAsync(item);

                await this.Repositorio.CompleteAsync();

                var obj = new
                {
                    ok            = true,
                    UsuarioModulo = r
                };

                return(Created("", obj));
            }
            catch (Exception ex)
            {
                return(BadRequest(new
                {
                    ok = false,
                    mensaje = "Se produjo un error al crear la UsuarioModulo",
                    errors = new { mensaje = ex.Message }
                }));
            }
        }
Beispiel #2
0
        public async Task <IActionResult> Eliminar([FromBody] UsuarioModulo itemN)
        {
            //buscar la UsuarioModulo
            var itemEncontrado = await this.Repositorio.UsuarioModulos.FindAsync(x => x.UsuarioId == itemN.UsuarioId && x.ModuloId == itemN.ModuloId);

            if (itemEncontrado == null)
            {
                return(BadRequest(new { ok = false, mensaje = $"No se encontró el UsuarioModulo con Id {itemN.ModuloId}", erros = "" }));
            }

            // borrado fisico

            this.Repositorio.UsuarioModulos.RemoveRange(itemEncontrado);

            await this.Repositorio.CompleteAsync();

            var obj = new
            {
                ok            = true,
                mensaje       = $"Se Borró el UsuarioModulo {itemN.ModuloId}, correctamente",
                UsuarioModulo = itemEncontrado
            };

            return(Ok(obj));
        }
Beispiel #3
0
        public async Task <IActionResult> Eliminar([FromBody] UsuarioRole itemN)
        {
            //buscar la UsuarioRole
            var itemEncontrado = await this.Repositorio.UsuarioRoles.FindAsync(x => x.UsuarioId == itemN.UsuarioId && x.RoleId == itemN.RoleId);

            if (itemEncontrado == null)
            {
                return(BadRequest(new { ok = false, mensaje = $"No se encontró el UsuarioRole con Id {itemN.RoleId}", erros = "" }));
            }

            // borrado fisico

            this.Repositorio.UsuarioRoles.RemoveRange(itemEncontrado);
            await this.Repositorio.CompleteAsync();


            #region REMUEVE MODULOS DEFAULT

            //Asignar los modulos default del role
            var listaModulos = await this.Repositorio.RoleModulosDefault.FindAsync(x => x.RoleId == itemN.RoleId);

            if (listaModulos.Any())
            {
                var arrayMod = listaModulos.FirstOrDefault().Modulos.Split(',');

                if (arrayMod.Length > 0)
                {
                    List <UsuarioModulo> listaUM = new List <UsuarioModulo>();
                    foreach (var key in arrayMod)
                    {
                        UsuarioModulo itum = new UsuarioModulo()
                        {
                            UsuarioId = itemN.UsuarioId,
                            ModuloId  = Int32.Parse(key)
                        };
                    }

                    if (listaUM.Any())
                    {
                        this.Repositorio.UsuarioModulos.RemoveRange(listaUM);
                        await this.Repositorio.CompleteAsync();
                    }
                }
            }
            #endregion



            var obj = new
            {
                ok          = true,
                mensaje     = $"Se Borró el UsuarioRole {itemN.RoleId}, correctamente",
                UsuarioRole = itemEncontrado
            };

            return(Ok(obj));
        }
        public virtual UsuarioModulo GetFromReader(IDataReader reader)
        {
            UsuarioModulo um = new UsuarioModulo();

            um.Usuario = new Usuario()
            {
                Id = int.Parse(reader["IdUsuario"].ToString())
            };
            um.Modulo = (Modulo)int.Parse(reader["NuModulo"].ToString());
            return(um);
        }
Beispiel #5
0
 public override bool Insertar(UsuarioModulo usuarioModulo)
 {
     using (SqlConnection cn = new SqlConnection(this.ConnectionString))
     {
         SqlCommand cmd = new SqlCommand("pa_Insertar_UsuarioModulo", cn);
         cmd.CommandType = CommandType.StoredProcedure;
         cmd.Parameters.Add("@IdUsuario", SqlDbType.Int).Value = usuarioModulo.Usuario.Id;
         cmd.Parameters.Add("@NuModulo", SqlDbType.Int).Value  = usuarioModulo.Modulo;
         cn.Open();
         int ret = ExecuteNonQuery(cmd);
         return(ret > 0);
     }
 }
Beispiel #6
0
 public override UsuarioModulo ObtenerPorId(UsuarioModulo usuarioModulo)
 {
     using (SqlConnection cn = new SqlConnection(this.ConnectionString))
     {
         SqlCommand cmd = new SqlCommand("pa_ObtenerPorId_UsuarioModulo", cn);
         cmd.CommandType = CommandType.StoredProcedure;
         cmd.Parameters.Add("@IdUsuario", SqlDbType.Int).Value = usuarioModulo.Usuario.Id;
         cmd.Parameters.Add("@NuModulo", SqlDbType.Int).Value  = usuarioModulo.Modulo;
         cn.Open();
         IDataReader reader = ExecuteReader(cmd, CommandBehavior.SingleRow);
         if (reader.Read())
         {
             return(GetFromReader(reader));
         }
         return(null);
     }
 }
        public async Task <bool> ValidateModulePermissions(IGetHelper getHelper, Guid moduloId, eTipoPermiso tipoPermiso)
        {
            permisosModulo = new UsuarioModulo()
            {
                ModuloID         = moduloId,
                PermisoEscritura = false,
                PermisoImprimir  = false,
                PermisoLectura   = false
            };

            if (token.Administrador == "SA" || token.Administrador == "GA")
            {
                permisosModulo.PermisoEscritura = true;
                permisosModulo.PermisoImprimir  = true;
                permisosModulo.PermisoLectura   = true;
                return(true);
            }

            if (token.UsuariosModulos.Contains(moduloId))
            {
                return(true);
            }

            var permisos = await getHelper.GetUsuarioModuloByUsuarioAndModuloIDAsync(token.UsuarioID, moduloId);

            if (permisos == null)
            {
                TempData["toast"] = "No tiene privilegios en el módulo";
                return(false);
            }

            permisosModulo = permisos;

            switch (tipoPermiso)
            {
            case eTipoPermiso.PermisoLectura:
                if (!permisos.PermisoLectura)
                {
                    TempData["toast"] = "No tiene privilegios de acceso al módulo";
                    return(false);
                }
                break;

            case eTipoPermiso.PermisoEscritura:
                if (!permisos.PermisoLectura || !permisos.PermisoEscritura)
                {
                    TempData["toast"] = "No tiene privilegios de escritura en el módulo";
                    return(false);
                }
                break;

            case eTipoPermiso.PermisoImprimir:
                if (!permisos.PermisoLectura || !permisos.PermisoImprimir)
                {
                    TempData["toast"] = "No tiene privilegios de imprimir en el módulo";
                    return(false);
                }
                break;
            }

            return(true);
        }
Beispiel #8
0
        public async Task <IActionResult> Crear([FromBody] UsuarioRole item)
        {
            try
            {
                var r = await this.Repositorio.UsuarioRoles.AddAsync(item);

                await this.Repositorio.CompleteAsync();

                #region ASIGNAR MODULOS DEFAULT


                //Asignar los modulos default del role
                var listaModulos = await this.Repositorio.RoleModulosDefault.FindAsync(x => x.RoleId == item.RoleId);

                if (listaModulos.Any())
                {
                    var arrayMod = listaModulos.FirstOrDefault().Modulos.Split(',');

                    if (arrayMod.Length > 0)
                    {
                        List <UsuarioModulo> listaUM = new List <UsuarioModulo>();
                        foreach (var key in arrayMod)
                        {
                            UsuarioModulo itum = new UsuarioModulo()
                            {
                                UsuarioId = item.UsuarioId,
                                ModuloId  = Int32.Parse(key)
                            };

                            listaUM.Add(itum);
                        }

                        if (listaUM.Any())
                        {
                            await this.Repositorio.UsuarioModulos.AddRangeAsync(listaUM);

                            await this.Repositorio.CompleteAsync();
                        }
                    }
                }

                #endregion


                var obj = new
                {
                    ok          = true,
                    UsuarioRole = r
                };

                return(Created("", obj));
            }
            catch (Exception ex)
            {
                return(BadRequest(new
                {
                    ok = false,
                    mensaje = "Se produjo un error al crear la UsuarioRole",
                    errors = new { mensaje = ex.Message }
                }));
            }
        }
 public abstract bool Insertar(UsuarioModulo usuarioModulo);
 public abstract UsuarioModulo ObtenerPorId(UsuarioModulo usuarioModulo);