DISABILITARE ADBLOCK

ADBlock sta bloccando alcuni contenuti del sito

ADBlock errore
risultati trovati: 

DOMANDA

Incontro spesso il seguente scenario in cui devo offrire molti tipi diversi di autorizzazioni. Uso principalmente ASP.NET / VB.NET con SQL Server 2000.

Scenario

Voglio offrire un sistema di autorizzazione dinamico in grado di lavorare su parametri diversi. Diciamo che voglio dare a un dipartimento o solo una persona specifica l'accesso a un'applicazione. E fingiamo di avere un numero di applicazioni che continua a crescere.

In passato, ho scelto uno dei due modi seguenti che conosco per farlo.

  1. Utilizza una singola tabella di autorizzazioni con colonne speciali utilizzate determinare un come applicare i parametri. Le colonne speciali in questo esempio sono TypeID e TypeAuxID. L'SQL sembrerebbe qualcosa come questo.

    SELECT COUNT(PermissionID)
    FROM application_permissions
    WHERE
    (TypeID = 1 AND TypeAuxID = @UserID) OR
    (TypeID = 2 AND TypeAuxID = @DepartmentID)
    AND ApplicationID = 1
    
  2. Utilizza una tabella di mapping per ciascun tipo di autorizzazione, quindi uniscili tutti insieme.

    SELECT COUNT(perm.PermissionID)
    FROM application_permissions perm
    LEFT JOIN application_UserPermissions emp
    ON perm.ApplicationID = emp.ApplicationID
    LEFT JOIN application_DepartmentPermissions dept
    ON perm.ApplicationID = dept.ApplicationID
    WHERE q.SectionID=@SectionID
      AND (emp.UserID=@UserID OR dept.DeptID=@DeptID OR
     (emp.UserID IS NULL AND dept.DeptID IS NULL)) AND ApplicationID = 1
    ORDER BY q.QID ASC
    

I miei pensieri

Spero che gli esempi abbiano un senso. Li ho messi insieme.

Il primo esempio richiede meno lavoro, ma nessuno dei due sembra la risposta migliore. C'è un modo migliore per gestirlo?

SOLUZIONE

Sono d'accordo con John Downey.

Personalmente, a volte utilizzo un elenco contrassegnato di autorizzazioni. In questo modo è possibile utilizzare le operazioni bit per bit AND, OR, NOT e XOR sugli elementi dell'enumerazione.

"[Flags]
public enum Permission
{
    VIEWUSERS = 1, // 2^0 // 0000 0001
    EDITUSERS = 2, // 2^1 // 0000 0010
    VIEWPRODUCTS = 4, // 2^2 // 0000 0100
    EDITPRODUCTS = 8, // 2^3 // 0000 1000
    VIEWCLIENTS = 16, // 2^4 // 0001 0000
    EDITCLIENTS = 32, // 2^5 // 0010 0000
    DELETECLIENTS = 64, // 2^6 // 0100 0000
}"

Quindi, puoi combinare diverse autorizzazioni usando l'operatore AND bit a bit.
Ad esempio, se un utente può visualizzare & amp; modifica utenti, il risultato binario dell'operazione è 0000 0011 che è stato convertito in decimale è 3.
È quindi possibile archiviare l'autorizzazione di un utente in una singola colonna di DataBase (nel nostro caso sarebbe 3).

All'interno dell'applicazione, è sufficiente un'altra operazione bit per bit (OR) per verificare se un utente dispone di un'autorizzazione particolare o meno.

Se ti va lasciaci una tua opinione

L'articolo ti è stato utile ed è tradotto correttamente?

ALTRI SUGGERIMENTI

Il modo in cui vado generalmente sui sistemi di autorizzazione alla codifica è avere 6 tabelle.

  • Utenti: è piuttosto semplice, è la tipica tabella degli utenti
  • Gruppi: sarebbe sinonimo di dipartimenti
  • Ruoli: questa è una tabella con tutte le autorizzazioni che generalmente includono anche un nome leggibile e una descrizione
  • Users_have_Groups: questa è una tabella molti-a-molti dei gruppi a cui appartiene un utente
  • Users_have_Roles: un'altra tabella molti-a-molti di quali ruoli sono assegnati a un singolo utente
  • Groups_have_Roles: la tabella molti-a-molti finale di quali ruoli ha ciascun gruppo

All'inizio di una sessione degli utenti avresti eseguito una logica che estraeva tutti i ruoli che avevano assegnato, sia nella directory che attraverso un gruppo. Quindi codifichi tali ruoli come autorizzazioni di sicurezza.

Come ho detto, questo è ciò che faccio in genere, ma il tuo millage può variare.

Oltre alle soluzioni di John Downey e jdecuyper, ho anche aggiunto un "Nega esplicito" bit alla fine / all'inizio del campo di bit, in modo da poter eseguire autorizzazioni aggiuntive per gruppo, appartenenza al ruolo e quindi sottrarre autorizzazioni basate su voci di rifiuto esplicite, proprio come NTFS funziona, dal punto di vista delle autorizzazioni.

Sinceramente le funzioni di iscrizione / ruoli ASP.NET funzionerebbero perfettamente per lo scenario che hai descritto. Scrivere i tuoi tavoli / procs / classi è un ottimo esercizio e puoi ottenere un controllo molto preciso sui dettagli minuti, ma dopo aver fatto questo da solo ho concluso che è meglio usare solo le cose .NET integrate. Un sacco di codice esistente è progettato per aggirare il problema, il che è bello. Scrivere da zero mi ha richiesto circa 2 settimane e non era affatto robusto come .NET. Devi codificare tanta merda (recupero password, blocco automatico, crittografia, ruoli, un'interfaccia di autorizzazione, tonnellate di processi, ecc.) E il tempo potrebbe essere speso meglio altrove.

Scusa se non ho risposto alla tua domanda, sono come il ragazzo che dice di imparare c # quando qualcuno fa una domanda vb.

Un approccio che ho usato in varie applicazioni è di avere una classe PermissionToken generica che abbia una proprietà Value variabile. Quindi esegui una query sull'applicazione richiesta, ti dice quali PermissionTokens sono necessari per usarla.

Ad esempio, l'applicazione di spedizione potrebbe dirti che ha bisogno di:

new PermissionToken()
{
    Target = PermissionTokenTarget.Application,
    Action = PermissionTokenAction.View,
    Value = "ShippingApp"
};

Questo può ovviamente essere esteso a Crea, Modifica, Elimina ecc. e, grazie alla proprietà Valore personalizzata, qualsiasi applicazione, modulo o widget può definire le proprie autorizzazioni richieste. YMMV, ma questo è sempre stato un metodo efficiente per me che ho trovato per ridimensionare bene.

Licensed under: CC-BY-SA with attribution
Not affiliated with StackOverflow