Newsgroup: it.comp.lang.delphi
Titolo: Sistema di autenticazione accessi programma

Ciao a tutto il ng,
mi e' stato chiesto di implementare un sistema assai semplificato di accesso a
due livelli ad un programma che gira in un negozio: livello amministratore e
livello dipendente. 
Il dipendente non puo' accedere a certe funzionalita' del programma, mentre
l'amministratore e' ovviamente il proprietario assoluto del sistema.
In maniera assai poco ortodossa ho gia' sviluppato il tutto, con verifica
dell'account sul db dell'applicativo e quindi autorizzazione/negazione
dell'accesso a determinate aree del software.
Siccome questo sistema si attiva ogni qualvolta il datore o il commesso cerca
di entrare in una zona protetta da autenticazione, mi e' stato chiesto di
impedire che ogni volta venga chiesta la password. Una cosa del tipo: mi loggo
e acceddo a tutte le aree di mia competenza fino alla mia disconnessione.
Come posso fare? Devo implementare qualche pattern particolare, oppure esiste
qualche componente/metodologia che mi facilita il compito?
Ora come ora, il software ogni volta controlla userid e password con i dati
contenuti sul db, e autorizza o nega l'accesso in base al risultato
dell'autenticazione.
-- 
Morde. 
(
mo...@despammed.com
)
M-List di icld: 
http://it.groups.yahoo.com/group/icld/

 Come posso fare? 
Io in genere faccio così: 
 - prima di tutto, ogni azione che l'utente può compiere la definisco
attraverso una Action -> i bottoni e le voci di menu vengono poi collegati
alle varie Action
 - al lancio del programma disabilito tutte le action tranne quella per il
login
 - dopo aver effettuato il login, a seconda delle credenziali che leggo sul
db abilito o meno le varie Action
In questo modo, anche se l'utente schiaccia il tasto corrispondente allo
shortcut di un bottone, siccome la sua Action è disabilitata non riuscirà a
farla partire.
procedure TFormMain.aLogoutExecute(Sender: TObject);
var i: Integer;
begin
  for i := 0 to ActionManager1.ActionCount - 1 do
    TAction(ActionManager1.Actions[i]).Enabled := False;
  aLogin.Enabled  := True;
  aChiudi.Enabled := True;
  aInfo.Enabled   := True;
end;
procedure TFormMain.aLoginExecute(Sender: TObject);
var mres: Integer;
    i: Integer;
begin
  mres := FormLogin.ShowModal;
  if mres = mrOk then
  begin
    // Abilita tutte le voci
    for i := 0 to amMain.ActionCount - 1 do
      TAction(amMain.Actions[i]).Enabled := True;
    aLogin.Enabled    := False;
  end;
end;
Finora tutto ciò mi ha dato grandi soddisfazioni!
Saluti
	Marco Bortolani
	info @ 
marcobortolani.it

> Io in genere faccio così:
...
Ciao interessante come soluzione. Io ho un problema simile ma con i 
componenti Intraweb, pensi che si possa adattare in qualche modo visto che 
non posso usare l'ActionManager? Se hai suggerimenti o esempi sono bene 
accetti :-) Thanks
St1

 dell'autenticazione.
Tecniche di SSO (Single-Sign-On) esistono e sono collaudate.  I sistemi
come LDAP servono proprio a questo, a centralizzare le informazioni sulle
credenziali utenti in un luogo solo.  L'utente entra nel sistema, vengono
raccolte e identificate (mediante un ID di "sessione") le informazioni sui
suoi diritti/permessi e da allora in poi viene interrogato il server LDAP
ogni qual volta è necessario testare se l'utente può o meno accedere a
quella specifica parte del sistema.  Bada bene, però, che formalmente in
questo modo è la *sessione* ad essere identificata e non l'*utente*.  E'
una sottile differenza che però è bene tener presente.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

Saluti
	Ciao
	MassimoB
 
---------------------------
http://www.massimobeschi.it/

