Ammettiamolo: tutti abbiamo grandi idee per un'applicazione web. Sia che tu li scriva sulla carta o li ricordi usando la tua memoria eidetica, arriva un momento in cui vuoi testare se la tua idea è davvero valida.

In questo tutorial, utilizzeremo un micro framework, un linguaggio di template e un ORM per sviluppare rapidamente un prototipo di applicazione.

Passaggio 1: Introduzione e installazione

Abbiamo tutti avuto questa sensazione. Sai, quello in cui sai di avere una grande idea di applicazione web, solo che non hai il tempo di creare un prototipo veloce e testare l'idea funzionerà davvero. Usando un micro framework, un linguaggio di template e un ORM, potresti averlo installato e funzionante in pochi minuti.

Per questo tutorial, utilizzeremo l'eccellente micro framework Slim, il linguaggio dei modelli Twig e il leggero fluente ORM Paris e Idiorm. La nostra applicazione di esempio sarà un blog. Probabilmente hai già creato un blog, ma siamo qui per conoscere i micro framework e un blog si adatta bene al progetto!

La prima cosa che vorrai fare è prendere questi pacchetti dai loro rispettivi siti web:

• Slim 1.5.02 (versione stabile)
• Slim Extras
• Twig 1.1
• Parigi e Idiorm

Ora che hai tutti i pacchetti scaricati sul tuo computer, è ora di impostare la struttura della directory. Inseriremo i file nella nostra cartella principale del sito, quindi la cartella del tuo progetto dovrebbe avere il seguente aspetto:

"Non dimenticare di includere il file .htaccess fornito con Slim."

Ora che abbiamo strutturato il nostro progetto, procedi e cancella il contenuto di Slim index.php file - scriveremo il nostro un po 'più tardi. Puoi anche rottamare tutto tranne il TwigView.php file di classe nel pacchetto Slim extras.

Passaggio 2: Bootstrap

Nostro index.php file funzionerà come un bootstrap, il che farà sì che Slim, Twig e Paris e Idiorm lavorino insieme bene. Slim reindirizzerà tutte le richieste alla nostra applicazione qui, verificando la presenza di eventuali route route corrispondenti e quindi inviando la risposta appropriata. Questo file conterrà la nostra intera configurazione e logica dell'applicazione.

La prima cosa che dobbiamo fare è includere tutte le librerie che faranno accadere la magia. Aggiungi il seguente al index.php file di bootstrap:

  
Se tutto va bene, una richiesta alla tua applicazione non dovrebbe assolutamente fare nulla, il che è fantastico!
 
Ora facciamo girare Twig. Usando il pacchetto Slim extras possiamo lasciare che Slim crei un ambiente Twig per noi. Tutto quello che deve sapere è la directory in cui è presente Twig, quindi aggiungiamola nel nostro bootstrap. Inoltre, vai avanti e crea una directory modelli chiamata modelli nella radice del sito mentre ci sei. 
 
 // Configurazione TwigView :: $ twigDirectory = __DIR__. '/ Twig / lib / Ramoscello /';
 
