Autorizzazione complicata basata su criteri dinamici

Question

Autorizzazione complicata basata su criteri dinamici

#1 da (1 voti)
#2 da (0 voti)
#3 da (0 voti)

2

Mi dispiace per non aver pubblicato alcun codice. Sono bloccato nella fase di progettazione, ecco perché -

Quello che voglio realizzare è: consentire agli amministratori di sistema di un "Sistema di compiti dello staff" di impostare dinamicamente i diritti su un determinato utente / reparto a un'azione specifica in fase di esecuzione.

I diritti sono complicati. Ad esempio: possono limitare l'assegnazione delle attività ai dipendenti, se l'utente è il manager dell'utente che riceve l'assegnazione. Anche questo manager può visualizzare le attività solo se nello stesso dipartimento e nella stessa posizione. A volte un'attività può richiedere più di una persona da approvare e non solo è necessario autorizzare questi specifici utenti in modo dinamico, ma anche contrassegnare l'attività come approvata dopo che questi specifici utenti hanno approvato l'attività.

Quanto sopra è solo per darti un'idea di cosa sto cercando di implementare. Sto cercando un consiglio sul modello di progettazione / struttura / direzione per iniziare a implementare qualcosa come sopra.

Sono sicuro che il ruolo non è la risposta giusta. Ho iniziato a esplorare l'autorizzazione basata sulle attestazioni da .NET Identity ma non ho visto molti esempi o tutorial su di esso.

c# design-patterns asp.net-mvc authorization

posta e7na online 21.11.2016 - 10:31

fonte

3 risposte

Leggi altre domande sui tag c# design-patterns asp.net-mvc authorization

layout dinamico; viewBag vs render azioni Microservice di notifica aggregata

score 1 · Answer 1

La cosa complicata in te è che il permesso si basa anche sul contenuto dei dati della tabella. (cioè if within same department and same location )

Ho visto un sistema di autorizzazione ogni gruppo di utenti ha sql specifico per la tabella, in cui verrà aggiunto ogni query sql.

Esempio:

ruolo: reparto-a-manager; filtro: (indirizzo zipcode: 45xxx), (store departmen: a)

questo significa che quando un "dipartimento-a-manager" seleziona i dati dalla tabella del databse dell'indirizzo, la logica di dadabase aggiunge and zipcode like '45%' a sql-where.

Un altro aproble sarebbe quello di creare una vista del database specifica del ruolo che abbia lo sql all'interno.

Esempio

il databaseview adress-department-a-manager è definito come select * from adress where zipcode like '45%'

score 0 · Answer 2

La descrizione del problema esclude fondamentalmente i ruoli semplici e i calcoli basati sulle rivendicazioni. Le affermazioni sono fondamentalmente una serie di fatti sul tuo utente che sono statici. Puoi fare molte cose divertenti con questo, ma non puoi facilmente aggiungere e rimuovere le richieste in fase di runtime.

Probabilmente dovrai estendere AuthorizeAttribute per abilitare l'autorizzazione dinamica.

L'attributo ha un metodo di callback che implementeresti per fare le tue ricerche e applicare le regole. Un esempio molto approssimativo sarebbe come questo:

public class AuthorizeStaffTaskAttribute : AuthorizeAttribute
{
    public string Something { get; set; }

    protected override bool Authorize(HttpContextBase context)
    {
        MyCustomUser user = context.User as MyCustomUser;
        return user != null && user.CanDo(Something);
    }
}

Il fatto è che le dichiarazioni di attributi richiedono che le tue espressioni siano costanti. Puoi usare un enum, una stringa magica, ecc. Nulla che viene calcolato. Ovviamente puoi dichiarare il tuo Something come espressione di Linq e valutarlo nel callback Authorize() .

Questo può iniziare almeno.

score 0 · Answer 3

Le espressioni Lambda ti danno quella "al volo" che combina il potere che vuoi! Sono state implementate soluzioni del genere, con sicurezza relazionale sulle raccolte di contenuti. Definisci i gruppi di sicurezza e le autorizzazioni utilizzando i criteri LINQ e quindi filtra le raccolte in base a queste regole di sicurezza come:

public IQueryable<TContent> Filter<TContent>(
    IQueryable<TContent> content, 
    string permission, TUser user) {
      var predicate = BuildPredicate<TContent>(permission, user);
      return content.Where(predicate);
}

Il concetto principale alla base di questo approccio consiste nell'utilizzare i generici per la definizione delle "regole di sicurezza" e le espressioni lambda per creare i predicati in modo dinamico.

public static Predicate<T> Or<T>(params Predicate<T>[] predicates)
{
    return delegate (T item)
    {
        foreach (Predicate<T> predicate in predicates)
        {
            if (predicate(item))
            {
                return true;
            }
        }
        return false;
    };
}

public static Predicate<T> And<T>(params Predicate<T>[] predicates)
{
    return delegate (T item)
    {
        foreach (Predicate<T> predicate in predicates)
        {
            if (!predicate(item))
            {
                return false;
            }
        }
        return true;
}

La grande implementazione di tale approccio potrebbe essere trovare qui