Como criar páginas com visualizações de permissions diferentes

Eu preciso criar diferentes visualizações de página para diferentes tipos de usuários. Eu já pedi isso aqui: Como criar páginas com visualizações de permissions diferentes

E mesmo que a resposta de Aldeel funcione, não parece a melhor solução para mim. Eu explicarei porque.

Vou tentar explicar o que preciso muito detalhado e espero que alguns de vocês possam me ajudar: D

Eu preciso mostrar visões diferentes, mas não é apenas assim. Cada usuário pode ter access a diferentes partes da página.

Vou dar um exemplo:

Imagine uma página ‘X’ com essa estrutura

Field A Field B Field C Field D 

Quando o usuário U1 do grupo G1 visita a página X o sistema verifica o database para a permissão desse grupo na página X O usuário U1 pode ver o Field A e o Field B , mas somente editar o Field A

Usuário U2 definido para nenhuma página de visitas de grupo X O sistema verifica suas permissions na página X O usuário U2 pode ver e editar todos os campos.

Quando o usuário U3 do grupo G2 visitar a página X o sistema verifica o database para a permissão desse grupo na página X O usuário U3 pode ver o Field C e o Field D , mas não pode editar nenhum.

Espero que seja fácil de entender …

Eu não poderia encontrar uma maneira de fazer isso em vez de preencher ViewData com muitos dados sobre a permissão desse usuário específico. No meu exemplo, existem apenas 4 campos, mas no meu projeto atual não tenho canvas com menos de 20 campos. Então eu acho que você pode ver como isso é feio e não produtivo.

A ideia é semelhante a uma rede social, como eu disse ( exemplo do facebook ). Quando um usuário visitando a página do UserX só consegue ver o que o UserX lhe permitiu.

Eu realmente aprecio qualquer ajuda.