Ciao a tutto il ng,
[...]
Grazie a tutti per le risposte, ci lavoro un po' su e vedo che riesco a fare.
La soluzione delle taction mi sembra quella piu' semplice e piu' alla mia
portata, faro' di conseguenza :)
Di nuovo grazie :)


 delle azioni
Il metodo che proponi è molto interessante. Fino ad ora bene o male non ho
mai avuto problemi di con il metodo
AbilitaTuttoPoiGestisciICasiParticolari, però anche quello che suggerisci
tu non è male: appena metterò le mani su qualche nuovo progetto lo testerò
subito!


 accetti :-) Thanks
Azz... su Intraweb mi trovi digiuno :-( 
Magari controlla che le voci di menu abbiano una property Enabled e poi
gestisci singolarmente le varie voci, avendo cura di centralizzare il
gestore di evento in una procedura sola e abilitarlo solo se la voce di
menu collegata è attiva (per il caso in cui una routine di gestione sia
invocabile anche da un bottone). 
Ad esempio: 
1. ho il menu file con le voci login e logout e due bottoni per fare le
stesse cose (tipo toolbar)
2. nella routine di gestione del clic sulla voce di menu login metto
    procedure VoceMenuLoginClick(Sender: TObject);
    begin
      if VoceMenuLogin.Enabled then
        ...
3. nella routine di gestione del bottone di login metto il riferimento alla
routine di gestione del click sul menu
    procedure BottoneLoginClick(Sender: TObject);
    begin
      VoceMenuLoginClick(Sender);
    end;
In questo modo centralizzi il tutto... a mano!
Saluti
	Marco Bortolani
	info @ 
marcobortolani.it
P.S.
Ovviamente la cosa è migliorabile, ma così al volo non mi viene altro :-|

 ha scritto nel messaggio
news:uor7u056jgac948d3...@4ax.com...

Io ho utilizzato un metodo diverso dagli altri,
avento un sistema a più livelli e che puo arrivare da 0 a nn.
Dopo essermi loggato verifico a che livello
appartiene l'utente e inizializzo una variabile
LivUtente e quanto tento l'accesso in una sezione
verificho che
if LivUtente In [1,20,21,25] Then
   istruzioni....
End  ShowMessage('Non sei abilitato');
Ciao by Enzo
www.scozzaro.it

End  ShowMessage('Non sei abilitato');
Non male neanche questa.... sopratutto perche' impatta assai poco sul codice
preesistente. :)


> Azz... su Intraweb mi trovi digiuno :-(
vorrei avere la scioltezza mentale del programmatore esperto :-) il 
suggerimento è ottimo. Ne ho di strada da fare :-) Thanks, bye
St 

 dell'autenticazione.
Credo che la strada delle TAction possa essere valida, ma fossi in te
sceglierei una piccola "modifica" al sistema delle actions.
L'idea di base è che l'action si abilita o disabilita in base al
ruolo assegnato alla funzionalità(puoi avere una tabella base che
distingue i singoli ruoli in qualche modo), magari usando la
proprietà Tag.
Poi una classe singleton a livello di applicazione utilizza lo
strato middleware(che può essere anche un semplice dataset,
volendo) per stabilire "chi può fare cosa". L'action interroga il
singleton dicendo: "io sono Tizio, posso abilitarmi?" nell'OnUpdate
della action medesima.
Tramite questo sistema, il tutto può essere usato sia per essere
ulteriormente raffinato in caso di espansione dei ruoli, sia poi
essere generalizzato per dar vita ad un framework utile per
altri progetti.
Che ne pensi?
Ciao,
Andrea

Che ne pensi?
Che ad esser capace, avrei fatto proprio cosi' ;)
Ho scelto la soluzione proposta da Enzo Scozzaro,e l'ho gia' implementata nel
programma.
Grazie per la risposta, che resta a futuro utilizzo di chiunque avra' questa
necessita'.


 necessita'.
Beh, mi trovavo ed ho fatto una piccola prova per vedere che veniva
fuori :-)
Link: 
http://cc.borland.com/codecentral/ccWeb.exe/listing?id=22957
Se vuoi dagli un'occhiata :-)
Ciao,
Andrea