Share
Det er vanskelig å nekte det faktum at PHP-fellesskapet er begeistret for Laravel 4. Blant annet bruker rammen kraften til Composer, noe som betyr at den kan bruke enhver pakke eller skript fra Packagist.
I mellomtiden tilbyr Laravel "Bundles", som tillater oss å modulere kode for bruk i fremtidige prosjekter. Buntkatalogen er full av gode skript og pakker som du kan bruke i dine applikasjoner. I denne leksjonen vil jeg vise deg hvordan du bygger en fra grunnen av!
Bundler tilbyr en enkel måte å gruppere relatert kode på. Hvis du er kjent med CodeIgniter, er bunter ganske lik "Sparks". Dette er tydelig når du ser på mappestrukturen.
Å lage et bunt er ganske enkelt. For å illustrere prosessen, vil vi bygge en admin panel kjeleplate som vi kan bruke i fremtidige prosjekter. For det første må vi opprette en "admin" -katalog i mappen "bunter". Prøv å replikere mappestrukturen fra bildet ovenfor.
Før vi begynner å legge til noe i vårt pakke, må vi først registrere det med Laravel. Dette gjøres i søknaden din bundles.php fil. Når du åpner denne filen, bør du se en matrise som returneres; vi trenger bare å legge til vårt bunt og definere a håndtak. Dette blir URIen der vi får tilgang til administrasjonspanelet.
Accentsconagua
'admin' => array ('handles' => 'admin') Her har jeg kalt min, "admin", men vær så snill å ringe din, uansett hva du ønsker.
Når vi har oppsettet, må vi opprette en start.php fil. Her skal vi sette opp noen ting, for eksempel våre navneområder. Hvis du ikke er plaget av dette, trenger du ikke egentlig en startfil for bunten din til å virke, som forventet.
Laravel autoloader klasse lar oss gjøre et par ting: kart vår base controller og autoload navnerom.
Autoloader :: kart (array ('Admin_Base_Controller' => Bundle :: sti ('admin'). 'Controllers / base.php',)); Autoloader :: namespaces (array ('Admin \ Modeller' => Bundle :: path ('admin'). 'Modeller', 'Admin \ Biblioteker' => Bundle :: sti ('admin'). 'Biblioteker' ); Namespacing vil sikre at vi ikke er i konflikt med andre modeller eller biblioteker som allerede er inkludert i vår søknad. Du vil legge merke til at vi ikke har valgt å ikke navneområde våre kontrollere for å gjøre ting litt enklere.
For administrasjonspanelet, vil vi dra nytte av Twitter Bootstrap, så ta tak i en kopi. Vi kan pope dette inn i a offentlig mappe inne i vår pakke for å publisere til vår søknad senere.
Når du er klar til å publisere dem, bare kjør følgende kommando gjennom håndverkere.
php artisan bunt: publiser admin
Dette vil kopiere mappestrukturen og filene til bunter katalog i vår offentlig mappe, i roten av Laravel-installasjonen. Vi kan da bruke dette i bundleens basestyring.
Det er alltid en smart idé å sette opp en basestyring, og strekke derfra. Her kan vi sette opp rolige kontrollører, definere oppsettet og inkludere eventuelle eiendeler. Vi trenger bare å ringe denne filen, base.php, og pop den inn i vår kontrollerkrets katalog.
For det første, la oss få litt housekeeping ut av veien. Vi vil selvfølgelig bruke Laravels rolige kontroller.
offentlig $ restful = true;
Og vi vil spesifisere et oppsett som vi skal lage snart. Hvis du ikke er vant til regulatoroppsett, så er du inne for en godbit.
offentlig $ layout = 'admin :: layouts.main';
Bundtnavnet, etterfulgt av to kolonner, er et paradigme i Laravel, vi vil se mer av i fremtiden, så hold øye med.
Når du håndterer eiendeler i vårt pakke, kan vi gjøre ting som forventet og angi banen fra roten til den offentlige mappen. Heldigvis er Laravel der for å gjøre livet enklere. I vår konstruksjon må vi spesifisere pakken før du legger til våre aktivbeholdere.
Aktiva :: beholder ( 'header') -> bunt ( 'admin'); Asset :: container ( 'footer') -> bundle ( 'admin');
Hvis du ikke er kjent med beholdningsbeholdere, ikke bekymre deg; de er bare deler av en side hvor du vil huske dine eiendeler. Her vil vi inkludere stilark i overskriften og skript i bunnteksten.
Nå, med det ut av veien, kan vi enkelt inkludere våre bootstrap stiler og skript. Vår komplette basestyring skal se ut som:
klasse Admin_Base_Controller utvider Controller public $ restful = true; offentlig $ layout = 'admin :: layouts.main'; offentlig funksjon __construct () foreldre :: __ construct (); Aktiva :: beholder ( 'header') -> bunt ( 'admin'); Asset :: container ('header') -> add ('bootstrap', 'css / bootstrap.min.css'); Asset :: container ( 'footer') -> bundle ( 'admin'); Asset :: container ('footer') -> legg til ('jquery', 'http://code.jquery.com/jquery-latest.min.js'); Asset :: container ('footer') -> add ('bootstrapjs', 'js / bootstrap.min.js'); / ** * Catch-all metode for forespørsler som ikke kan matches. * * @param streng $ metode * @param array $ parametere * @return Response * / offentlig funksjon __call ($ metode, $ parametere) return Response :: error ('404'); Vi har også brakt over catch-all-forespørselen fra programmets basestyring for å returnere et 404-svar, hvis en side ikke ble funnet.
Før vi gjør noe annet, la oss lage filen for den oppsettet, visninger / layout / main.blade.php, så vi møter ikke noen feil senere.
Når vi bygger et administrasjonspanel, skal vi holde folk ute. Heldigvis kan vi bruke Laravel er innebygd Auth klasse for å oppnå dette med letthet ...
Først må vi lage vårt bord; Jeg skal bruke "admins" som min tabell navn, men du kan endre det, hvis du ønsker det. Håndtverker vil generere en migrasjon, og pop den inn i buntens migrasjons katalog. Bare kjør følgende i kommandolinjen.
php artisan migrere: gjør admin :: create_admins_table
Hvis du ikke er kjent med skjemabyggeren, anbefaler jeg at du tar et blikk på dokumentasjonen. Vi skal inkludere noen få kolonner:
Vi vil også inkludere standard tidsstempler, for å følge best practices.
/ ** * Gjør endringer i databasen. * * @return void * / offentlig funksjon opp () Schema :: create ('admins', funksjon ($ table) $ table-> trinn ('id'); $ table-> string ('name', 200 ); $ table-> string ('brukernavn', 32) -> unikt (); $ tabell-> streng ('passord', 64); $ tabell-> streng ('epost', 320) -> unikt ; $ tabell-> streng ('rolle', 32); $ tabell-> tidsstempel ();); / ** * Gjenopprett endringene i databasen. * * @return void * / offentlig funksjon ned () Schema :: drop ('admins'); Nå som vi har vår databasestruktur på plass, må vi opprette en tilhørende modell for bordet. Denne prosessen er i hovedsak identisk med hvordan vi kan oppnå dette i vår hovedapplikasjon. Vi lager filen og modellen, basert på enestående form av vårt tabellnavn - men vi må sørge for at vi navnerom riktig.
navneområde Admin \ Modeller; bruk \ Laravel \ Database \ Eloquent \ Model som Eloquent; klassen Admin utvider Eloquent
Ovenfor har vi sørget for at vi bruker navneområdet som vi definerte i start.php. Også, slik at vi kan referere Eloquent riktig, oppretter vi et alias.
For å holde bunden vår helt selvstendig, må vi utvide auth. Dette vil tillate oss å definere et bord bare å logge inn på vårt administrasjonspanel, og ikke forstyrre hovedprogrammet.
Før vi lager vår egendefinerte driver, oppretter vi en konfigurasjonsfil, der du kan velge om du vil bruke brukernavn eller e-post kolonner fra databasetabellen.
returnere array ('brukernavn' => 'brukernavn', 'passord' => 'passord',); Hvis du vil endre kolonnene som vi skal bruke, kan du justere verdiene her.
Vi må neste skape sjåføren. La oss kalle det, "AdminAuth", og inkludere det i bibliotekets mappe. Siden vi utvider Auth, trenger vi bare å overskrive et par metoder for å få alt som fungerer, som vi hadde til hensikt.
navneområde Admin \ Biblioteker; bruk Admin \ Modeller \ Admin som Admin, Laravel \ Auth \ Drivers \ Eloquent som Eloquent, Laravel \ Hash, Laravel \ Config; klasse AdminAuth utvider Eloquent / ** * Få den nåværende brukeren av applikasjonen. * * Hvis brukeren er gjest, skal null returneres. * * @param int | objekt $ token * @return mixed | null * / public function retrieve ($ token) // Vi returnerer et objekt her enten hvis passet token er et heltall (ID) // eller hvis vi er bestått et modellobjekt av riktig type hvis (filter_var ($ token, FILTER_VALIDATE_INT)! == false) return $ this-> model () -> find ($ token); annet hvis (get_class ($ token) == ny Admin) return $ token; / ** * Forsøk å logge en bruker inn i applikasjonen. * * @param array $ arguments * @return void * / offentlig funksjon forsøk ($ arguments = array ()) $ user = $ this-> model () -> hvor (funksjon ($ query) bruk ($ argumenter) $ brukernavn = Config :: get ('admin :: auth.username'); $ query-> hvor ($ brukernavn, '=', $ arguments ['brukernavn']); foreach (array_except ($ arguments, array brukernavn ',' passord ',' husk ')) som $ kolonne => $ val) $ spørring-> hvor ($ kolonne,' = ', $ val);) -> første // Hvis legitimasjonene samsvarer med hva som er i databasen, vil vi bare // logge brukeren inn i søknaden og huske dem hvis de blir spurt. $ password = $ arguments ['password']; $ password_field = Config :: get ('admin :: auth.password', 'passord'); hvis ! er_null ($ bruker) og Hash :: sjekk ($ passord, $ bruker -> $ password_field)) return $ this-> logg inn ($ user-> get_key (), array_get ($ arguments, ')); returner falsk; beskyttet funksjonsmodell () returner ny Admin; Nå som vi har skapt sjåføren, må vi la Laravel vite. Vi kan bruke Auth's forlenge metode for å gjøre dette i vår start.php fil.
Auth :: extend ('adminauth', funksjon () returner nytt Admin \ Biblioteker \ AdminAuth;); En siste ting vi må gjøre er å konfigurere Auth for å bruke dette ved kjøring. Vi kan gjøre dette i vår basestyringens konstruktør med følgende.
Config :: set ('auth.driver', 'adminauth'); Før vi kan rute til noe, må vi opprette en kontroller. La oss opprette kontrollpanelet på dashbordet, noe som vi ser etter at du har logget inn.
Som vi vil at dette skal dukke opp på roten til bunten vår (det vil si håndtaket vi definerte tidligere), må vi ringe dette home.php. Laravel bruker "hjem" søkeordet for å etablere det du vil vise opp til roten til søknaden eller bunten.
Utvid basen kontrolleren, og opprett en indeksvisning. For nå, returner du bare 'Hello World', slik at vi kan sikre at alt fungerer i orden.
klasse Admin_Home_Controller utvider Admin_Base_Controller offentlig funksjon get_index () return 'Hello World';
Nå som vår kontroller er satt opp, kan vi rute til den. Lage en routes.php i bunten din, hvis du ikke allerede har det. I likhet med vår hovedapplikasjon kan hver bunt ha sin egen rutefil som fungerer identisk.
Rute :: kontroller (array ('admin :: home',)); Her har jeg registrert hjemmekontrolleren, som Laravel automatisk skal tilordne seg til /. Senere legger vi inn loggkontrollen til matrisen.
Hvis du leder til / admin (eller hva håndtere deg tidligere definert) i nettleseren din, så bør du se "Hello World".
La oss lage innloggingsregulatoren, men i stedet for å utvide basestyringen, vil vi i stedet utvide Laravels hovedkontroller. Årsaken bak denne beslutningen vil bli tydelig innen kort tid.
Fordi vi ikke strekker seg, må vi sette opp et par ting før du begynner - nemlig avslappende layouter, riktig auth driver og våre eiendeler.
klassen Admin_Login_Controller utvider kontrolleren public $ restful = true; offentlig funksjon __construct () foreldre :: __ construct (); Config :: set ('auth.driver', 'adminauth'); Aktiva :: beholder ( 'header') -> bunt ( 'admin'); Asset :: container ('header') -> add ('bootstrap', 'css / bootstrap.min.css'); La oss også skape vårt syn. Vi skal bruke Blade - Laravel's templating motor - for å få fart på ting litt. Opprett en innloggingsliste og en "index.blade.php" -fil innenfor den i bunndisplaykatalogen.
Vi vil pope i en standard HTML-sidestruktur og ekko aktivaene.
Logg Inn Asset :: beholder ( 'header') -> stiler ()
La oss nå sørge for at visningen blir opprettet i kontrolleren. Når vi bruker rolige kontrollører, kan vi dra nytte av "get" -verdet i vår metode.
offentlig funksjon get_index () return View :: make ('admin :: login.index'); Rått! Vi er nå gode til å begynne å bygge vårt skjema, som vi kan lage med Form klasse.
Form :: open () Form :: label ('brukernavn', 'Brukernavn') Formular :: tekst ('brukernavn') Form :: etikett , «Passord») Formular: Passord ('Passord') Formular :: Send ('Logg inn', array ('class' => 'btn btn-suksess')) Form :: token () Formular :: Lukk () 
Ovenfor har vi opprettet et skjema som legger til seg selv (akkurat det vi ønsker), sammen med ulike formelementer og etiketter for å gå med det. Det neste trinnet er å behandle skjemaet.
Når vi sender inn skjemaet til seg selv og bruker rolige kontrollører, trenger vi bare å opprette post_index metode og bruk dette for å behandle innloggingen vår. Hvis du aldri har brukt Auth før, så ta en titt på dokumentasjonen før du fortsetter.
offentlig funksjon post_index () $ creds = array ('brukernavn' => Input :: get ('brukernavn'), 'passord' => Input :: get ('passord');); hvis (Auth: forsøk ($ creds)) return Omdirigering :: til (URL :: to_action ('admin :: home @ index')); ellers return Omdirigere :: tilbake () -> med ('feil', sant); Hvis legitimasjonene er riktige, blir brukeren omdirigert til oversikten. Ellers blir de omdirigert tilbake med en feil som vi kan sjekke for i påloggingsvisningen. Siden dette bare er øktdata, og ikke valideringsfeil, trenger vi bare å gjennomføre en enkel sjekk.
@if (Session :: get ('error')) Beklager, brukernavnet eller passordet ditt var feil. @slutt om Vi må også logge brukere ut; så la oss lage en get_logout metode, og legg til følgende. Dette vil logge ut brukere, og deretter omdirigere dem når de besøker / Admin / login / logout.
offentlig funksjon get_logout () Auth :: logout (); returnere Omdirigering :: til (URL :: to_action ('admin :: home @ index')); Det siste vi bør gjøre er å legge inn påloggingsregulatoren til vår rutefil.
Rute :: kontroller (array ('admin :: home', 'admin :: login',)); For å stoppe folk fra å omgå vår innloggingsskjerm, må vi filtrere våre ruter for å avgjøre om de er autoriserte brukere. Vi kan lage filteret i vår routes.php, og fest den til vår basestyring, for å filtrere før ruten vises.
Rute :: filter ('auth', funksjon () hvis (Auth :: gjest ()) returnere Omdirigering :: til (URL :: to_action ('admin :: login'));); På dette punktet er alt som er igjen å gjøre, kalt dette i vår hovedkontroller konstruktør. Hvis vi utvidet vår påloggingsregulator fra basen vår, ville vi ha en uendelig sløyfe som til slutt ville gå ut.
$ this-> filter ('før', 'auth'); Tidligere skapte vi vår main.blade.php oppsett; nå skal vi gjøre noe med det. La oss få en HTML-side og våre eiendeler blir hentet inn.
$ Title Asset :: beholder ( 'header') -> stiler ()$ InnholdAsset :: beholder ( 'bunntekst') -> skript ()
Du vil legge merke til at jeg også har egget ut et par variabler: $ title og $ innhold. Vi kan bruke magiske metoder fra vår kontroller for å overføre data til disse. Jeg har også poppet $ innhold inne i beholderen div at Bootstrap vil gi styling for.
Deretter la vi opprette visningen for oversikten. Da vi kommer til å neste dette, trenger vi bare å sette innholdet vi ønsker å sette inn i vår container.
Hallo
Dette er vårt oversiktsbildevisning
Lagre dette som index.blade.php innen visninger / dashbord katalog inne i bunten din.
Vi trenger nå å stille inn kontrolleren vår for å dra nytte av oppsettet og vise filer som vi nettopp har opprettet. Innen get_index Metode som vi opprettet tidligere, legg til følgende.
$ this-> layout-> title = 'Dashboard'; $ this-> layout-> nest ('content', 'admin :: dashboard.index'); tittel er en magisk metode som vi kan ekko ut som en variabel i vårt layout. Ved bruk av rede, Vi kan inkludere en visning inne i oppsettet rett fra vår kontroller.
For å øke hastigheten, gir Laravel oss en enkel måte å utføre kode fra kommandolinjen. Disse kalles "Oppgaver"; det er en god ide å lage en for å legge til en ny bruker i databasen enkelt.
Vi må bare sørge for at filen tar opp navnet på vår oppgave, og pop den inn i vår buntens oppgaverkatalog. Jeg skal ringe dette setup.php, som vi vil bruke den bare etter at du har installert bunten.
bruk Laravel \ CLI \ Command as Command; bruk Admin \ Modeller \ Admin som Admin; klasse Admin_Setup_Task public function run ($ arguments) if (empty ($ arguments) || count ($ arguments) < 5) die("Error: Please enter first name, last name, username, email address and password\n"); Command::run(array('bundle:publish', 'admin')); $role = (!isset($arguments[5])) ? 'admin' : $arguments[5]; $data = array( 'name' => $ argumenter [1], 'brukernavn' => $ argumenter [2], 'email' => $ argumenter [3], 'passord' => Hash :: make ($ arguments [4 ]), 'rolle' => $ rolle,); $ user = Admin :: opprett ($ data); ekko ($ bruker)? 'Admin opprettet vellykket!' : 'Feil å opprette admin!'; Laravel vil passere gjennom en rekke argumenter; Vi kan telle disse for å sikre at vi får akkurat det vi ønsker. Hvis ikke, ekko vi en feil. Du vil også merke at vi bruker Kommando klasse å løpe pakke: publisere. Dette vil tillate deg å kjøre en kommandolinjeoppgave innebygd i Laravel i søknaden eller bunten.
Det viktigste som denne oppgaven gjør er å ta tak i argumentene som er sendt videre til det, hash passordet, og sett inn en ny admin i admins bord. For å kjøre dette må vi bruke følgende i kommandolinjen.
php artisan admin :: setup fornavn etternavn brukernavn [email protected] passord
I denne opplæringen opprettet vi et kjedepanel-administrasjonspanel som er ganske enkelt å utvide. For eksempel, roller kolonne som vi opprettet kan tillate deg å begrense hva kundene dine kan se.
En pakke kan være alt fra et administrasjonspanel, som vi bygget i dag, til Markdown parsers - eller til og med hele Zend Framework (jeg tuller ikke). Alt vi dekket her vil sette deg på vei til å skrive fantastiske Laravel-bunter, som kan bli publisert i Laravels bunt katalog.
Lær mer om å lage Laravel-bunter her på Nettuts+.