Cumprimentos.

    Para fazer o que você está procurando fazer, você não deve controlar seus pontos de vista – você realmente tem que proteger seus controladores – não os pontos de vista. Você pode fazer isso via atributos do controlador. Algo semelhante a isto:

     [Authorize] public class MyController { } 

    Ao fazer isso, você protege todo o controlador. Cada ação dentro desse controlador não responderá se o usuário não for autenticado (especificamente, ele receberá uma resposta 401). Você pode estender isso autorizando usuários individuais ou funções individuais, conforme mostrado nos exemplos abaixo:

     [Authorize(Users="eestein,JasCav") public class MyController { } [Authorize(Roles="Administrator")] public class MyController { } 

    No seu caso, você pode não querer ter um controlador inteiro com autorização nele. Bem, excelente o suficiente, a ASP.NET MVC oferece controle de autenticação no nível de ação. Então você pode fazer isso:

     public class MyController { public ActionResult Index() { } [Authorize(Roles="Administrator")] public ActionResult Admin() { } } 

    Usando essa ideia, é aqui que você pode controlar o que um usuário vê em uma página. Você desejará retornar páginas parciais de suas ações para poder carregar vários aspectos da página. Por exemplo, você pode ter uma exibição que mostre alguns dados normais e alguns dados secretos. Os dados normais podem ser retornados através da página normal. Os dados secretos devem ser retornados como uma visão parcial dentro da página. No entanto, se ocorrer um 401, você pode manipulá-lo e simplesmente não mostrar nada.

    É bastante simples de fazer. A equipe do .NET fez um ótimo trabalho ao configurar isso e você não precisa verificar individualmente as permissions em seu controlador. Espero que isso ajude você a começar. Faça uma pesquisa online para obter mais informações sobre como usar o atributo Authorization.

    Atualização No caso em que você tem um administrador de uma página que está controlando essas permissions, é necessário ser esperto sobre como configurar seu atributo Autorizar. Este é o lugar onde “Funções” são muito importantes (por meus exemplos acima). Por exemplo, se o administrador disser “Eu adicionarei John Doe a uma function SpecialUser”, o usuário John Doe poderá acessar todas as ações nas quais a function está definida como SpecialUser (se isso for de fato um papel no seu sistema).

    Obviamente, você terá que dar aos administradores uma maneira de fazer isso, e o atributo Authorize faz isso perfeitamente. Para ver quem tem permissions em uma página, você terá que consultar o database para descobrir quem faz parte de qual function. Aqui está uma maneira de pensar sobre a configuração:

    • Você controla os papéis das ações.
    • Seus administradores controlam quem recebe essas funções.
    • Você sempre pode verificar (por meio de uma consulta simples) para ver quem está designado para qual function. Você pode então (através de seu conhecimento das funções de ações) ver quem vê qual parte do site.

    Espero que isso esclareça (e espero ter entendido bem o seu problema). Eu acho que o que você está tentando fazer é possível.

    Atualização 2 Sim, isso supõe que você tenha grupos estáticos em seus controladores e que qualquer novo grupo teria que ser programaticamente adicionado. Eu ficaria curioso em saber que tipo de caso de uso requer tipos diferentes de permissions para criar na hora – isso parece estar aberto a abusos. De qualquer forma, não tenho uma solução para isso.

    Quanto à forma como as vistas parciais funcionam … é algo como isto …

     public class ProductController : Controller { // // GET: /Index/ public ActionResult Index() { return View(); } public ActionResult Partial1() { return PartialView(); } [Authorize] public ActionResult Partial2() { return PartialView(); } } 

    Dentro do seu arquivo Index.aspx, você terá algo parecido com isto:

     < %= Html.RenderAction("Partial1") %> < %= Html.RenderAction("Partial2") %> 

    Se o usuário não estiver autorizado, você pode manipular a segunda RenderAction para que a exibição nunca seja exibida. (Você pode verificar isso dentro do seu controlador.)

    Espero que esclarece as coisas! Estou fugindo, então não posso expandir mais agora.

    Eu recomendaria segurança “aditiva”; As permissions de um usuário, e de qualquer um de seus Grupos, summ-se para dar uma série de coisas que ele pode fazer. Se ele não tiver permissão explícita para fazer algo para o qual é necessária permissão, ele não tem permissão para fazê-lo. No seu caso, entre o Usuário U1 e o Grupo G1, há permissions suficientes concedidas para o usuário ver o Campo A e o Campo B e editar o Campo A. Como o usuário, seja ele próprio ou por meio de seu grupo, não recebeu permissão explícita para editar o campo B ou para exibir ou editar campos C e D, ele não tem essas permissions.

    Eu implementaria esse tipo de permissão colocando um método no codebehind que aceitaria um object representando o usuário e suas permissions, e interrogaria essas permissions para determinar a visibilidade dos campos. Todos os campos devem começar invisíveis e esse método os tornará visíveis e / ou editáveis.

    Coisas a ter em conta:

    • Verifique se você está usando as ferramentas do lado do servidor .NET para mostrar / ocultar campos. Se a propriedade Visible de um campo estiver definida como false no lado do servidor, a página renderizada nem includeá esse campo no HTML. Por outro lado, adicionar um estilo ou usar JavaScript para ocultar propriedades as mantém no DOM e no HTML, portanto, uma pessoa pode “visualizar a origem” para observar os campos ocultos dessa maneira.
    • NUNCA use o código do lado do cliente para implementar a segurança. JavaScript, controles ActiveX, etc. podem ser recusados, desativados e / ou manipulados. O código do lado do cliente para mostrar dados também requer que os dados morem em algum lugar na origem da página, o que significa que podem ser encontrados facilmente visualizando a origem da página.
    • Da mesma forma, não confie que um campo não editável não terá seus dados alterados. HTML, e código do lado do cliente, podem ser alterados facilmente com ferramentas como o FireBug.
    • Seu código será mais seguro se você começar com tudo invisível / desativado e torná-los visíveis / ativados, do que se você começar com access totalmente aberto e ocultar as coisas. Se você esquecer de esconder algo novo, de repente os clientes veem um novo campo em que não devem tocar. Se você esquecer de adicionar um código para mostrar um novo campo com base nas permissions, ainda precisará corrigi-lo, mas é muito mais difícil ou impossível explorar um campo que não existe.