Il prossimo componente nel nostro stack è Parigi e Idiorm, il nostro ORM. Utilizza l'oggetto PDO PHP integrato, quindi puoi usare Postgres o SQLite per il tuo prototipo, ma per questo tutorial useremo MySQL. Assicurati di fornire le credenziali del database appropriate: 
 
 ORM :: configure ( 'mysql: host = localhost; dbname = blog'); ORM :: configure ('username', 'root'); ORM :: configure ( 'password', ");
 
Finalmente, iniziamo a dimagrire. È piuttosto complicato, penso che sarete d'accordo: 
 
 // Inizia Slim. $ app = new Slim (array ('view' => nuovo TwigView));
 
Una parola di avvertimento. Se provi a eseguire la tua applicazione ora, potresti ricevere un errore criptico. Non farti prendere dal panico! Lo risolveremo in un attimo aggiungendo alcune rotte.
 
 
 Passaggio 3: instradamento
 
Aggiungere percorsi in Slim è semplice. Tutto ciò che Slim ha bisogno di sapere è il metodo di richiesta del percorso (es. GET, POST, PUT ecc.) E l'URI a cui rispondere, e come rispondere. Daremo in primo luogo le rotte di base della nostra applicazione e creeremo le budella del prototipo in seguito in questo tutorial.
 
Creiamo prima un itinerario della homepage: 
 
 // Blog Home. $ app-> get ('/', function () use ($ app) );
 
Qui stiamo dicendo a Slim di rispondere a qualsiasi richiesta GET che punta alla radice della nostra app. Il parametro finale di chiusura conterrà infine la logica per generare l'output della pagina.
 
Aggiungiamo un altro percorso per visualizzare un singolo articolo del blog: 
 
 // Blog View. $ app-> get ('/ view / (: id)', funzione ($ id) use ($ app) );
 
Noti la differenza qui? Nel nostro parametro URI, abbiamo aggiunto una lumaca (: Id), che dice a Slim di aspettarsi un valore alla fine dell'URI. 
 
Se hai mai usato un altro framework PHP, probabilmente hai familiarità con questo concetto. Se non lo sei, il nostro esempio corrisponderebbe / View / 1, / View / 2 eccetera. 
 
Abbiamo anche passato questo parametro alla nostra funzione di chiusura, quindi possiamo utilizzarlo anche nella nostra logica applicativa. Si noti come abbiamo anche passato nella nostra variabile applicativa nell'ambito delle chiusure, con il uso affermazione? Questo ci consente di accedere agli interni di Slim, che utilizzeremo per catturare i dati delle richieste e rendere le risposte.
 
Le nostre route di amministrazione dovranno utilizzare diversi metodi di richiesta, quindi aggiungiamoli in: 
 
 // Home dell'amministratore. $ app-> get ('/ admin', function () use ($ app) ); // Aggiungi amministratore. $ app-> get ('/ admin / add', function () use ($ app) ); // Admin Add - POST. $ app-> post ('/ admin / add', function () use ($ app) ); // Modifica amministratore. $ app-> get ('/ admin / edit / (: id)', funzione ($ id) uso ($ app) ); // Modifica amministratore - POST. $ app-> post ('/ admin / edit / (: id)', funzione ($ id) uso ($ app) ); // Admin Elimina. $ app-> get ('/ admin / delete / (: id)', funzione ($ id) uso ($ app) );
 
Noterai che abbiamo alcune rotte POST qui. Successivamente, li useremo per elaborare i moduli nel nostro centro di amministrazione.
 
Infine, dovremmo dire a Slim di eseguire la nostra applicazione.
 
 $ App-> run ();
 
 
 Step 4: Modelli
 
Paris e Idiorm rendono i modelli di costruzione facili da rappresentare per i tuoi dati, così come fa la maggior parte del lavoro dei grunt, che è ottimo per la prototipazione rapida. Conserveremo i nostri modelli in una directory chiamata Modelli, quindi vai avanti e crea quella directory. Al suo interno, crea la base Articolo modello in un file chiamato Article.php:
 
  
Abbastanza semplice, eh? Paris e Idiorm estrarranno tutte le informazioni necessarie dal nome della classe del modello e dalla tabella del database. Mentre ci siamo, dovremmo probabilmente creare il database e aggiungere alcuni dati di esempio: 
 
 CREATE DATABASE 'blog' SET DI CARATTERE DEFAULT utf8 COLLATE utf8_general_ci; USA 'blog'; CREATE TABLE SE NON ESISTE 'article' ('id' int (10) non firmato NOT NULL AUTO_INCREMENT, 'timestamp' datetime NOT NULL, 'title' varchar (128) NOT NULL, 'summary' varchar (128) NOT NULL, 'content 'testo NOT NULL,' author 'varchar (128) NOT NULL, PRIMARY KEY (' id ')) ENGINE = MyISAM DEFAULT CHARSET = utf8; INSERISCI IN "articolo" ("id", "timestamp", "title", "summary", "content", "author") VALUES (1, "2011-07-28 02:03:14", "Hello World ! ',' Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed fa eiusmod tempo incididunt ut labore et dolore magna aliqua. Ut ',' Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed fa eiusmod tempor incididunt ut labore et dolore magna alieno, niente di meno, niente esercizio fisico, niente male, niente paura, niente di meglio, come direi, come direi, come direi, come direi, come direi, come direi, come direi. Deserunt mollit anim id est laborum. ',' Mr White '), (2,' 2011-07-28 02:03:14 ',' Altro Hello World! ',' Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed il tuo tempo è incididunt ut labore et dolore magna aliqua. Ut ',' Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. ',' Mr Green ');
 
Infine, poiché utilizzeremo il modello Article in ogni pagina, lo includeremo nel nostro bootstrap, subito dopo aver caricato le nostre librerie: 
 
 // I modelli richiedono "models / Article.php";
 
 
 Passaggio 5: Front End dell'applicazione
 
Ora che abbiamo tracciato tutti i nostri percorsi applicativi e configurato i nostri modelli, è ora di iniziare a costruire alcune pagine. Il nostro front end del blog sarà piuttosto semplice, con un elenco di tutti gli articoli del blog e una pagina per visualizzare i singoli articoli.
 
Utilizzando l'interfaccia fluida collegabile che Paris e Idiorm forniscono, possiamo rapidamente costruire query di database, senza scrivere alcun SQL grezzo. Tiriamo fuori tutti gli articoli per la homepage usando la chiusura del percorso: 
 
 $ articles = Model :: factory ('Article') -> order_by_desc ('timestamp') -> find_many ();
 
Iniziamo chiamando il metodo factory model, che distribuirà un oggetto modello del tipo Articolo. Da qui, abbiamo un'interfaccia fluente, il che significa che possiamo concatenare i nostri comandi insieme. Qui, stiamo ottenendo tutti gli articoli nel database, ordinati in base al loro timestamp, in ordine decrescente, e poi dicendo a Parigi che vogliamo molti articoli restituiti. Il risultato di questa query è un array di oggetti del modello Article.
 
Per visualizzare i nostri risultati nel browser, dobbiamo eseguire il rendering di un modello. Slim fornisce un semplice metodo di rendering per farlo. Il primo parametro è il template da renderizzare, e il secondo parametro è un array associativo di dati da rendere disponibili al template, che nel nostro caso è il nostro oggetto article.
 
 return $ app-> render ('blog_home.html', array ('articoli' => $ articoli));
 
Scriveremo i nostri modelli usando Twig, che fornisce una struttura di tag pulita e semplice con caratteristiche di ereditarietà che possiamo usare per impaginare facilmente una pagina web senza usare PHP. Questo è ottimo per la creazione di prototipi, poiché significa concentrarsi sulla definizione dell'output della pagina, invece di guado attraverso codice spaghetti PHP e HTML mescolati.
 
Abbiamo bisogno di un file di layout di base - un file HTML di base nella cartella dei modelli chiamato layout.html andrà bene.
 
        % block content% % endblock%  
 
Notare i tag del blocco Twig? I blocchi sono denominati regioni che è possibile popolare con il contenuto. Inseriremo questi blocchi nei nostri modelli di pagina individuali.
 
Ecco un rapido corso accelerato su Twig per farti andare. 
 
Qualsiasi variabile o espressione all'interno  è automaticamente sfuggito ed echeggiato, mentre il %% i tag consentono di utilizzare istruzioni execute come ifals condizionali o per cicli.
 
Camminiamo però creando il modello di homepage del blog passo dopo passo. Non dimenticare di creare un nuovo modello chiamato blog_home.html nella cartella dei modelli.
 
La prima cosa che vogliamo che il nostro modello faccia è estendere il nostro layout. Il si estende tag consente a Twig di sapere che il nostro modello erediterà dal layout.html file: 
 
 % estende 'layout.html'%
 
Ora, possiamo utilizzare la stessa sintassi del blocco utilizzata in precedenza per popolare il nostro layout. Imposta il titolo della pagina: 
 
 % block page_title% Il mio blog % endblock%
 
Twig popolerà il titolo della pagina regione nel layout, con ciò che abbiamo definito nel nostro modello. Per illustrare ulteriormente la potenza di Twig, creiamo il blocco del contenuto e utilizziamo alcune altre funzionalità di Twig: 
 
 % block content% % per article in articles% % else% 
Al momento non ci sono articoli.
 % endif% % endblock%
 
Ricorda che abbiamo passato la nostra matrice di articoli recuperati al nostro modello in precedenza? Questo è ora disponibile nel modello con il nome articoli. Usando i tag logici di Twigs, passiamo attraverso il articoli variabile per verificare se esiste e se non lo fa, lanciamo un messaggio di avviso educato. Consolidiamo a per ciclo e altro condizionale in un set di tag per gestire facilmente un array vuoto.
 
Mostriamo un elenco di articoli del blog sulla home page per familiarizzare con la sintassi di loop e variabile di Twig: 
 
 % block content% % per article in articles% 
article.title di article.author
 
article.summary
 % altro % 
Al momento non ci sono articoli.
 % endfor% % endblock%
 
La sintassi del ciclo for è l'opposto dell'istruzione foreach di PHP: utilizziamo semplicemente la parola chiave nel, invece di come. Questo scorre attraverso la nostra gamma di articolo oggetti, rendendoli disponibili come variabile articolo all'interno del ciclo.
 
All'interno del ciclo, usiamo il  tag, che echeggeranno un valore di escape. Sì, Twig sfugge automaticamente all'output, quindi non più scrivere htmlentities ()! Accediamo anche al nostro attributo titolo articoli usando un punto (.) notazione, invece della solita freccia PHP (->). Se hai scritto Javascript o Python, dovresti avere familiarità con alcune di queste sintassi.
  
Quindi, ora che abbiamo preparato la nostra homepage di base, creiamo una visione dettagliata.
 
 // Blog View. $ app-> get ('/ view / (: id)', funzione ($ id) usa ($ app) $ article = Model :: factory ('Article') -> find_one ($ id); if (! $ article instanceof Article) $ app-> notFound (); return $ app-> render ('blog_detail.html', array ('article' => $ article)););
 
Usando Parigi, possiamo rapidamente prendere un articolo dal suo ID usando il trova uno() metodo. Se no Articolo l'istanza dell'oggetto viene restituita, diciamo all'applicazione Slim che la pagina non è stata trovata, che attiverà automaticamente un errore 404.
 
Se l'articolo viene trovato, lo passiamo al nostro modello di dettaglio, che appare come segue:
 
 % estende 'layout.html'% % block page_title% article.title % endblock% % block content% 
 titolo dell'articolo 
 
Pubblicato: article.timestamp | date ('jS F Y') di article.author
 
article.content
 
Torna alla homepage
 % endblock%
 
Usando i filtri integrati di Twigs, possiamo accedere ad alcune funzioni PHP di base, come ad esempio Data() nei nostri modelli. L'attributo della classe article.timestamp viene automaticamente assegnato al nostro filtro data come primo parametro e la nostra stringa formato data diventa il secondo parametro.
  
Ora abbiamo un front end funzionante, anche se semplice, ma non ha tardato a farlo funzionare. Parigi rende davvero facile concentrarsi sul prelievo dei dati dal database e, come vedremo durante la creazione del nostro centro di amministrazione, semplifica l'inserimento e l'aggiornamento dei record.
 
 
 Passaggio 6: Fine applicazione
 
Lavoriamo su un centro di amministrazione per il nostro blog, che struttureremo sotto l'URI / admin. Visto che abbiamo già configurato tutti i percorsi, scriviamo la logica per la pagina principale del centro di amministrazione. Sarà identico alla nostra pagina di elenco principale del blog, quindi il codice sotto dovrebbe essere completo: 
 
 // Home dell'amministratore. $ app-> get ('/ admin', function () usa ($ app) $ articles = Model :: factory ('Article') -> order_by_desc ('timestamp') -> find_many (); restituisce $ app- > render ('admin_home.html', array ('articoli' => $ articoli)););
 
Utilizzeremo un semplice layout di tabella con link di azione per aggiungere, modificare ed eliminare gli articoli del blog.
 
Hai già familiarità con il funzionamento del sistema di aree di blocco in Twig, quindi concentriamoci sul nostro blocco di contenuti: 
 
 % block content% 
My Blog Administration
 
Aggiungi articolo
 % se articoli%  % per articolo negli articoli%  % endfor% 
 
 
 
Titolo
 
Data
 
Autore
 
Azioni
 
 
 
 
 titolo dell'articolo 
 
article.author
 
article.timestamp | date ('jS F Y')
 
modificare
 
Elimina
 
 
 % altro % 
Al momento non ci sono articoli.
 % endif% % endblock%
 
In questo modello, stiamo usando il % se% % else% % endif% logica. Non vogliamo visualizzare il markup della tabella se non ci sono articoli, quindi controlliamo la sua esistenza prima di decidere cosa visualizzare. Stiamo anche utilizzando il filtro data  di nuovo il metodo, che penso che sarete d'accordo è abbastanza pulito e leggibile.
  
Il Main Admin Center
 
Passiamo alla vera carne del nostro centro amministrativo: manipolare il contenuto. Ciò di cui abbiamo bisogno è un modulo che contenga tutti i campi di cui abbiamo bisogno per aggiungere e modificare il nostro articolo. Fortunatamente Twig supporta partial parziali riutilizzabili, quindi creiamo un partial chiamato in forma article_form.html:
 
 
 
action_name Articolo
 
 Titolo: 
  
 
 Autore: 
  
 
 Sommario: 
 article.summary | default ('') 
 
 Soddisfare: 
 article.content | default ('') 
 
  
 
 
Un partial è semplicemente un modello riutilizzabile, può ancora contenere la logica standard di Twig. Nel nostro modello di modulo, usiamo il predefinito filtro, che emette un valore predefinito se la variabile che sta filtrando è vuota o inesistente. Nel caso dei nostri campi modulo, emetteremo una stringa vuota se nessuno degli attributi dell'articolo è presente. Ci aspettiamo anche due variabili per rendere il nostro modulo parziale attivo e funzionante. Il primo ha chiamato nome_azione descrive semplicemente l'azione del modulo per i nostri utenti (I.e. Aggiungi o Modifica) e il secondo action_url è usato come azione del modulo.
 
Sicuramente avrai notato come la logica di questa pagina sia suddivisa in due percorsi, uno per GET e uno per POST, il che significa che dovremo scrivere una funzione per gestire ciascun metodo. Il nostro percorso GET ha solo bisogno di rendere la pagina - niente di troppo complicato. Diremo semplicemente a Twig di eseguire il rendering di un nuovo modello: 
 
 // Aggiungi amministratore. $ app-> get ('/ admin / edit / (: id)', function ($ id) return $ app-> render ('admin_input.html', array ('action_name' => 'Aggiungi', 'action_url '=>' / admin / add '))););
 
Passiamo le due variabili previste dal nostro modulo parziale nel modello. A proposito, lasciatemi spiegare come usare il parziale nel nostro admin_input.html modello: 
 
 % include 'article_form.html'%
 
Sono sicuro che probabilmente hai immaginato che sarebbe stato così semplice, e lo è davvero. Abbiamo solo bisogno di includere il partial all'interno di una delle nostre regioni di blocco di Twig, e poi apparirà. Avrà anche accesso a tutte le variabili nell'ambito del suo modello principale (ad esempio le due variabili che abbiamo passato). Twig ha alcuni grandi controlli di ambito variabile e funzionalità di sicurezza sandbox, ma è meglio conservarli per un altro giorno.
 
Il nostro modello di input finale è piuttosto semplice (vedi sotto) e funzionerà bene anche quando costruiremo i nostri controlli di modifica. Suppongo che ti stia chiedendo perché ci siamo preoccupati di un parziale nel primo caso, se entrambi i nostri moduli di aggiunta e modifica utilizzeranno lo stesso modello. Il motivo è perché rende riutilizzabile la forma altrove durante la prototipazione di una vera brezza da fare, se necessario.
 
 % estende 'layout.html'% % block page_title% action_name Articolo % endblock% % block content% % include 'article_form.html'% % endblock%
  
Aggiungi un modulo articolo
 
Lavoriamo su quella rotta POST. Quello che dobbiamo fare è prendere i dati inviati e conservarli all'interno di un oggetto articolo. Non ci preoccupiamo di controllare gli errori nel nostro esempio poiché stiamo solo approssimativamente prototipando la nostra idea. Otterremo Parigi per dispensare, o creare, un nuovo articolo oggetto: 
 
 $ article = Model :: factory ('Article') -> create ();
 
Ora possiamo andare avanti con la compilazione dell'articolo dai dati pubblicati. Raccoglieremo i dati POST dal nostro oggetto applicazione Slim, che fornisce un metodo di supporto pratico tramite il suo oggetto richiesta: 
 
 $ article-> title = $ app-> request () -> post ('title'); $ article-> author = $ app-> request () -> post ('author'); $ article-> summary = $ app-> request () -> post ('summary'); $ article-> content = $ app-> request () -> post ('content'); $ article-> timestamp = date ('Y-m-d H: i: s');
 
Parigi si prende cura di sfuggire a tutti i nostri input durante il salvataggio, il che è utile se dovessi decidere di mettere in scena il tuo prototipo affinché altri possano accedervi. Tutto ciò che dobbiamo fare ora è dire a Parigi di salvare il record.
 
 $ Articolo-> save ();
 
Infine diciamo alla nostra applicazione Slim di riportarci alla pagina principale della dashboard dell'amministratore usando il reindirizzare metodo di supporto: 
 
 $ App-> redirect ( '/ admin');
 
Nel nostro metodo GET di modifica del percorso, che è semplicemente una fusione delle cose che abbiamo imparato dalla costruzione della pagina dei dettagli del nostro blog e della nostra pagina di aggiunta dell'amministratore. Per prima cosa, dobbiamo caricare l'articolo che stiamo modificando, recuperando il record con Parigi: 
 
 $ article = Model :: factory ('Article') -> find_one ($ id); if (! $ article instanceof Article) $ app-> notFound (); 
 
Parigi invia un'istanza di un oggetto dell'articolo che corrisponde all'ID del record dell'articolo ricevuto nella nostra chiusura, oppure falso se non esiste nessuno. Controlliamo quindi se abbiamo un'istanza indietro, se non diciamo a Slim di lanciare un errore 404.
 
Ora diciamo a Slim di rendere il modello di input, come nel nostro percorso di aggiunta, ma passando l'oggetto dell'articolo caricato e l'URL di azione corretto: 
 
 return $ app-> render ('admin_input.html', array ('action_name' => 'Edit', 'action_url' => '/ admin / edit /'. $ id, 'article' => $ article));
 
Il nostro percorso di modifica POST funziona quasi identico a Inserisci route, con l'eccezione che dobbiamo controllare se l'articolo può essere caricato prima di andare avanti e aggiornare i suoi attributi: 
 
 $ article = Model :: factory ('Article') -> find_one ($ id); if (! $ article instanceof Article) $ app-> notFound ();  $ article-> title = $ app-> request () -> post ('title'); $ article-> author = $ app-> request () -> post ('author'); $ article-> summary = $ app-> request () -> post ('summary'); $ article-> content = $ app-> request () -> post ('content'); $ article-> timestamp = date ('Y-m-d H: i: s'); $ Articolo-> save (); $ App-> redirect ( '/ admin');
 
Concluderemo il nostro centro di amministrazione costruendo il percorso di cancellazione. Lo faremo innanzitutto recuperando il record, in modo simile a come facevamo in precedenza nella nostra pagina dei dettagli del blog: 
 
 $ article = Model :: factory ('Article') -> find_one ($ id);
 
Se Parigi ha caricato un articolo, dobbiamo cancellarlo, quindi rimandare l'utente alla pagina principale dell'amministratore. Parigi rende l'eliminazione di un record il più semplice possibile: 
 
 if ($ article instanceof Articolo) $ article-> delete ();  $ app-> redirect ('/ admin');
 
E con questo il nostro centro di amministrazione prototipo di base è finito.
 
 
 Passaggio 7: utilizzo del middleware
 
Il nostro centro amministrativo è ora completato. È piuttosto semplice dato che è solo un prototipo, ma vogliamo ancora una qualche forma di autorizzazione per proteggerlo da sguardi indiscreti. Slim ci consente di inserire il middleware nei nostri percorsi. Ciò significa che siamo in grado di creare funzioni che vengono chiamate prima che la chiusura della risposta dei percorsi venga eseguita.
 
Possiamo utilizzare l'autenticazione di base HTTP per proteggere il nostro centro di amministrazione. Ovviamente, useremmo qualcosa di un po 'più sicuro in un sito live, ma per il nostro prototipo questo va bene. In cima al nostro index.php creiamo due costanti che contengono il nostro nome utente e password: 
 
 // Dettagli dell'autore. define ('USERNAME', 'admin'); define ('PASSWORD', 'password');
 
Dopo aver creato la nostra istanza dell'applicazione Slim, creeremo una chiusura, che legheremo a una variabile per mantenere il controllo del middleware delle autorizzazioni: 
 
 // Verifica autenticazione. $ authCheck = function () use ($ app) ;
 
Se non hai mai usato HTTP Basic Auth in PHP, è davvero facile. Possiamo usare il $ _SERVER array per verificare quali credenziali sono state inviate dal browser web dell'utente e confrontarle con le nostre costanti. Lo faremo all'interno della nostra chiusura appena creata. La prima cosa che dobbiamo fare nella nostra funzione di controllo dell'autorizzazione è scoprire se sono state inviate eventuali credenziali di autenticazione e, in caso affermativo, verificare se corrispondono alle nostre costanti: 
 
 $ authRequest = isset ($ _ SERVER ['PHP_AUTH_USER'], $ _SERVER ['PHP_AUTH_PW']); $ authUser = $ authRequest && $ _SERVER ['PHP_AUTH_USER'] === USERNAME; $ authPass = $ authRequest && $ _SERVER ['PHP_AUTH_PW'] === PASSWORD;
 
Tutto quello che stiamo facendo qui è controllare se i valori auth esistono e corrispondono, quindi memorizzare i risultati in alcune variabili. Supponendo che una di queste variabili sia falsa, sappiamo che è necessario chiedere all'utente di autorizzarsi:
 
 if (! $ authUser ||! $ authPass) $ app-> response () -> header ('WWW-Authenticate: Basic realm = "My Blog Administration"', ''); $ app-> response () -> header ('HTTP / 1.1 401 Unauthorized', ''); $ App-> risposta () -> corpo ('
Inserisci le credenziali di amministrazione valide
'); $ App-> risposta () -> send (); Uscita; 
 
Controlliamo se le nostre credenziali di autenticazione sono a posto. Se non lo sono, inviamo una risposta con le intestazioni appropriate e il messaggio di avviso. Come hai visto prima, potevamo accedere all'oggetto di richiesta del framework Slim per ottenere l'accesso ai nostri dati POST. Possiamo anche accedere all'oggetto di risposta interno, che ci facilita l'inserimento delle intestazioni e la sovrascrittura del corpo dell'oggetto di risposta Slim con un semplice messaggio di avviso HTML, prima di forzare lo script ad uscire.
 
In Slim è possibile aggiungere più callables a un percorso e vengono eseguiti nell'ordine in cui sono specificati. Ciò significa che possiamo facilmente impedire l'accesso a tutti i nostri percorsi aggiungendo la chiusura del controllo dell'autorizzazione prima della chiusura della risposta: 
 
 // Home dell'amministratore. $ app-> get ('/ admin', $ authCheck, function () use ($ app) //?); // Aggiungi amministratore. $ app-> get ('/ admin / add', $ authCheck, function () usa ($ app) //?); // Admin Add - POST. $ app-> post ('/ admin / add', $ authCheck, function () use ($ app) //?); // Modifica amministratore. $ app-> get ('/ admin / edit / (: id)', $ authCheck, funzione ($ id) usa ($ app) //?); // Modifica amministratore - POST. $ app-> post ('/ admin / edit / (: id)', $ authCheck, funzione ($ id) uso ($ app) //?); // Admin Elimina. $ app-> get ('/ admin / delete / (: id)', $ authCheck, funzione ($ id) uso ($ app) //?);
 
E lì ce l'hai, il nostro centro amministrativo ora è protetto. Chiunque tenti di accedervi vedrà un messaggio di avviso e verrà richiesto di fornire le credenziali.
  
 
 Passaggio 8: riepilogo
 
Speriamo che questo tutorial ti abbia mostrato quanto sia facile e veloce ottenere un prototipo attivo e funzionante con un micro framework, un ORM e un linguaggio modello, pur mantenendo una buona separazione tra preoccupazioni e codice leggibile.
 
Un potente linguaggio per i template può impedire che le tue viste finiscano come un mix di codice spaghetti PHP e HTML illeggibile, e come un ORM scorrevole possa rendere noiose e noiose azioni CRUD veloci e indolori.
 
Queste sono solo alcune delle molte cose interessanti che puoi fare con Slim, Twig e Paris. Se approfondisci ulteriormente, puoi aggiungere relazioni ai tuoi modelli con Paris, aggiungere snippet di macro in Twig per accelerare lo sviluppo dei modelli e utilizzare il routing basato su nome con Slim per rendere più semplice il collegamento tra i contenuti del tuo sito web e la modifica degli URL..
 
Felice prototipazione e grazie mille per la lettura!



		
			
	   
	




Codice