Share
Ho visto alcuni tutorial introduttivi per Codeigniter e speravo di mostrarti qualcosa di più avanzato. Questo tutorial ti mostrerà come creare una potente applicazione web per l'hosting di immagini, utilizzando la flessibilità di Codeigniter. Questo tutorial dovrebbe insegnarti la filosofia di codifica MVC, integrata nella produzione di applicazioni utili.
Prima di andare ovunque vicino al codice, dobbiamo fare un po 'di setup. Avvia il tuo editor di database preferito (userò SQLBuddy) e crea un nuovo database chiamato "uploadr". Al suo interno, crea due tabelle: "utenti" e "file". Imposta agli utenti di avere una colonna "id" con chiave primaria, numerata automaticamente, insieme a due colonne varchar: "password" e "username". La tabella dei file ha bisogno di un'altra colonna "id" (di nuovo chiave primaria e numerazione automatica), oltre a una colonna "proprietario" intero e una colonna "nome" varchar.
Dato che questo tutorial è focalizzato sull'apprendimento della programmazione di Codeigniter e su MVC, rinunciamo a tutto lo stile (come CSS, photoshop). A tal fine, ho creato un'installazione Codeigniter personalizzata per te, con tutti i file creati e le viste (principalmente) HTML-d e CSS-d. Le due cose che devi modificare sono le impostazioni di configurazione e del database. Ho persino incluso un timbro "Beta", quindi mi sento ancora più simile a una startup web!
Ora sul primo pezzo di carne! Apri il controller 'login.php' e crea una funzione chiamata 'register'. Questo controllerà l'intero processo di registrazione. Innanzitutto, dobbiamo verificare se sono state inviate al server richieste POST. In questo caso, questi significano che qualcuno sta tentando di registrarsi. Possiamo farlo controllando se $ _POST ['username'] è impostato. Se lo è, allora sappiamo che qualcuno ha provato a registrarsi e può inserirlo nel DB.
function register () if (isset ($ _ POST ['username'])) // L'utente ha provato a registrarsi, inserirli nel database. $ username = $ _POST ['username']; $ password = $ _POST ['password']; $ this-> users-> register ($ username, $ password); redirect ( 'login'); else // L'utente non ha provato a registrarsi, a richiamare le informazioni di registrazione. $ This-> load-> view ( 'registro');
Se l'utente non ha ancora provato a registrarsi, lo rileva e li invia automaticamente alla vista "registrati" che ho codificato per te. Noterai la linea:
$ This-> utenti-> registro ($ username, $ password);
Questo sta chiamando la funzione 'registrati' nel modello 'utenti'. Al momento questo non funzionerà, dal momento che non abbiamo caricato il modello. Lo facciamo allo stesso modo del caricamento delle viste, ma visto che utilizzeremo questo modello estesamente in questa classe, lo cariceremo nella funzione di costruzione (la funzione con lo stesso nome della classe), in modo che sia sempre caricato e disponibile:
function Login () parent :: Controller (); $ This-> load-> modello ( 'utenti');
Probabilmente sei interessato a cosa contiene effettivamente la funzione di registrazione. Bene, utilizza semplicemente un paio di funzioni di registrazione attive di Codeigniter, che consentono la manipolazione di DB. Il grande vantaggio dell'uso delle funzioni di registrazione attive incorporate in Codeigniter (oltre al fatto che sono semplici e semplici) è che sono indipendenti dal database: è possibile passare facilmente a diversi tipi di database (ad esempio mySQL, SQLite) nel DB config file senza influenzare l'applicazione. Nel caso della nostra registrazione, stiamo aggiungendo una voce alla tabella degli utenti. Crea questa funzione nel modello "users.php":
Accentsconagua
registro delle funzioni ($ username, $ password) $ new_user = array ('username' => $ username, 'password' => $ password); $ this-> db-> insert ('users', $ new_user); ritorna vero; L'unica cosa che vale la pena notare nella vista di registrazione sono le funzioni site_url () e base_url (). Questi rispettivamente danno l'URL del tuo sito con e senza il suffisso index.php /. Il più grande vantaggio per loro è che puoi cambiare la struttura dell'URL del tuo sito senza dover passare attraverso tutti i link: basta una modifica nel tuo file di configurazione.
Una volta che tutto è pronto, possiamo provare a registrare un account. La funzione nel nostro controller dovrebbe reindirizzare nuovamente la pagina di accesso dopo la creazione del nostro account.
Ora che abbiamo impostato alcuni utenti, abbiamo bisogno di un modo per farli realmente entrare nel sito. Per questo, useremo la lezione session di Codeigniter. Anche se questo in realtà utilizza i cookie, funziona in modo molto simile alle normali sessioni di PHP, solo con più opzioni (ti consiglio di controllare l'userguide).
Per cominciare, dobbiamo creare la funzione che il pulsante di accesso punta attualmente, "vai". Questa funzione dovrà raccogliere le informazioni che il modulo ha inviato e quindi controllarle sul DB utilizzando un modello. Se tutto è corretto, inizierà una sessione e reindirizza l'utente ai suoi file. Se hanno digitato male le loro informazioni, verranno reindirizzati alla pagina di accesso.
function go () $ username = $ _POST ['username']; $ password = $ _POST ['password']; // Restituisce userid se ha successo, false se fallita $ results = $ this-> users-> login ($ username, $ password); if ($ results == false) redirect ('login'); else $ this-> session-> set_userdata (array ('userid' => $ results)); reindirizzare ( 'profilo'); Parti di questa funzione dovrebbero sembrare molto familiari dalla funzione di registrazione: raccoglie $ username e $ password, prima di inviarli a un modello (questa volta 'login'). Dopo questo, tuttavia, le differenze iniziano a verificarsi.
Quindi controlla se il login è fallito; se lo ha, l'utente viene reindirizzato alla pagina di accesso. Tuttavia, se l'accesso ha esito positivo, lo script crea una sessione, impostando 'userid' sull'id utente. Tutto ciò di cui abbiamo bisogno ora che lo script di login funzioni è il modello. Aggiungi questa funzione al modello "utenti" che abbiamo usato in precedenza:
login funzione ($ username, $ password) $ query = $ this-> db-> get_where ('users', array ('username' => $ username, 'password' => $ password)); if ($ query-> num_rows () == 0) restituisce false; else $ result = $ query-> result (); $ first_row = $ result [0]; $ userid = $ first_row-> id; return $ userid; Un rapido riassunto: in primo luogo, interroga il database cercando gli utenti con esattamente lo stesso nome utente e password. Se non ne trova, il numero di righe sarà 0 e la funzione restituirà false. Se viene trovato qualcuno, utilizza un'altra delle funzioni di registrazione attive di Codeigniter per caricarlo come oggetto. Questo oggetto viene fornito come una matrice di righe DB, ciascuna contenente un oggetto con le informazioni di tali righe. Dal momento che vogliamo la prima e l'unica riga, eliminiamo $ result, quindi restituiamo l'id da esso.
Dovremo controllare se l'utente ha effettuato l'accesso mentre era nella pagina del profilo. Per fare ciò, inseriamo semplicemente due righe di codice nel costruttore del controller del profilo. Questo verificherà che la sessione contenga un ID utente. In caso contrario, reindirizzare alla pagina di accesso. Se lo fa, allora va tutto bene e diventa una variabile pubblica. Mentre stiamo cambiando il costruttore, caricheremo i due modelli di cui avremo bisogno per la pagina del profilo:
function Profile () parent :: Controller (); $ This-> load-> modello ( 'utenti'); $ This-> load-> modello ( 'files'); $ this-> userid = $ this-> session-> userdata ('userid'); se (! isset ($ this-> userid) o $ this-> userid == ") reindirizza ('login'); L'ultima cosa che dobbiamo fare è rendere possibile il logout. Questo si ottiene semplicemente impostando l'id utente su nulla, cancellandolo. Tutto ciò che richiede è una semplice funzione:
function logout () $ this-> session-> set_userdata (array ('userid' => ")); redirect ('login'); Allora, abbiamo appena effettuato l'accesso per la prima volta. Con cosa siamo salutati?
Non male, non male, anche se quel 'file di esempio' non viene generato dal nostro database, è statico. Lo risolveremo presto, ma prima dobbiamo modificare i permessi della cartella 'file' in modo che Codeigniter possa leggere e scrivere su di esso. L'ho cambiato in 777 Permessi:
Ora che è fuori mano, torniamo ad alcuni codici! Abbiamo bisogno di caricare tutti i file degli utenti dal database, e per farlo avremo bisogno ...
… un modello! Questa volta però, lo creeremo nel modello 'files.php', quindi manteniamo separati tavolo utente e tabella file. Inserisci questa funzione:
function get ($ userid) $ query = $ this-> db-> get_where ('files', array ('owner' => $ userid)); return $ query-> result (); Questo si rifà ancora dalle sezioni precedenti di questo tutorial, quindi dovresti essere in grado di capirlo. Fondamentalmente, ottiene tutte le righe dove il proprietario = l'id dell'utente e le restituisce in una bella serie di oggetti. Creiamo qualcosa nel controller 'profili' per interfacciarlo con esso e per passare le informazioni sulla vista. Modificare la funzione indice con questo:
function index () $ data ['files'] = $ this-> files-> get ($ this-> userid); $ this-> load-> view ('profile', $ data); Ancora una volta, una funzione molto semplice. Prende i risultati passati dal modello di file e li impacchetta alla vista. Codeigniter passa i dati alla vista di solito attraverso un array (in questo caso i dati). Quindi esploderà automaticamente l'array in molte variabili, quindi quando andremo alla vista, sarà in grado di accedere ai risultati del database tramite $ file, piuttosto che $ data ['file']. Mettiamo questo bellissimo risultato del database nella vista! Attaccalo a "profile.php", sostituendo il codice a cui il commento HTML ti dice di farlo.
nome?>File/nome?> "> Visualizza id)?> "> Elimina
Il ciclo foreach carica a turno ciascuna riga dell'array e lo rende accessibile tramite l'oggetto $ file. Quindi, usando la "sezione" di esempio come modello, inseriamo tutti i collegamenti e il nome con le informazioni per il nuovo oggetto $ file. Vedremo come funziona la funzione di eliminazione in seguito e come funziona il collegamento della vista dopo che abbiamo caricato qualcosa.
Se apri questo nel tuo browser ora, non vedrai nulla. Questo perché non abbiamo caricato alcun file! Bene, dobbiamo correggerlo, quindi dovremo creare un modulo di caricamento. Facciamo prima il controller; apri "profile.php" e aggiungi questa funzione:
function upload () if (isset ($ _ FILES ['file'])) $ file = read_file ($ _ FILES ['file'] ['tmp_name']); $ nome = basename ($ _ FILES ['file'] ['name']); write_file ('files /'.$ name, $ file); $ This-> file-> aggiungere (nome $); reindirizzare ( 'profilo'); else $ this-> load-> view ('upload'); Questa funzione aggiunge un bel po 'di cose nuove: in particolare la gestione dei file di Codeigniter. Inizia in modo abbastanza semplice, controllando se un modulo è stato inviato cercando un file. Se il file non esiste, mostra semplicemente la visualizzazione di caricamento (che verrà aggiornata in seguito). Se il file esiste, quindi estrae legge il file temporaneo che il server ha generato. La directory del file temporaneo può essere trovata in $ _FILES ['your_file'] [' tmp_name '], e il file può essere letto da questa directory tramite read_file di Codeigniter. Carica tutte le informazioni sui file nella variabile $ file.
La riga successiva ottiene il nome del file dal $ _FILES globale in un modo simile per ottenere la directory temporanea. Armato di queste due informazioni, codeigniter scrive il file nella cartella dei file nella stessa directory del suo file indice. Infine, il file deve essere aggiunto al database. Di nuovo, stiamo andando con un modello, questa volta la funzione 'aggiungi' in 'file'. Vedremo come funziona in un minuto, ma ora dobbiamo creare il modulo di caricamento nella vista. Aggiungi questo dove il commento HTML di upload.php ti dice di:
Sostituisci l'HTML corrente con questo. La cosa importante da notare qui è che quando carichiamo i file, usiamo un tipo di input = file, che ci consente di scegliere un file da caricare. Inoltre, dobbiamo specificare un enctype nel nostro tag form, in modo che il server sappia che sta ricevendo un file e per salvarlo. Non troppo interessanti per noi codificatori back-end, ma comunque cruciali! Diamo una rapida occhiata a ciò che abbiamo creato:
Ora passiamo all'ultimo bit dello script di caricamento dei file, il modello. Questo aggiunge il file al database, con il suo nome e proprietario, in modo che il server sappia quali file appartengono a chi. Diamo un'occhiata; aggiungi questo al tuo modello di 'file':
funzione add ($ file) $ this-> db-> insert ('files', array ('owner' => $ this-> session-> userdata ('userid'), 'name' => $ file)) ; Ancora sfruttando la funzionalità di registrazione attiva di Codeigniter, aggiungiamo una riga al database con il nome del file e il proprietario. Otteniamo il proprietario trovando l'id utente dai dati della sessione che abbiamo salvato in precedenza al momento dell'accesso. Tutto sommato, una funzione molto semplice. Proviamo a caricare una bella foto, eh?
Et voilà!
Guardando nella cartella 'file', vediamo che il file che abbiamo caricato è apparso lì, come per magia (Codeigniter magic!), E vediamo perché il link della vista funziona, poiché punta semplicemente direttamente al file nella directory . Fatto questo, tutto ciò che rimane per questo tutorial è l'eliminazione dei file.
Ok, l'ultimo bit. Questo non dovrebbe richiedere molto tempo, dal momento che sarai in grado di utilizzare le idee che hai imparato prima per capirlo. Per prima cosa aggiungeremo questo codice al nostro controller 'profili':
function delete ($ id) // Questo elimina il file dal database, prima di restituire il nome del file. $ name = $ this-> files-> delete ($ id); unlink ( 'file /'.$ name); reindirizzare ( 'profilo');
E questo codice per il nostro modello di 'file':
function delete ($ fileid) $ query = $ this-> db-> get_where ('files', array ('id' => $ fileid)); $ result = $ query-> result (); $ query = $ this-> db-> delete ('files', array ('id' => $ fileid)); return $ result [0] -> name; Il primo controller dovrebbe essere molto facile da capire. Chiama la funzione di cancellazione dal modello di file (che abbiamo definito allo stesso tempo), che genera il nome del file. Quindi usa una funzione PHP di base per cancellare il file con quel nome nella directory dei file. Infine, rimanda al profilo degli utenti (che ora è meno un file).
Il modello è leggermente più complesso. Deve restituire il nome del file e cancellarlo, quindi prima richiede al database di ottenere i dettagli dei file. Carica questo nella variabile $ result e quindi continua a eliminare il file. Quindi restituisce la colonna 'name' della prima riga dell'array (l'unica riga restituita dalla query), che viene quindi utilizzata nel controller di cui sopra.
Proviamo a eliminare una funzione:
E fai clic su Elimina ...
Evviva! Ha funzionato. Immagino che abbiamo finito tutti!
Cancella file
Ovviamente, questo codice non dovrebbe essere eseguito su un server senza alcuni miglioramenti seri. Qui ci sono alcuni problemi principali con esso:
Tutto sommato, hai creato una piccola e potente applicazione web, soprattutto a causa della piccola quantità di codice che dovevi scrivere. A causa della natura di Codeigniter, è facilmente estensibile, sia per risolvere i problemi di cui sopra, sia per aggiungere nuove funzionalità, come ad esempio la ridenominazione dei file. Spero anche che questo tutorial ti abbia insegnato un po 'sull'uso dei concetti MVC e sulla potenza che essi portano: semplicemente aggiustando i modelli sulla nostra applicazione, possiamo scambiare il nostro DB per file di testo, XML o altro, e cambiando le visualizzazioni , possiamo completamente ri-tema senza rompere la funzionalità. Stupefacente!
