Share
Nel nostro ultimo tutorial di CakePHP abbiamo esaminato la creazione del framework CakePHP e introdotto alcuni concetti e terminologia di base del framework. Ora passiamo ad illustrare più funzionalità di sviluppo rapido di CakePHP utilizzando come esempio un'applicazione per blog personale. Nella prossima serie di esercitazioni costruiremo l'applicazione blog in modo incrementale in modo che il processo di sviluppo CakePHP di base sia presentato in modo chiaro invece che brevemente menzionato come in altri tutorial simili. In questo tutorial iniziamo con un componente di autenticazione di base dell'autore per l'applicazione blog di esempio.
Il nostro obiettivo è creare i componenti di un'applicazione per blog personale. Nel momento in cui completeremo il progetto, aggiungeremo effetti Web 2.0 e offriremo l'integrazione con altri servizi per completare l'applicazione. Prima di poter iniziare il nostro progetto, tuttavia, dobbiamo definire un piano di sviluppo con una sorta di elenco di caratteristiche che ci guidino.
Ecco una piccola lista delle caratteristiche principali di cui discuteremo e includeremo nella nostra applicazione finita:
Nell'articolo di oggi ci concentreremo principalmente sul sistema di gestione utente / autore perché è il posto perfetto per imparare le basi del controller, del modello e del codice di visualizzazione. Una volta apprese queste basi, possiamo implementarle in seguito per gli altri componenti del sistema più grande.
Senza ulteriori indugi, infiliamo CakePHP.
Come accennato in precedenza, i modelli interagiscono con il database sottostante del framework. Per impostazione predefinita, CakePHP viene fornito con una serie di metodi incorporati per salvarci dal codice di riscrittura per implementare funzionalità comuni. Oltre ai metodi di lettura e scrittura / salvataggio previsti, puoi anche usare "metodi magici" come findBy
Il nostro sistema utente per questa iterazione dell'applicazione sarà piuttosto semplice. Poiché l'obiettivo principale è un blog personale avremo un solo autore alla volta. Per motivi di estensione, tuttavia, memorizzeremo gli utenti in una tabella nel caso in cui scegliamo di sviluppare un sistema utente / autorizzazione in un secondo momento, o se vogliamo aggiungere manualmente più autori. Le nostre funzionalità di base consentiranno l'accesso, la disconnessione e l'aggiornamento delle informazioni personali.
Faremo tutto questo con una piccola tabella MySQL implementata dalla seguente istruzione CREATE TABLE:
Accentsconagua
CREATE TABLE 'authors' ('id' int (11) NOT NULL auto_increment, 'username' varchar (255) NOT NULL default ", 'password' varchar (32) NOT NULL default", 'name' varchar (255) NOT NULL default "," email "varchar (255) NOT NULL default", "bio" text NOT NULL, PRIMARY KEY ('id')) 
Vogliamo anche un account iniziale di base, quindi inseriremo una riga mentre ci siamo (il nome utente e la password per l'account di partenza sono test / test):
INSERISCI IN "autori" ("nome utente", "password", "nome", "email", "bio") VALORI ("test", "098f6bcd4621d373cade4e832627b4f6", "Test", "[email protected]", "Ciao mondo ... '); Lo scopo della struttura della tabella è il seguente:
Ora abbiamo effettivamente bisogno di creare il modello. Per fare ciò, crea un nuovo file nel / App / modelli / cartella denominata author.php con i seguenti contenuti:
l'autore della classe estende AppModel
var $ name = 'Autore';
?>
Il modello per questa funzionalità è in realtà piuttosto semplice. Dal momento che la funzionalità di cui abbiamo bisogno, come findByUsername o il salvataggio è già coperto dalle funzioni in Model (che è esteso da AppModel) abbiamo finito con il lato del modello. Questo file ci consente di interfacciarci con la tabella Author.
Nelle sezioni successive, quando iniziamo ad aggiungere funzionalità di post, potremmo aver bisogno di estendere i modelli.
Le visualizzazioni sono principalmente un mix di HTML e aiutanti. In altri sistemi chiameremmo questi modelli. Gli helper generano codice comune o aiutano con compiti comuni. Alcuni tipi di helper trovati in CakePHP sono helper HTML e aiutanti di paginazione.
Per stabilire viste, creare una cartella in / App / views / chiamato autori / in modo che possiamo memorizzare tutte le nostre opinioni. La nostra prima visione dovrebbe essere chiamata login.thtml con i seguenti contenuti:
Errore
Il nome utente e la password non corrispondono. Si prega di riprovare e ricontrollare le informazioni inserite.
FormTag ( '/ autori / login /'); ?> ingresso ( 'Autore / username'); ?> password ( 'Autore / password'); ?>
submit ( "Login"); ?>
Invece di usare i tag stanno utilizzando uno degli helper per generare campi di input validi che possono essere utilizzati nei nostri controller. Abbiamo anche inserito un po 'di controllo degli errori nella parte superiore del modello nel caso in cui l'utente inserisca un nome utente o una password errati. La variabile di errore viene impostata successivamente nel controller.
Ora che la nostra prima azione ha un modello dietro, possiamo passare agli altri.
La disconnessione in realtà non ha bisogno della sua vista, perché ridirigeremo gli utenti alla pagina indice del blog e mostreremo un messaggio di successo rapido. L'aggiornamento delle informazioni del profilo nella gestione utenti richiede tuttavia un modulo, quindi sarà necessario scrivere una vista per questo.
Crea un modello chiamato manage.thtml con i seguenti contenuti:
Errore
Assicurati che tutte le informazioni richieste siano state compilate.
FormTag ( '/ autori / gestire /'); ?> ingresso ( 'autore / nome'); ?>
ingresso ( 'Autore / email'); ?>
textarea ('Autore / bio', array ('cols' => '60', 'rows' => '10')); ?>
submit ( "Update"); ?>
Questa vista è molto simile al nostro modulo di login eccetto che stiamo gestendo alcuni campi diversi e includiamo un altro metodo di supporto ($ html-> textarea) per generare un'area di testo.
Grande! Ora che la nostra piccola serie di punti di vista è scritta, possiamo passare ai controller.
I controllori si comportano come i direttori del traffico. Accettano input, decidono cosa fare e poi forniscono istruzioni di gestione al resto del sistema. Sono il cuore dell'applicazione perché prendono i dati dai modelli e li inoltrano per correggere le visualizzazioni da visualizzare.
Questa sezione riguarda specificamente l'impostazione e la lettura di una sessione e l'aggiornamento del database. Creeremo anche un controller "genitore" dal quale erediteranno tutti i nostri futuri controllori.
Prima crea un file in app / controllers / di nome authors_controller.php. Ora passeremo attraverso il codice passo dopo passo.
reindirizzare( '/' ); function login () $ this-> set ('error', false); se (! empty ($ this-> data)) $ author = $ this-> Author-> findByUsername ($ this-> data ['Author'] ['username']); if (! empty ($ author ['Autore'] ['password']) && $ autore ['Autore'] ['password'] == md5 ($ this-> dati ['Autore'] ['password'] )) $ this-> Session-> write ('Author', $ author ['Author']); $ this-> redirect ('/'); else $ this-> set ('error', true); La nostra funzione di indice è piuttosto semplice. Per ora, ci limiteremo a reindirizzare all'indice degli script utilizzando una funzione CakePHP integrata denominata "redirect".
La nostra funzione di login è un po 'più avanzata. Per prima cosa impostiamo la variabile error su false per impedire a PHP di respingere una variabile non definita. Quindi facciamo un controllo per vedere se qualche dato è stato inviato. "$ this-> data" contiene tutti i dati di input dal modulo di accesso e viene fornito nel formato $ this-> data ['CONTROLLER'] ['FIELD']. Ora vediamo il nostro metodo magico "findByUsername". utilizzato per trovare le righe che contengono il nome utente dell'utente che ha appena effettuato l'accesso. Se disponiamo di una corrispondenza utente, confrontiamo le password e scriviamo una sessione utilizzando il gestore di sessione di CakePHP. Se c'è un problema, impostiamo "error" su true, quindi la nostra vista può gestire il messaggio. Un sistema di accesso non può essere molto più semplice di così!
function logout () $ this-> Session-> delete ('Autore'); $ this-> flash ('Sei stato disconnesso.', '/'); La funzione di logout è ancora più semplice. Usiamo la classe di sessione di CakePHP per cancellare completamente la sessione, e quindi usiamo il metodo "flash" per reindirizzare. Il metodo flash è leggermente diverso dal metodo di reindirizzamento perché è consentito inviare un messaggio sullo schermo. Questo diventa utile perché possiamo effettivamente far sapere agli utenti che qualcosa è successo.
Nota: poiché siamo ancora in modalità di sviluppo, lo schermo del flash non reindirizzerà automaticamente. È necessario fare clic sul testo per andare allo schermo. Quando siamo in modalità di produzione, questa schermata reindirizza per noi.
function manage () $ this-> set ('error', false); if (vuoto ($ this-> data)) $ this-> Author-> id = $ this-> Session-> read ('Author.id'); $ this-> data = $ this-> Author-> read (); else if (vuoto ($ this-> data ['Author'] ['name']) || vuoto ($ this-> data ['Author'] ['email']) || vuoto ($ this- > data ['Author'] ['bio'])) $ this-> set ('error', true); $ this-> Author-> id = $ this-> Session-> read ('Author.id'); $ this-> data = $ this-> Author-> read (); else $ this-> Autore-> id = $ this-> Session-> read ('Author.id'); if ($ this-> Author-> save ($ this-> data ['Author'])) $ this-> flash ('Le informazioni del tuo account sono state aggiornate.', '/ authors / manage /'); La nostra funzione più avanzata per questo controller è il gestire funzione. Molte delle funzionalità sono implementate utilizzando le tecniche appena introdotte. Una cosa da notare in questa funzione è l'impostazione della variabile $ this-> author-> id prima del salvataggio e della lettura. Questo indica al modello quale riga gestire, in modo che non provi a salvare o inserire un'intera nuova riga. Ci occupiamo anche di più funzionalità di sessione leggendo l'id dall'hash.
Il nostro ultimo passo è proteggere la pagina di gestione. Vogliamo solo che gli utenti loggati visualizzino questa pagina e possiamo fornire protezione con una semplice funzione di controllo. Questa è una parte delle funzionalità di cui avremo bisogno anche per gli schermi futuri, quindi dovremmo memorizzarla in un luogo condiviso. Come accennato in precedenza, tutti i controller CakePHP ereditano da un controller chiamato "AppController" che al momento è un file vuoto seduto nel torta directory ...
Creeremo un appController specifico per l'applicazione creando un file denominato "app_controller.php" nel app / cartella e inserire i seguenti contenuti:
Session-> check ('Author')) $ this-> flash ('Devi essere loggato per farlo.', '/ Authors / login'); Uscita; ?> Controlliamo semplicemente la sessione e, se non è presente, inviamo l'utente alla schermata di accesso. Questa funzione può ora essere utilizzata in qualsiasi metodo di controller.
Il nostro ultimo passo è chiamare la funzione dalla nostra funzione di gestione. Apriamo il nostro app / regolatore / authors_controller.php file e trova:
function manage () $ this-> set ('error', false); e aggiungi
$ This-> isLoggedIn ();
proprio sotto di esso.
Le azioni possono essere testate e accessibili con i seguenti URL:
Il nome utente dell'account è test e la password è test.
Questo articolo ha lo scopo di introdurre alcune funzioni core di CakePHP con esempi nel contesto della creazione di un'applicazione per blog personale. Abbiamo iniziato con alcune funzionalità della pagina utente / autore per introdurre i concetti di base dello sviluppo di applicazioni con CakePHP prima di passare (nel prossimo tutorial) alla scrittura del post controller. In questo modo avremo una migliore comprensione di come tutto nel quadro si adatta insieme. Abbiamo ancora una lunga strada da percorrere prima che la nostra applicazione per il blog sia completa, quindi preparati a immergerti in profondità in CakePHP in modo che possiamo ottenere tutte le funzionalità di post e commenti del blog che funzionano la prossima volta!
