
guide
Tutti i linguaggi per diventare uno sviluppatore di app per Android.
Gestiamo gli utenti con PHP. Da login e logout alla gestione dei permessi.
In questo articolo vogliamo introdurre i lettori ai concetti fondamentali riguardanti la gestione degli utenti all’interno di un sito web o di un’applicazione internet. Tratteremo argomenti relativi all’autenticazione, alla gestione dei permessi, alla sicurezza ed alla registrazione, in modo da presentare un’analisi completa delle problematiche che si devono affrontare durante la stesura di un sistema simile.
Gli script proposti implementano una struttura procedurale abbastanza frammentata, in modo da permettere la semplice modifica per adattarli alle proprie esigenze.
Prima di iniziare esorto i lettori a leggere gli articoli riguardanti i Tutto sui cookie e le Sessioni alternative in Php presenti su HTML.it, anche se non essenziali per la corretta comprensione degli articoli.
Abbiamo racchiuso i file utilizzati in questo articoli in tre diversi archivi ZIP che corrispondono alle tre parti in cui è diviso questo articolo: uno relativo all’autenticazione, uno relativo alla registrazione e uno ai permessi. Tutti gli script sono stati comunque racchiusi anche in un unico archivio. Vanno tenuti presenti in modo particolare poiché faremo riferimento ad essi per ogni commento al codice interno all’articolo.
Nelle prime pagine dell’articolo svilupperemo un semplice sistema di autenticazione che permetterà di svolgere le seguenti operazioni:
Il sistema, una volta verificata la correttezza dei dati passati, inizializzerà una sessione all’interno del nostro database, ed utilizzerà un ID univoco come riferimento a questa. Questo ID verrà passato tra le pagine sfruttando o i cookie o la query string dell’URL, in base alle scelte del programmatore.
Prima di iniziare, prepariamo il nostro database: creiamo una tabella per gestire le sessioni con il seguente comando:
CREATE TABLE sessioni ( uid CHAR(32) NOT NULL, user_id INT UNSIGNED NOT NULL, creation_date INT UNSIGNED NOT NULL, INDEX(uid) );
La tabella sessioni contiene tre campi:
Creiamo ora la tabella per salvare informazioni sugli utenti:
CREATE TABLE utenti ( id INT UNSIGNED NOT NULL AUTO_INCREMENT, name VARCHAR(30) NOT NULL, surname VARCHAR(30) NOT NULL, username VARCHAR(30) NOT NULL, password CHAR(32) NOT NULL, PRIMARY KEY(id), INDEX(username, password) );
La tabella utenti contiene cinque campi:
Dato che il processo di registrazione verrà analizzato nei prossimi articoli, riempiremo ora la tabella utenti manualmente:
INSERT INTO utenti (name, surname, username, password) VALUES (‘Gabriele’, ‘Farina’,’darkbard’,MD5(‘test’)); INSERT INTO utenti (name, surname, username, password) VALUES (‘Fabio’, ‘Sutto’,’fabio heller’,MD5(‘test2’)); INSERT INTO utenti (name, surname, username, password) VALUES (‘Giancarlo’, ‘Moschitta’,’gm’,MD5(‘test3’));
L’unica cosa da appuntare è l’utilizzo della funzione MD5 (facente parte del core di funzioni di MySQL): data una stringa in input, questa funzione restituisce un valore di 32 bit irreversibile che rappresenta univocamente la stringa data. Salvando nel database le password attraverso MD5 aumentiamo leggermente la sicurezza: difatti, anche avendo accesso manuale al database, non si avrà alcun modo per conoscere la password relativa ad un dato utente.
La semplice applicazione che creeremo avrà la seguente struttura nel filesystem:
autenticazione
|
+--- Directory: include
| |
| +--- File: config.php
| |
| +--- File: auth.lib.php
|
+--- File: home.php
|
+--- File: login.php
|
+--- File: logout.php
|
+--- File: pagina1.html
|
+--- File: pagina2.php
|
+--- File: pagina3.php
|
+--- File: pagina4.php
Cominciamo creando il file di configurazione (config.php): questo file conterrà alcune costanti predefinite che utilizzeremo all’interno dei nostri script (il loro significato vi verrà spiegato in seguito), i parametri di connessione al DB, alcune opzioni e le funzioni per effettuare la connessione a MYSQL. Nel file config.php contenuto nella cartella include potete visualizzare il codice necessario.
Continuiamo iniziando a scrivere il file auth.lib.php, che conterrà tutte le funzioni che utilizzeremo per effettuare il processo di autenticazione dell’utente. Sempre per motivi di spazio, non vi mostro il listato del codice, che potete comunque trovare all’interno del file auth.lib.php nella cartella include.
Questa libreria implementa le funzionalità necessarie affinché il nostro script sia capace di autenticare un utente. Vediamola in dettaglio.
L’array $_AUTH contiene le opzioni capaci di cambiare il comportamento della libreria. Per ora solo un’opzione è stata inserita che serve ad identificare il metodo con il quale passare tra le varie pagine l’ID di sessione; le opzioni possibili sono AUTH_USE_LINK
, AUTH_USE_COOKIE
. Lascio a voi la modifica della libreria per permettere la gestione dell’ID tramite metodi alternativi. Questo array non verrà mai letto direttamente, ma utilizzeremo le funzioni auth_get_option()
e auth_set_option()
. In questo modo potremo implementare una gestione più completa delle opzioni, magari elaborando i dati presenti nell’array in caso di richieste particolari;
La funzione auth_clean_expired() viene utilizzata per eliminare le sessioni scadute precedentemente. Viene richiamata in ogni pagina dalla funzione auth_get_status(). L’eliminazione della sessione avviene semplicemente eliminando dal database i record relativi a sessioni scadute, ed eliminando l’ID di riferimento salvato.
La funzione auth_get_uid() restituisce l’ID univoco relativo alla sessione corrente. Preleva l’ID in base al valore dell’opzione TRANSICTION METHOD
auth_get_status() viene utilizzata per prelevare un array di due valori avente come primo valore lo stato dell’utente che sta navigando la pagina e come secondo una lista di informazioni relative all’utente, in caso questi sia connesso. Per prima cosa vengono eliminate le sessioni scadute, poi viene recuperato l’ID univoco. Se questo non è presente, significa che l’utente non ha ancora effettuato il login o che la sua sessione è scaduta. Se invece esiste, vengono prelevate dal database le informazioni relative all’utente e restituite.
auth_login() effettua il login: accetta come parametri l’username e la password esegue una query di selezione per controllare che i dati permettano il login di un utente. In caso affermativo restituisce lo status AUTH_LOGEDD_IN ed i dati dell’utente, in caso negativo restituisce AUTH_INVALID_PARAMS e nessun altra informazione.
auth_generate_uid() genera un ID univoco di 32 caratteri, sfruttando funzioni builtin di PHP.
auth_register_session() accetta come parametri i dati di un utente che si suppone autenticato precedentemente, e genera una nuova sessione; inserisce nella tabella delle sessioni le informazioni necessarie, e restituisce un array: in caso l’operazione sia andata a buon fine restituirà lo status AUTH_LOGEDD_IN e l’ID della sessione, altrimenti AUTH_FAILED e null’altro.
L’ultima funzione, auth_logout(), esegue il logout dell’utente connesso, eliminando la sessione a lui riferita.
Dopo aver scritto la nostra libreria, non ci resta che testarla con un semplicissimo esempio. In questo esempio permetteremo ad un utente di navigare all’interno di della pagine, alcune private altre pubbliche, e di effettuare login e logout.
Il file presentati all’interno della cartella principale del file compresso contengono un semplice applicativo di esempio. La libreria viene utilizzata per effettuare il login nel seguente modo:
<?php include_once(“include/config.php”); include_once(“include/auth.lib.php”);
list($status, $user) = auth_get_status();
if($status == AUTH_NOT_LOGGED){ $uname = strtolower(trim($_POST[‘uname’])); $passw = strtolower(trim($_POST[‘passw’]));
if($uname == “” or $passw == “”) $status = AUTH_INVALID_PARAMS; else{ list($status, $user) = auth_login($uname, $passw); if(!is_null($user)) list($status, $uid) = auth_register_session($user); } }
switch($status){ //… controllare nel file login.php per il codice completo } ?>
Dopo aver controllato che lo status dell’utente non corrisponda ad AUTH_LOGGED, e dopo aver controllato che entrambi i dati passati tramite POST siano corretti, richiamiamo le funzioni auth_login() ed auth_register_session() per eseguire il login e registrare una nuova sezione. Il grosso switch presente alla fine della pagina controlla il valore della variabile $status (che rappresenta lo stato in cui lo script è terminato), e visualizza un messaggio all’utente. Con questo metodo possiamo gestire varie possibilità molto semplicemente.
Oltretutto in ogni pagina privata è presente un semplice controllo sullo stato dell’utente che sta navigando attualmente (prelevato sempre attraverso auth_get_status() ). In caso lo stato sia AUTH_LOGGED sappiamo che l’utente è loggato e possiamo permettergli di visualizzare i dati della pagina, altrimenti no .
In questa parte descriveremo il processo di registrazione di un nuovo utente. Il sistema che svilupperemo sarà strutturato in modo da eseguire le seguenti operazioni:
Vedremo le modifiche da apportate ad ogni file trattao nelle pagine precedenti e spiegheremo la struttura dei nuovi script aggiunti.
Prima di addentrarci nel codice PHP, apportiamo delle modifiche alla tabella utenti in modo da renderla adatta a gestire il nostro processo di autenticazione:
ALTER TABLE utenti ADD indirizzo VARCHAR( 100 ) NOT NULL, ADD occupazione VARCHAR( 100 ) NOT NULL, ADD temp SET( ‘0’, ‘1’ ) NOT NULL, ADD regdate VARCHAR( 11 ) NOT NULL, ADD uid VARCHAR( 32 ) NOT NULL;
I primi due campi aggiunti sono due dati simbolici che rappresentano le informazioni necessarie affinché l’utente possa registrarsi. Potete aggiungerne altri, ma ricordate di apportare le modifiche necessarie ai file descritti in seguito.
Il campo temp contiene un valore pari a 1 in caso l’utente non abbia ancora confermato la registrazione, pari a 0 in caso contrario. Dato che un utente che non ha ancora confermato i dati non può effettuare il login, modifichiamo la query SQL eseguita dalla funzione auth_login all’interno del file auth.lib.php in questo modo:
$result = mysql_query(” SELECT * FROM “.$_CONFIG[‘table_utenti’].” WHERE username='”.$uname.”‘ and password=MD5(‘”.$passw.”‘) and temp = ‘0’” );
Il campo regdate conterrà l’istante in cui la registrazione è stata effettuata. Verrà utilizzato per rimuovere le registrazioni non ancora confermate e scadute.
Infine il campo uid conterrà un indice univoco che utilizzeremo per la conferma della registrazione.
Aggiungiamo alla tabella dei link all’interno del file home.php un riferimento al form di registrazione:
<td><a href=”registrati.php”>Registrati</a></td>
La libreria per la registrazione che ci accingiamo a scrivere conterrà funzioni utili per il controllo, il salvataggio e la validazione dei dati. Il codice sorgente può essere prelevato dal file reg.lib.php all’interno della cartella include.
La funzione reg_register accetta come parametro un array associativo contenete i dati dell’utente: dopo aver prelevato un indice univoco necessario per la successiva conferma dei dati, la funzione inserisce un nuovo record all’interno del database ed invia una mail all’utente attraverso un’altra funzione di libreria; come potete notare il campo temp è settato automaticamente a 1, in modo da impedire il login dell’utente finché questi non avrà confermato i suoi dati.
La funzione successiva, reg_send_confirmation_mail, accetta come parametri l’indirizzo dell’utente, l’indirizzo di provenienza della mail e l’id univoco, e si pone il compito di inviare una mail all’utente contenete il link alla pagina di conferma.
reg_clean_expired ripulisce la tabella utenti dalle registrazioni scadute, basandosi sui dati presenti nel file di configurazione. reg_get_unique_id genera un indice univoco, utilizzato per la conferma.
La funzione reg_check_data viene utilizzata per effettuare un controllo sui dati inseriti dall’utente; per ogni dato presente all’interno dell’array passato come argomento, questa funzione richiama una callback associata precedentemente all’interno del file di configurazione, la quale si occuperà di validare o meno il dato; nel caso in cui siano stati riscontrati errori, questa funzione li restituirà al blocco di codice chiamante, in modo che questi possa gestirli correttamente.
L’ultima funzione presente all’interno del modulo, reg_confirm, è quella che effettua la conferma dei dati, modificando il valore del campo temp nella tabella utenti in base al parametro passatole.
Come possiamo notare anche questo modulo è molto semplice e compatto, e contiene tutte le operazioni necessarie a soddisfare gli obiettivi che ci eravamo posti all’inizio dell’articolo.
Non ci resta che adattare gli altri script alla nuova libreria.
Il file config.php contenuto nella cartella include è stato leggermente modificato in modo da supportare la libreria di registrazione. È stato aggiunto il parametro di configurazione regexpire che rappresenta il numero di ore dopo le quali una registrazione non confermata sarà dichiarata scaduta.
Il parametro check_table è invece un array associativo strutturato in modo da associare ad ogni chiave, rappresentante un campo del form di registrazione, una funzione che ne controlli il valore. Questa funzione di callback accetta come parametro il valore del campo, e restituisce true in caso di successo, oppure una stringa che rappresenta il valore testuale dell’errore. In caso un valore del form non sia presente come chiave dell’array, il valore viene interpretato automaticamente come corretto.
Le funzioni check_* sono quelle di callback. Per non allungare il codice inutilmente, ho associato la funzione check_global a quasi tutti i campi.
La struttura a callback permette di gestire facilmente l’aggiunta o la rimozione di campi all’interno del form di registrazione.
Sono state aggiunte anche tre costanti, caratterizzate dal prefisso REG_, utilizzate come valore di ritorno di alcune funzioni al fine di implementare un controllo degli stati simile a quello utilizzato durante la stesura dello script di autenticazione.
Il modulo di registrazione (contenuto nel file registrati.php) è un semplice form HTML contente un numero di campi pari ai valori necessari al fine di rendere la registrazione corretta.
In caso voleste aggiungere o rimuovere dei campi dal processo di registrazione, le operazioni da seguire sono le seguenti:
Il modulo di registrazione richiama la pagina register.php che si occupa di effettuare realmente la registrazione. La pagina ha il seguente contenuto:
<html> <head> <style type=”text/css”> <!– .style1 { color: #FF0000; font-weight: bold; } –> </style> </head> <body> <?php include_once(“include/config.php”); include_once(“include/reg.lib.php”);
if(isset($_POST[‘action’]) and $_POST[‘action’] == ‘Invia’){ $ret = reg_check_data($_POST); $status = ($ret === true) ? reg_register($_POST) : REG_ERRORS;
switch($status){ case REG_ERRORS: ?> <span class=”style1″>Sono stati rilevati i seguenti errori:</span><br> <?php foreach($ret as $error) printf(“<b>%s</b>: %s<br>”, $error[0], $error[1]); ?> <br>Premere “indietro” per modificare i dati <?php break; case REG_FAILED: echo “Registrazione Fallita a causa di un errore interno.”; break; case REG_SUCCESS: echo “Registrazione avvenuta con successo.<br> Vi è stata inviata una email contente le istruzioni per confermare la registrazione.”; break; } } ?> </body> </html>
A parte l’ovvio codice HTML, possiamo notare che, dopo aver effettuato un controllo sul fatto che la pagina abbia ricevuto dei dati, lo script si occupa di controllare il valore dei dati ricevuti e di effettuare successivamente la registrazione. Il controllo della variabile $status permette di mostrare all’utente un output differente in base al risultato delle funzioni richiamate: ad esempio, in caso di errori, lo script si occupa di mostrare all’utente una lista contenete il nome del campo ed il valore dell’errore.
L’ultima pagina generata e non ancora trattata è confirm.php:
<?php include_once(“include/config.php”); include_once(“include/reg.lib.php”);
if(isset($_GET[‘id’]) and strlen($_GET[‘id’]) == 32){ reg_clean_expired(); $status = reg_confirm($_GET[‘id’]);
switch($status){ case REG_SUCCESS: echo “La tua registrazione è stata confermata; ora puoi effettuare il login.”; break; case REG_FAILED: echo “La registrazione non può essere confermata, probabilmente picchè è scaduta.”; break; } } ?>
Dopo aver controllato che sia stato passato un ID valido alla pagina tramite querystring, lo script rimuove le registrazioni scadute e richiede una conferma dei dati: in caso affermativo sarà concesso all’utente di effettuare il login, altrimenti verrà visualizzato un messaggio di errore
Con quest’ultima parte concludiamo la mini-guida alla gestione degli utenti con PHP. Nelle prime tre pagine abbiamo iniziato strutturando il database e creando degli script che ci permettessero di gestire gli utenti con PHP (login, logout e sessioni). Successivamente, dalla pagina 4 alla pagina 6, abbiamo esteso l’esempio aggiungendo, senza troppe difficoltà data l’organizzazione procedurale dei file, un modulo che permettesse la registrazione di nuovi utenti.
In quest’ultima parte, infine, ci preoccuperemo di implementare degli script che rendano possibile la gestione di permessi relativi ad ogni utente, così da avere la possibilità di impedire o permettere l’esecuzione di alcune operazioni in base all’utente con il quale il server sta dialogando.
Esistono molti sistemi per gestire l’assegnazione di permessi agli utenti; io ho deciso di implementarne uno abbastanza semplice basato su operazioni binarie, che verrà descritto il più dettagliatamente possibile in questo articolo.
Come negli altri articoli, prima di spiegare le modifiche fatte agli script, ci accingiamo ad eseguire semplici query SQL per rendere il database adatto a gestire le aggiunte. Eseguiamo le seguenti query:
ALTER TABLE utenti ADD permessi INT DEFAULT ‘0’ NOT NULL ;
CREATE TABLE permessi ( id INT UNSIGNED NOT NULL , nome VARCHAR( 100 ) NOT NULL , descrizione TEXT NOT NULL , PRIMARY KEY ( id ) );
La prima query modifica la tabella utenti aggiungendole un campo permessi nel quale salveremo un intero che rappresenta i permessi associati al singolo utente. La seconda query si occupa di creare la tabella per la gestione dei permessi:
Dopo aver apportato le modifiche al database e dopo aver modificato leggermente il testo della pagina home.php (guardate il file omonimo per le semplicissime modifiche), ci apportiamo ad impostare la pagina di amministrazione: questa pagina ci permetterà di assegnare o togliere i permessi ad un dato utente e di crearne di nuovi; ho impostato la pagina in modo che abbia un aspetto simile a seguente:
la parte superiore permette la gestione dei permessi: possiamo modificare i permessi di un utente semplicemente selezionando o meno la checkbox relativa e ciccando sul pulsante modifica.
La parte inferiore permette di aggiungere un nuovo permesso nel database, semplicemente compilando i campi.
Ora descriverò le librerie base che sfrutteremo all’interno dei nostri script per permettere la gestione dei permessi. La libreria contenuta nel file utils.lib.php è molto semplice:
<?php function get_users_list(){ $result = mysql_query(” SELECT * FROM utenti WHERE temp=’0′ “); $data = array(); while($tmp = mysql_fetch_assoc($result)){ array_push($data, $tmp); };
return $data; }
function user_get_id($user){ return mysql_result(mysql_query(” SELECT id FROM utenti WHERE username='”.$user[‘username’].”‘ and password='”.$user[‘password’].”‘ “), 0, ‘id’); } ?>
La funzione get_users_list restituisce una lista di tutti gli utenti registrati presenti all’interno del database. La funzione user_get_id accetta come parametro un array contente le informazioni relative ad un utente, e ne restituisce l’id.
La libreria contenuta nel file license.lib.php è invece leggermente più complicata, e contiene tutte le procedure necessarie a gestire i permessi:
Urge una breve spiegazione delle operazioni boolene su multipli di due: i multipli di due, trasformati in numeri binari, assumono il seguente aspetto:
quando i numeri binari sono combinati attraverso le operazioni boolean AND ed OR, viene fatto un controllo booleano cifra per cifra nel seguente modo:
Come potete notare vengono svolte operazioni molto semplici:
La spiegazione è purtroppo molto sommaria, ma in rete potrete trovare moltissime informazioni utili a riguardo.
La sezione di amministrazione, contenuta nel file admin.php, è molto semplice da sviluppare: oltre al solito codice HTML per impaginare i dati, svolgiamo le seguenti operazioni:
Spostando il mouse sopra il nome di un permesso,ne visualizzeremo la descrizione.
Come potete notare la zona di amministrazione è molto semplice ma funzionale; non viene effettuato alcun controllo al momento dell’accesso alla pagina, quindi sarebbe opportuno aggiungere il sistema di autenticazione anche a questa pagina.
Il procedimento per controllare i permessi è molto semplice: ho modficato leggermete la pagina pagina4.php in modo che necessiti del permesso “test” (che ho precedentemente creato all’interno del database tramite la pagina di amministrazione):
<?php include_once(“include/config.php”); include_once(“include/auth.lib.php”); include_once(“include/utils.lib.php”); include_once(“include/license.lib.php”);
list($status, $user) = auth_get_status();
if($status == AUTH_LOGGED){ $msg = “Hai i seguenti permessi:<br>”; foreach(license_get($user) as $perm){ $msg .= “>> “.$perm[‘nome’].”<br>”; } $msg .= (license_has($user, “test”)) ? “HAI IL PERMESSO TEST, e quindi ti é permesso eseguire questa operazione” : “<b>NON</b> HAI IL PERMESSO TEST, e quindi <b>NON</b> ti é permesso eseguire questa operazione”;
}else $msg = ‘<b><font color=”red” size=”5″>Non hai i diritti per visualizzare la pagina</font></b>’; ?> <html> <head> <title>Pagina quattro</title> <meta http-equiv=”Content-Type” content=”text/html; charset=iso-8859-1″> <style type=”text/css”> body,td,th { font-family: Verdana, Arial, Helvetica, sans-serif; font-size: 9px;}</style> </head> <body> <?=$msg;?> </body> </html>
Dopo aver controllato che l’utente ha effettuato il login attraverso il metodo descritto nel primo articolo, utilizziamo la funzione license_has per controllare che l’utente abbia il permesso necessario (test): in caso affermativo visualizziamo un messaggio, in caso negativo un altro. In questo modo, utilizzando semplici istruzioni condizionali, possiamo visualizzare e permettere operazioni solamente ad utenti aventi un particolare permesso. Potremmo per esempio visualizzare opzioni aggiuntive all’interno di un forum solamente agli utenti che hanno il permesso “moderatore”, oppure visualizzare la lista dei forum in base ai permessi di visualizzazione che ha l’utente che sta visitando la pagina.
Come semplice controllo, visualizzo anche la lista di tutti i permessi associati all’utente corrente.
Siamo arrivati alla fine della mini-guida. Spero l’argomento sia stato di vostro gradimento, e vi invito ad approfondire i discorsi affrontati in modo da gestire in modo più completo i sistemi di autenticazione.
Se vuoi aggiornamenti su Gestire gli utenti con PHP inserisci la tua email nel box qui sotto:
Compilando il presente form acconsento a ricevere le informazioni relative ai servizi di cui alla presente pagina ai sensi dell'informativa sulla privacy.
La tua iscrizione è andata a buon fine. Se vuoi ricevere informazioni personalizzate compila anche i seguenti campi opzionali:
Compilando il presente form acconsento a ricevere le informazioni relative ai servizi di cui alla presente pagina ai sensi dell'informativa sulla privacy.
Come approcciare al paradigma funzionale di programmazione per sviluppatori Java
Tutti i linguaggi per diventare uno sviluppatore di app per Android.
Come creare applicazioni per il Web con PHP e MySQL per il DBMS.
Tutte le principali tecnologie per diventare uno sviluppatore mobile per iOS.
I fondamentali per lo sviluppo di applicazioni multi piattaforma con Java.
Diventare degli esperti in tema di sicurezza delle applicazioni Java.
Usare Raspberry Pi e Arduino per avvicinarsi al mondo dei Maker e dell’IoT.
Le principali guide di HTML.it per diventare un esperto dei database NoSQL.
Ecco come i professionisti creano applicazioni per il Cloud con PHP.
Lo sviluppo professionale di applicazioni in PHP alla portata di tutti.
Come sviluppare applicazioni Web dinamiche con PHP e JavaScript.
Fare gli e-commerce developer con Magento, Prestashop e WooCommerce.
Realizzare applicazioni per il Web utilizzando i framework PHP.
Creare applicazioni PHP e gestire l’ambiente di sviluppo come un pro.
Percorso base per avvicinarsi al web design con un occhio al mobile.
Realizzare siti Web e Web application con WordPress a livello professionale.
Come creare database e collection, inserire, estrarre, aggiornare e rimuovere dati da una base di dati MongoDB con Python
Impariamo ad utilizzare Takamaka, una blockchain Java Full Stack, per scrivere codice Java installabile ed eseguibile su una blockchain
Misurare l’efficacia di una campagna pubblicitaria su web
Come creare un’applicazione per la gestione di un negozio di commercio elettronico con il framework PHP Laravel. Una guida completa che, partendo dalla configurazione di un ambiente di sviluppo basato su Laravel, descrive nel dettaglio tutti i passaggi necessari per pubblicare un e-commerce con cui promuovere e vendere i propri prodotti online