Să recunoaștem: avem cu toții idei grozave pentru o aplicație web. Fie că le scrieți pe hârtie, fie că vă amintiți-le folosind memoria dvs. eidetică, vine un punct când doriți să testați dacă ideea dvs. este sau nu viabilă.

În acest tutorial, vom folosi un cadru micro, o limbă templantă și un ORM pentru a dezvolta rapid un prototip de aplicație.

Pasul 1: Introducere și configurare

Toți aveam acest sentiment. Știți, de unde știți că aveți o idee minunată de aplicații web, doar că nu aveți timp să bateți un prototip rapid și să testați că ideea va funcționa cu adevărat. Folosind un cadru micro, o limbă templantă și un ORM, ai putea să îl ai în funcțiune în câteva minute.

Pentru acest tutorial, vom folosi excelenta cadru micro Slim, limba creatoare Twig si fluentul fluent ORM Paris si Idiorm. Aplicația noastră de probă va fi un blog. Probabil că ați construit un blog, dar suntem aici pentru a afla despre cadrele micro și un blog se potrivește perfect cu proiectul de lege!

Primul lucru pe care veți dori să-l faceți este să apucați aceste pachete de pe site-urile lor respective:

• Slim 1.5.02 (Release Stabil)
• Slim Extras
• Twig 1.1
• Paris și Idiorm

Acum că aveți toate pachetele descărcate pe computer, este timpul să vă configurați structura directorului. Vom plasa fișierele în dosarul rădăcină al site-ului nostru, astfel încât dosarul proiectului să arate astfel:

"Nu uitați să includeți fișierul .htaccess care vine cu Slim."

Acum, că am structurat proiectul nostru, continuați și ștergeți conținutul produsului Slim index.php fișier - ne vom scrie un pic mai târziu. Puteți, de asemenea, elimina orice altceva decât TwigView.php fișier de clasă în pachetul Slim extras.

Pasul 2: Îndepărtarea

Al nostru index.php fișierul va acționa ca un bootstrap, care va primi Slim, Twig și Paris și Idiorm toate lucrează împreună frumos. Slim va redirecționa toate cererile la aplicația noastră aici, verificând pentru orice tipare de traseu potrivită și apoi expediând răspunsul corespunzător. Acest fișier va conține, în cele din urmă, întreaga setare a aplicației și logică.

Primul lucru pe care trebuie să-l facem este să includeți toate bibliotecile care vor face magia să se întâmple. Adăugați următoarele la index.php fișier bootstrap:

  
Dacă totul merge bine, o cerere la cererea dumneavoastră ar trebui să facă absolut nimic, ceea ce este minunat!
 
Acum să lăsăm pe Twig să se ducă în fugă. Folosind pachetul Slim extras putem lăsa Slim să configureze un mediu Twig pentru noi. Tot ce trebuie să știe este directorul în care se află Twig, așa că să adăugăm asta în bootstrapul nostru. De asemenea, mergeți mai departe și creați un director de șabloane numit template-uri în rădăcina site-ului în timp ce sunteți la el. 
 
 // Configurație TwigView :: $ twigDirectory = __DIR__. '/ Twig / lib / crenguță /';
 
