PHP OOP - Come gestire l'autorizzazione?

Question

Sto costruendo un sistema di gestione per un'idea che ho. Sono esperto di PHP (almeno abbastanza per fare tutto ciò che devo fare), ma non sono così esperto nell'uso di OOP. Lo uso più che posso, ma molte delle migliori pratiche che non conosco, quindi quando faccio le cose mi preoccupo di farle nell'ordine sbagliato.

Per questo progetto ho una classe per ciò che l'utente sta gestendo, ho bisogno di verificare se l'utente ha o meno le autorizzazioni per gestirlo. So come controllare le autorizzazioni,, la mia domanda è: dove dovrei farlo?

dovrei fare al di fuori della classe, in questo modo:

if user permissions are valid 
initialize class 
else return error 

o dovrei fare

initialize class 
class checks permissions 
class returns error if permissions are invalid 

io sono sicuro che è l'approccio corretto . Da un lato il controllo all'interno della classe sembra il migliore basato su quello che so della metodologia OOP, ma poi ho anche la sensazione che lasciarlo arrivare all'inizializzazione della classe quando le autorizzazioni sono sconosciute potrebbe essere sbagliato.

Come dovrei farlo? Se c'è qualche tipo di articolo che copre questo genere di cose un link sarebbe molto apprezzato (non riesco a trovare nulla attraverso le ricerche ma non sono sicuro al 100% se sto cercando la cosa giusta in quanto conosco poco di OOP)

Answer 1

Dipende da quale è il modello di autorizzazioni e non esiste "un modo corretto" per farlo. È una questione di approccio. La cosa importante è che qualunque cosa tu scelga, la usi in modo coerente.

Nei miei ultimi progetti, mi sono imbattuto in diversi modelli. Uno dei più semplici è un permesso basato su pagina, che è buono se si esegue il flusso basato sulla pagina e si utilizzano oggetti per il supporto: si definisce nella parte superiore della pagina chi deve accedervi e nel caso in cui sia possibile reindirizzare. Questo è il più semplice, ma può essere molto utile su applicazioni specifiche.

Se, al contrario, si utilizzano gli oggetti per eseguire il flusso principale, è necessario proteggere i metodi oggetto (anziché l'istanziazione di classe). Se hai un metodo "save()", che può essere chiamato solo da utenti specifici, per prima cosa quando entri in quel metodo, fai il controllo delle tue autorizzazioni.

Attualmente sto utilizzando un pattern MVC e ho un controller che invia le azioni ai suoi figli. Il suo unico metodo pubblico è execAction($params) e chiamerà lo actionAction($params) su se stesso, ma prima controllerà le autorizzazioni.

Una cosa importante da ricordare è: mai azioni presenti sull'interfaccia utente che l'utente non è autorizzato a fare (a meno che non si sta cercando di costringerlo a comprare la vostra "versione PRO", che è) ;-)

Answer 2

Penso che il modo migliore per fare è avere una classe di permessi. E quindi puoi controllare prima di creare oggetto o in oggetto.

create permission class 
if access then create class and set permission object 
else error 
// do action 
if have permissions show something 
else do not show something 

Guarda come fatto in zend acl component

Answer 3

Ho scritto un sistema CMS piuttosto solido e robusto. Ecco come lo faccio e spero che tu possa estrapolare alcune informazioni sulla creazione della tua soluzione.

• Ho un file di indice, che carica una classe Admin. La funzionalità nel mio CMS è modulare (quindi contenuta nel proprio file e classe).
• Un modulo viene caricato in base a un parametro $_GET.
• Poiché la funzione di controllare il parametro $_GET e caricare la funzione corrispondente è nella mia classe Admin ($admin->pick_method()) e ho anche un oggetto User nella mia classe Admin, posso controllare prima il modulo richiesto è attualmente connesso utente di array di autorizzazioni.
• Se il controllo permessi restituisce true, carico il modulo. Se false, visualizzo una pagina di accesso "non autorizzato".

Spero che questo aiuti.

Answer 4

La convalida all'interno della classe genera una dipendenza tra la classe e l'autorizzazione delle autorizzazioni che non è buona perché si stanno unendo due potenziali elementi diversi. Puoi risolvere questo problema con Inversion of Control (ad esempio dependency injection) o come faccio per authorisation notifications using Emesary.

Convalida al di fuori della classe è forse peggio perché c'è un reale pericolo che il controllo di autorizzazione sia sbagliato o perso completamente. Crea anche il tipo sbagliato di collegamento tra gli oggetti poiché l'oggetto non ha il controllo di se stesso.

Se si sta per farlo al di fuori dell'oggetto quando viene creato, è probabilmente meglio richiedere all'oggetto di fornire un interface come IAuthorisable che può essere verificato da un oggetto separato.

ad es.

interface IAuthorisable 
{ 
    public function getRequirements(); 
} 

class Authorisation 
{ 
    public static createObject($newObj) 
    { 
      if (canDo($newObj->getRequirements())) 
       return $newObj; 
      return null; 
    } 
} 

class Something implements IAuthorisable 
{ 
    public function getRequirements() 
    { 
      return SomeSortOfIdentifierOrSomething; 
    } 
} 

$mySomething = Authorisation::createObject(new Something($p1, $p2), " 

Se $ mySomething è nullo non è consentito. Ovviamente questo ha bisogno di estendere e progettare correttamente, che è lasciato come esercizio per il lettore.

Answer 5

basi OO
Se ha senso per includerlo nella classe. È possibile farlo.
La classe di un libro ha una funzione di autenticazione? No, funzioni come download() e convertToPDF() hanno più senso.

Il mio approccio
cerco sempre di trovare il percorso di minor resistenza.

Se ci sono 10 script/pagine che comunicano con 1 classe e 1 o 2 script richiedono l'autenticazione per determinate azioni, vorrei creare l'autenticazione in questi 1 o 2 script. (o inserirli in una sottocartella con un .htpasswd)

Ma quando si utilizza una struttura MVC, tutto è una classe, quindi diventa una questione di decidere quale classe.
Tendo a inserire le regole di autenticazione nelle classi Controllers e l'autenticazione nella logica del database in una classe User.