Următoarea componentă din stackul nostru este Parisul și Idiorm, ORM-ul nostru. Utilizează obiectul PHP PDO încorporat, astfel încât să puteți utiliza Postgres sau SQLite pentru prototipul dvs., dar pentru acest tutorial vom folosi MySQL. Asigurați-vă că îi dați acreditările corespunzătoare ale bazei de date: 
 
 ORM :: Configure ( 'mysql: host = localhost; dbname = blog-ul'); ORM :: configure ('username', 'root'); ORM :: Configure ( 'parola', ");
 
În sfârșit, să lăsăm Slim să funcționeze. Este destul de complicat, cred că veți fi de acord: 
 
 // Start Slim. $ app = nou Slim (array ('view' => new TwigView));
 
Un cuvânt de avertizare. Dacă încercați să executați aplicația acum, este posibil să primiți o eroare criptică. Nu vă panicați! Vom rezolva asta într-un moment prin adăugarea unor rute.
 
 
 Pasul 3: Rutarea
 
Adăugarea de rute în Slim este simplă. Toate cele Slim trebuie să știe este metoda de solicitare a traseului (de exemplu, GET, POST, PUT etc) și URI pentru a răspunde și cum să răspundă. Vom crea mai întâi rutele principale ale aplicației noastre și vom crea mai departe curajul prototipului în acest tutorial.
 
Să creați mai întâi un traseu inițial: 
 
 // Pagina de pornire a blogului. $ app-> get ('/', funcția () utilizează ($ app) );
 
Aici îi spunem lui Slim să răspundă la orice solicitare GET indicată la baza aplicației noastre. Parametrul final de închidere va conține eventual logica pentru a genera ieșirea paginii.
 
Să adăugăm un alt traseu pentru vizualizarea unui articol de blog individual: 
 
 // Vizualizare Blog. $ app-> get ('/ view / (: id)', funcția ($ id) folosiți ($ app) );
 
Observați diferența aici? În parametrul nostru URI, am adăugat un slug (: Id), care îi spune lui Slim să aștepte o valoare la sfârșitul URI-ului. 
 
Dacă ați folosit vreodată alt cadru PHP, probabil că sunteți familiarizat cu acest concept. Dacă nu sunteți, exemplul nostru s-ar potrivi / Vizualizare / 1, / Vizualizare / 2 etc. 
 
De asemenea, am trecut acest parametru la funcția de închidere, astfel încât să putem folosi și în logica aplicațiilor noastre. Observați cum am trecut, de asemenea, în variabila noastră de aplicație în domeniul de închidere, cu utilizare afirmație? Acest lucru ne permite să accesăm intervalele Slim, pe care le vom folosi pentru a prelua datele de solicitare și pentru a răspunde.
 
Căile noastre de administrare vor trebui să utilizeze diferite metode de solicitare, deci să le adăugăm în: 
 
 // Admin Home. $ app-> get ('/ admin', funcția () utilizează ($ app) ); // Admin Add. $ app-> get ('/ admin / add', funcția () utilizează ($ app) ); // Admin Add - POST. $ app-> post ('/ admin / add', funcția () utilizează ($ app) ); // Admin Edit. $ app-> get ('/ admin / edit / (: id)', funcția ($ id) utilizează ($ app) ); // Admin Edit - POST. $ app-> post ('/ admin / edit / (: id)', funcția ($ id) utilizează ($ app) ); // Admin Delete. $ app-> get ('/ admin / delete / (: id)', funcția ($ id) folosiți ($ app) );
 
Veți observa că avem câteva rute POST aici. Mai târziu, le vom folosi pentru a procesa formulare în centrul nostru de administrare.
 
În cele din urmă, mai bine ar trebui să-i spunem lui Slim să ne execute cererea.
 
 $ App-> run ();
 
 
 Pasul 4: Modele
 
Paris și Idiorm fac modelele de clădiri să reprezinte datele dvs. ușoare, deoarece efectuează cea mai mare parte a lucrărilor de grămadă, ceea ce este excelent pentru prototipuri rapide. Vom păstra modelele noastre într-un director numit modele, deci mergeți mai departe și creați acel director. În interior, creați baza Articol model într-un fișier numit Article.php:
 
  
Destul de simplu, nu? Paris și Idiorm vor extrage toate informațiile de care are nevoie de la numele claselor de modele și din tabelele bazei de date. În timp ce suntem la el, ar trebui să creăm baza de date și să adăugăm câteva date de probă: 
 
 CREAȚI DATABASE 'blog' DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci; USE 'blog'; CREATE TABLE DACĂ NU EXISTĂ "articol" ('id' int (10) nesemnate NOT NULL AUTO_INCREMENT, 'timestamp' datetime NOT NULL, 'title' varchar (128) NOT NULL, 'text NOT NULL,' autor 'varchar (128) NOT NULL, KEY PRIMARY (' id ')) ENGINE = MyISAM DEFAULT CHARSET = utf8; INSERT IN 'articol' ('id', 'timestamp', 'title', 'summary', 'content', 'author') VALOES (1, '2011-07-28 02:03:14' ! ',' Lorem ipsum dolor stați amet, consecutiv de adipiscare elit, sed do eiusmod temporal incididente în labore și dolore magna aliqua.Ut ',' Lorem ipsum dolor stau amet, consectetur adipisicing elit, sed do eiusmod temporal incididunt ut labore et dolore magna aliqua.Ut enim ad minim veniam, quis exerciții ullamco laboris nisi ut aliquip ex ei commodo consequat .Dais aute irure dolor în reprehendit în voluptate comandă esse cillum dolore eu fugiat nulla pariatur.Excepție sint occaecat cupidatat non proident, sunt în culpa qui officia (2, '2011-07-28 02:03:14', 'Mai mult Hello World!', 'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed a se vedea tema de incidenta a muncii si a dolorei magna aliqua. Ut ',' Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt lucrați și păstrați magna aliqua. Ut enim ad minim veniam, quis exerciții de muncă ultima lucrătoare aliquip ex a commodo consequat. Duis aute irure dolor în republicarea în voluptate comandă esse cillum dolore eu fugiat nulla pariatur. Cu excepția cazului în care nu există un prozident, sunt în culpa qui officia desertuit molit anim id est laborum. "," Domnul Green ");
 
În sfârșit, pe măsură ce vom folosi modelul Articol în fiecare pagină, îl vom include în bootstrap-ul nostru, imediat după ce am încărcat bibliotecile noastre: 
 
 // Modelele necesită 'modele / Article.php';
 
 
 Pasul 5: Frontul aplicației
 
Acum, că avem rutele noastre de aplicații toate proiectate și modelele noastre configurate, este timpul să începem să construim câteva pagini. Partea frontală a blogului nostru va fi destul de simplă, cu o listă a tuturor articolelor de pe blog și o pagină pentru a vedea articole individuale.
 
Folosind interfața fluentă în lanț, Paris și Idiorm oferă posibilitatea de a construi rapid interogări baze de date, fără a scrie nici un SQL brut. Să eliminăm toate articolele pentru pagina de pornire utilizând închiderea rutei: 
 
 $ articles = Model :: fabrică ('Articol') -> order_by_desc ('timestamp') -> find_many ();
 
Începem prin apelarea metodei din fabrica de model, care va distribui un obiect model de tip Articol. De aici, avem o interfață fluentă, ceea ce înseamnă că ne putem alinia comenzile împreună. Aici, primim toate articolele din baza de date, ordonate după timestampul lor, în ordine descrescătoare, iar apoi spunând Parisului că vrem să ne întoarcem multe articole. Rezultatul acestei interogări este o serie de obiecte model de articol.
 
Pentru ca rezultatele să apară în browser, trebuie să redați un șablon. Slim oferă o metodă de randare simplă pentru a face acest lucru. Primul parametru este șablonul de a face, iar al doilea parametru este o matrice asociativă de date care trebuie să fie puse la dispoziția șablonului, care în cazul nostru este obiectele noastre de articol.
 
 retur $ app-> render ('blog_home.html', array ('articole' => $ articole));
 
Vom scrie șabloanele noastre utilizând Twig, care oferă o structură de etichete curată și simplă cu caracteristici de moștenire pe care le putem folosi pentru a structura cu ușurință o pagină Web fără a utiliza niciun PHP. Acest lucru este minunat pentru prototipuri, deoarece înseamnă concentrarea pe modelarea ieșirii paginii, în loc de a trece prin codul de spaghetti PHP și HTML amestecat.
 
Avem nevoie de un fișier de aspect de bază - un fișier HTML de bază în dosarul șabloanelor numit layout.html se va face.
 
        % conținutul blocului% % endblock%  
 
Observați etichetele blocului Twig? Blocurile sunt numite regiuni pe care le puteți popula cu conținut. Vom popula aceste blocuri în șabloanele noastre individuale de pagină.
 
Iată un curs rapid de prăbușire pe Twig pentru a te duce. 
 
Orice variabilă sau expresie în cadrul  este scos automat și repetat, în timp ce %% Etichetele vă permit să utilizați instrucțiuni de executare, cum ar fi dacă sunt altceva condiționate sau pentru bucle.
 
Hai să mergem prin crearea șablonului de pagină de blog pe blog. Nu uitați să creați un nou șablon numit blog_home.html în directorul de șabloane.
 
Primul lucru pe care dorim să-l facem este să ne extindem aspectul. extinde eticheta permite Twig să știe șablonul nostru va moșteni de la layout.html fişier: 
 
 % extends 'layout.html'%
 
Acum, putem folosi aceeași sintaxă de bloc pe care am folosit-o mai devreme pentru a popula aspectul nostru. Să setăm titlul paginii: 
 
 % block page_title% Blogul meu % endblock%
 
Twig va popula titlul paginii regiune în aspect, cu ceea ce am definit în șablonul nostru. Pentru a ilustra mai mult puterea lui Twig, să creăm blocul de conținut și să folosim câteva funcții Twig: 
 
 % conținutul blocului% % pentru articol în articole% % else% 
În prezent nu există articole.
 % endif% (% endblock%
 
Amintiți-vă că am trecut mai devreme matricea articolelor noastre reclamate în șablonul nostru? Acest lucru este acum disponibil în șablon cu numele articole. Folosind etichetele logice Twigs, buclele trec prin articole pentru a verifica dacă există și dacă nu, am expediat un mesaj de avertizare politicos. Noi consolidăm a pentru buclă și altfel condiționată într-un set de etichete pentru a manipula cu ușurință o matrice goală.
 
Să afișăm o listă cu articole de blog de pe pagina de pornire pentru a ne familiariza cu sintaxa de ieșire looping și variabilă a lui Twig: 
 
 % conținutul blocului% % pentru articol în articole% 
article.title de article.author
 
article.summary
 % else% 
În prezent nu există articole.
 % endfor% % endblock%
 
Sintaxa pentru buclă pentru contracte este inversa în declarația de bază a PHP-ului - pur și simplu folosim cuvântul cheie în, in loc de la fel de. Acest lucru trece printr-o serie de noi articol obiecte, făcând fiecare disponibil ca o variabilă numită articol în bucla.
 
În interiorul buclei, folosim  tag-uri, care vor echivala o valoare evadată. Da, Twig scapă automat de ieșirea dvs., deci nu mai scrieți htmlentities ()! De asemenea, accesăm atributul titlul articolelor folosind un punct (.), în loc de săgeata de obicei PHP (->). Dacă ați scris Javascript sau Python, ar trebui să fiți familiarizați cu o parte din această sintaxă.
  
Deci, acum, când ne-am stabilit pagina de pornire de bază, hai să facem cracare în această vedere detaliată.
 
 // Vizualizare Blog. Aplicația $ app-> get ('/ view / (: id)', funcția ($ id) utilizează ($ app) $ article = Model :: factory ('Article') -> find_one ($ id); $ article instanceof articolul) $ app-> notFound (); return $ app-> render ('blog_detail.html', array ('article' => $ article)););
 
Folosind Paris, putem să luăm rapid un articol prin ID-ul său folosind găsește una() metodă. Daca nu Articol obiectul instanței este returnat, spunem aplicației Slim că pagina nu a fost găsită, ceea ce va declanșa automat o eroare de 404.
 
Dacă se găsește articolul, îl transmitem în șablonul de detaliu, care arată după cum urmează:
 
 % extends 'layout.html'% % block page_title% article.title % endblock% % conținut bloc%% 
 titlul articolului 
 
Publicat: article.timestamp | data ('jS F Y') de article.author
 
article.content
 
Înapoi la pagina principală
 % endblock%
 
Folosind Twigs construit în filtre, putem accesa câteva funcții de bază PHP, cum ar fi Data() în șabloanele noastre. Atributul de clasă article.timestamp este dată în mod automat filtrului de date ca prim parametru, iar șirul de format de dată devine al doilea parametru.
  
Acum avem un front de lucru, deși unul simplu, dar nu a mers prea mult să-l ridice și să fie difuzat. Parisul face foarte ușor să vă concentrați asupra extragerii datelor din baza de date și, așa cum vom vedea când creați centrul de administrare, vă va facilita inserarea și actualizarea înregistrărilor.
 
 
 Pasul 6: Încheierea aplicației
 
Să lucrăm la un centru de administrare pentru blogul nostru, pe care îl vom structura sub URI / admin. Văzând că deja avem toate setările rutelor, să scriem logica pentru pagina principală a centrului de administrare. Acesta va fi identic cu pagina principală de înregistrare a blogului nostru, astfel încât codul de mai jos ar trebui să aibă un sens complet: 
 
 // Admin Home. $ app-> get ('/ admin', functie () foloseste ($ app) $ articles = Model :: factory ('Article') -> order_by_desc (' > render ('admin_home.html', array ('articole' => $ articole)););
 
Vom folosi un tabel simplu care conține link-uri de acțiune pentru adăugarea, editarea și ștergerea articolelor din blog.
 
Sunteți deja familiarizați cu modul în care funcționează sistemul de regiuni bloc din Twig, așa că să ne concentrăm doar pe blocul de conținut: 
 
 % conținutul blocului% 
Administrarea blogului meu
 
Adăugați articolul
 % dacă articolele%  % pentru articol în articole%  % endfor% 
 
 
 
Titlu
 
Data
 
Autor
 
acţiuni
 
 
 
 
 titlul articolului 
 
article.author
 
articol.timestamp | data ('jS F Y')
 
Editați | ×
 
Șterge
 
 
 % else% 
În prezent nu există articole.
 % endif% (% endblock%
 
În acest șablon, folosim % dacă% % altceva% % endif% logică. Nu vrem să afișăm marcajul tabelului dacă nu există articole, așa că verificăm existența acestuia înainte de a decide ce să afișăm. De asemenea, folosim filtru de date  din nou, ceea ce cred că veți fi de acord este destul de curat și lizibil.
  
Centrul de administrare principal
 
Să trecem la carnea reală a centrului nostru de administrare: manipularea conținutului. Avem nevoie de un formular care conține toate câmpurile de care trebuie să adăugăm și să ne editați articolul. Din fericire, Twig susține partiale reutilizabile, așa că hai să creăm o formă parțial numită article_form.html:
 
 
 
action_name Articol
 
 Titlu: 
  
 
 Autor: 
  
 
 Rezumat: 
 article.summary | implicit ('') 
 
 Conţinut: 
 article.content | implicit ('') 
 
  
 
 
Un parțial este pur și simplu un șablon reutilizabil, poate conține în continuare logica standard Twig. În șablonul nostru de formă, folosim Mod implicit filtru, care afișează o valoare implicită dacă variabila pe care o filtrează este goală sau inexistentă. În cazul câmpurilor formularului nostru, vom emite un șir gol dacă niciun atribut de articol nu este prezent. De asemenea, așteptăm două variabile pentru ca formularul nostru să fie parțial în curs de desfășurare. Primul a sunat ACTION_NAME descrie pur și simplu forma de acțiune pentru utilizatorii noștri (adică Adăugați sau editați) și a doua action_url este folosit ca acțiune în formă.
 
Veți observa fără îndoială modul în care logica pentru această pagină este împărțită în două rute, una pentru GET și una pentru POST, ceea ce înseamnă că va trebui să scriem o funcție pentru a gestiona fiecare metodă. Traseul nostru GET trebuie doar să redați pagina - nimic prea dificil. Îi vom spune lui Twig să facă un nou șablon: 
 
 // Admin Add. $ app-> get ('admin_input.html', array ('action_name' => 'Adauga', 'action_url') '=>' / admin / add ')););
 
Transmitem cele două variabile așteptate de forma noastră parțială în șablon. Vorbind despre asta, permiteți-mi să vă explic cum să folosiți parțial în nostru admin_input.html șablon: 
 
 % include 'article_form.html'%
 
Sunt sigur că probabil că ai ghicit că ar fi atât de simplu și chiar este. Trebuie doar să includem partea parțială din interiorul uneia din regiunile blocului Twig, iar apoi va apărea. De asemenea, va avea acces la toate variabilele din sfera sa de bază (adică cele două variabile în care am trecut). Twig are unele mari controale de domeniu variabil și caracteristici de securitate sandbox, dar acestea sunt cel mai bine salvate pentru o altă zi.
 
Șablonul final de intrare este destul de simplu (vedeți mai jos) și va funcționa bine atunci când construim și comenzile de editare. Presupun că vă întrebați de ce ne-am deranjat cu un parțial în primul clic, dacă atât formularele noastre de adăugare, cât și cele de editare vor folosi același șablon. Motivul este că face ca reutilizarea formularului în altă parte în timpul prototipării să facă o adevărată briză, dacă ar deveni necesară.
 
 % extinde 'layout.html'% % bloc page_title% action_name Articol % endblock% % block content% % include 'article_form.html'% % endblock%
  
Adăugați un formular pentru articole
 
Să lucrăm la acel traseu POST. Ceea ce trebuie să facem este să luăm datele postate și să le stocăm într-un obiect de articol. Nu ne deranjăm cu verificarea erorilor în exemplul nostru, deoarece noi doar proiectăm ideea noastră. Vom face Parisul să renunțe sau să creeze un nou articol obiect: 
 
 $ article = Model :: fabrică ('Articol') -> create ();
 
Acum putem continua să populăm articolul din datele postate. Vom extrage datele POST din obiectul de aplicație Slim, care oferă o metodă utilă la îndemână prin intermediul obiectului de solicitare: 
 
 $ article-> title = $ app-> request () -> post ("titlu"); $ article-> author = $ app-> request () -> post ("autor"); $ article-> summary = $ app-> request () -> post ("rezumat"); $ article-> content = $ app-> request () -> post ("conținut"); $ article-> timestamp = dată ('Y-m-d H: i: s');
 
Parisul are grijă să scape de toate contribuțiile noastre la salvare, ceea ce este la îndemână ar trebui să te hotărăști vreodată să-ți creezi prototipul pentru alții să acceseze. Tot ce trebuie să facem acum este să spuneți Parisului să salveze înregistrarea.
 
 $ Articol la> Salvare ();
 
În cele din urmă, le spunem aplicației noastre Slim să ne aducă înapoi la pagina principală a tabloului de bord al adminului utilizând redirecţiona metoda de ajutor: 
 
 $ App-> redirecționare ( '/ admin');
 
Pe metoda noastră de editare a metodei GET, care este pur și simplu o combinare a lucrurilor pe care le-am învățat de la construirea paginii cu detaliile blogului și a paginii noastre de adăugare a administratorului. În primul rând, trebuie să încărcăm articolul pe care îl editați, prin preluarea înregistrării la Paris: 
 
 $ articol = model :: fabrică ('Articol') -> find_one ($ id); dacă ($ article articleof articolul) $ app-> notFound (); 
 
Paris expediază un exemplu de obiect de articol care corespunde ID-ului de înregistrare al articolului primit în închiderea noastră sau false dacă nu există niciunul. Apoi verificăm dacă avem un exemplu înapoi, dacă nu îi spunem lui Slim să arunce o eroare de 404.
 
Acum îi spunem lui Slim să facă șablonul de intrare, ca în traseul nostru de adăugare, dar trecând în obiectul articol încărcat și adresa URL de acțiune corectă: 
 
 retur $ app-> render ('admin_input.html', array ('action_name' => 'Edit', 'action_url' => '/ admin / edit / $ $);
 
Traseul nostru de editare POST funcționează aproape identic cu adăuga cu excepția faptului că trebuie să verificăm dacă articolul ar putea fi încărcat înainte de a continua și de a actualiza atributele acestuia: 
 
 $ articol = model :: fabrică ('Articol') -> find_one ($ id); dacă ($ article articleof articolul) $ app-> notFound ();  $ article-> title = $ app-> request () -> post ("titlu"); $ article-> author = $ app-> request () -> post ("autor"); $ article-> summary = $ app-> request () -> post ("rezumat"); $ article-> content = $ app-> request () -> post ("conținut"); $ article-> timestamp = dată ('Y-m-d H: i: s'); $ Articol la> Salvare (); $ App-> redirecționare ( '/ admin');
 
Vom încheia centrul de administrare prin construirea rutei de ștergere. Vom face acest lucru prin recuperarea mai întâi a înregistrării, similar cu modul în care am făcut-o mai devreme pe pagina cu detaliile blogului nostru: 
 
 $ articol = model :: fabrică ('Articol') -> find_one ($ id);
 
Dacă Paris a încărcat un articol, trebuie să îl ștergem, apoi să trimitem utilizatorul înapoi la pagina principală de administrare. Paris face ștergerea unui record la fel de simplu ca poate fi: 
 
 dacă (articolul articol din articol) $ article-> delete ();  $ app-> redirect ('/ admin');
 
Și cu acest centru de administrare a prototipului de bază se face.
 
 
 Pasul 7: Folosind middleware
 
Centrul nostru de administrare este acum finalizat. Este destul de fundamental, deoarece este doar un prototip, dar încă mai dorim o anumită formă de autorizare pentru ao proteja de ochii curioși. Slim ne permite să inserăm middleware în rutele noastre. Ceea ce inseamna asta este ca putem sa cream functii care sa fie chemate inainte ca raspunsul nostru sa fie inchis.
 
Putem folosi HTTP Basic Auth pentru a ne proteja centrul de administrare. Evident, vom folosi ceva mai sigur într-un site live, dar pentru prototipul nostru acest lucru este bine. La vârful nostru index.php să creăm două constante care conțin numele de utilizator și parola: 
 
 // Auth Details. definiți ("USERNAME", "admin"); define ("PASSWORD", "parola");
 
După ce am creat instanța de aplicație Slim, vom crea o închidere, pe care o vom lega de o variabilă care să dețină controlul intermediar de autorizare: 
 
 // Auth Check. $ authCheck = funcția () utilizează ($ app) ;
 
Dacă nu ați mai folosit niciodată HTTP Basic Auth în PHP, este foarte ușor. Putem folosi $ _SERVER pentru a verifica ce acreditări au fost trimise din browser-ul web al utilizatorului și pentru a le compara cu constantele noastre. Vom face asta în interiorul închiderii nou create. Primul lucru pe care trebuie să-l facem în funcția noastră de verificare a auth este să aflăm dacă au fost trimise acreditări de auth și dacă s-ar afla, verificați dacă se potrivesc cu constantele noastre: 
 
 $ authRequest = este setat ($ _ SERVER ['PHP_AUTH_USER'], $ _SERVER ['PHP_AUTH_PW']); $ authUser = $ authRequest && $ _SERVER ['PHP_AUTH_USER'] === USERNAME; $ authPass = $ authRequest && $ _SERVER ['PHP_AUTH_PW'] === PASSWORD;
 
Tot ceea ce facem aici este verificarea dacă valorile auth există și se potrivesc, apoi stocarea rezultatelor în unele variabile. Presupunând că oricare dintre aceste variabile este falsă, știm că trebuie să îi solicităm utilizatorului să se autorizeze:
 
 dacă ! $ authUser ||! $ authPass) $ app-> răspuns () -> antet ("WWW-Authenticate: Basic =" Administrarea blogului meu "; $ app-> răspuns () -> antet ("HTTP / 1.1 401 neautorizat", "); răspuns $ app-> () -> corp (“
Introduceți acreditări de administrare valide
„); răspuns $ app-> () -> send (); Ieșire; 
 
Verificăm dacă acreditările noastre de auth sunt în regulă. Dacă nu sunt, vom trimite un răspuns înapoi cu anteturile corespunzătoare și mesajul de avertizare. Așa cum ați văzut mai devreme, am putea accesa obiectul cererii cadru Slim pentru a obține acces la datele noastre POST. Putem de asemenea să accesăm obiectul de răspuns intern, ceea ce ne face ușor să împingem anteturile noastre și să suprascriem corpul obiectului de răspuns Slim cu un mesaj de avertizare HTML simplu, înainte de a forța scriptul să iasă.
 
În Slim puteți adăuga mai multe apeluri callabile pe un traseu și acestea sunt executate în ordinea în care sunt specificate. Ceea ce înseamnă acest lucru este faptul că putem preveni cu ușurință accesul la toate rutele noastre prin adăugarea închiderii verificării auth înainte de închiderea răspunsului: 
 
 // Admin Home. $ app-> get ('/ admin', $ authCheck, funcția () utilizează ($ app) //?); // Admin Add. $ app-> get ('/ admin / add', $ authCheck, function () folosiți ($ app) //?); // Admin Add - POST. $ app-> post ('/ admin / add', $ authCheck, funcția () folosiți ($ app) //?); // Admin Edit. $ app-> get ('/ admin / edit / (: id)', $ authCheck, funcția ($ id) utilizează ($ app) //?); // Admin Edit - POST. $ app-> post ('/ admin / edit / (: id)', $ authCheck, funcția ($ id) folosiți ($ app) //?); // Admin Delete. $ app-> get ('/ admin / delete / (: id)', $ authCheck, funcția ($ id) utilizează ($ app) //?);
 
Și acolo aveți, centrul nostru de administrare este acum protejat. Oricine încearcă să-l acceseze va vedea un mesaj de avertizare și va fi solicitat pentru acreditările sale.
  
 
 Pasul 8: Rezumat
 
Sperăm că acest tutorial ne-a arătat cât de rapid și ușor este să obțineți un prototip care să funcționeze cu un cadru micro, o limbă ORM și un șablon, menținând în același timp o bună separare a preocupărilor și a codului lizibil.
 
Un puternic limbaj templificator poate împiedica opiniile dvs. să se termine ca un amestec de coduri de spaghetti PHP și HTML care nu pot fi citite și modul în care un ORM fluent poate face actiuni CRUD obositoare rapid și fără durere.
 
Acestea sunt doar câteva dintre cele mai reci lucruri pe care le puteți face cu Slim, Twig și Paris. Dacă vă grăbiți mai mult, puteți adăuga relații la modelele dvs. cu Paris, puteți adăuga fragmente macro în Twig pentru a accelera dezvoltarea șabloanelor și pentru a utiliza rutarea bazată pe nume cu Slim pentru a vă conecta conținutul site-ului dvs. și pentru a modifica adresele URL triviali.
 
Fericit de prototipuri și vă mulțumesc atât de mult pentru lectură!



		
			
	   
	




Cod