Share
Het is moeilijk te ontkennen dat de PHP-community enthousiast is voor Laravel 4. Het framework maakt onder andere gebruik van de kracht van Composer, wat betekent dat het elk pakket of script van Packagist kan gebruiken..
In de tussentijd biedt Laravel 'Bundels', waarmee we de code kunnen modulariseren voor gebruik in toekomstige projecten. De bundelmap staat vol met uitstekende scripts en pakketten die u in uw toepassingen kunt gebruiken. In deze les laat ik je zien hoe je er een helemaal vanaf kunt bouwen!
Bundels bieden een eenvoudige manier om gerelateerde code te groeperen. Als u bekend bent met CodeIgniter, lijken bundels sterk op "Sparks". Dit is duidelijk wanneer u de mappenstructuur bekijkt.
Het maken van een bundel is vrij eenvoudig. Om het proces te illustreren, bouwen we een boilerplate van het beheerderspaneel die we kunnen gebruiken in toekomstige projecten. Allereerst moeten we een 'admin'-map maken in onze map' bundels '. Probeer de mappenstructuur uit bovenstaande afbeelding te repliceren.
Voordat we iets aan onze bundel toevoegen, moeten we het eerst registreren bij Laravel. Dit gebeurt in uw applicaties bundles.php het dossier. Zodra u dit bestand opent, ziet u dat een array wordt geretourneerd; we hoeven alleen onze bundel toe te voegen en een a te definiëren handvat. Dit wordt de URI waarin we toegang hebben tot ons admin panel.
Accentsconagua
'admin' => array ('handles' => 'admin') Hier heb ik de mijne genoemd, "admin", maar voel je vrij om de jouwe te bellen wat je maar wilt.
Zodra we die configuratie hebben, moeten we een start.php het dossier. Hier gaan we een paar dingen opzetten, zoals onze naamruimten. Als je hier geen last van hebt, dan heb je geen startbestand nodig om je bundel te laten werken, zoals verwacht.
Met de autoloader-klasse van Laravel kunnen we een aantal dingen doen: kaart van onze basiscontroller en naamruimten autoload.
Autoloader :: map (array ('Admin_Base_Controller' => Bundel :: path ('admin'). 'Controllers / base.php',)); Autoloader :: namespaces (array ('Admin \ Models' => Bundel :: path ('admin'). 'Models', 'Admin \ Libraries' => Bundel :: path ('admin'). 'Libraries',) ); Namespacing zorgt ervoor dat we niet in conflict komen met andere modellen of bibliotheken die al in onze applicatie zijn opgenomen. U zult merken dat we er niet voor hebben gekozen om onze controllers geen namespace te geven om het een beetje gemakkelijker te maken.
Voor het admin-paneel maken we gebruik van de Bootstrap van Twitter, dus pak een kopie. We kunnen dit in een openbaar map in onze bundel om later naar onze applicatie te kunnen publiceren.
Wanneer u klaar bent om ze te publiceren, voert u de volgende opdracht uit via artisanaal.
php artisan bundle: publiceer admin
Hiermee worden de mappenstructuur en bestanden naar de map gekopieerd bundels map in onze openbaar map, in de hoofdmap van de Laravel-installatie. We kunnen dit dan gebruiken in de basiscontroller van onze bundel.
Het is altijd een slim idee om een basiscontroller in te stellen en van daaruit uit te breiden. Hier kunnen we rustgevende controllers instellen, de lay-out definiëren en alle items opnemen. We moeten dit bestand gewoon bellen, base.php, en pop het in de directory van onze controller.
Laten we eerst een aantal zaken uit de weg ruimen. We willen natuurlijk de rustgevende controllers van Laravel gebruiken.
public $ restful = true;
En we zullen een lay-out specificeren die we binnenkort zullen maken. Als je niet gewend bent aan controllerde lay-outs, dan ben je in voor een traktatie.
public $ layout = 'admin :: layouts.main';
De bundelnaam, gevolgd door twee dubbele punten, is een paradigma in Laravel waar we in de toekomst meer van zullen zien, dus houd het in de gaten.
Wanneer we activa in onze bundel verwerken, kunnen we de dingen doen zoals verwacht en het pad opgeven vanuit de hoofdmap van de openbare map. Gelukkig is Laravel er om ons leven gemakkelijker te maken. In onze constructie moeten we de bundel specificeren voordat we deze toevoegen aan onze assetcontainers.
Asset :: container ( 'header') -> bundel ( 'admin'); Asset :: container ( 'footer') -> bundel ( 'admin');
Als u niet bekend bent met asset-containers, maakt u zich geen zorgen; het zijn slechts gedeelten van een pagina waar u uw vermogen wilt onderbrengen. Hier gaan we stylesheets opnemen in de koptekst en scripts in de voettekst.
Nu, met dat uit de weg, kunnen we onze bootstrap-stijlen en -scripts eenvoudig opnemen. Onze voltooide basiscontroller moet er ongeveer zo uitzien:
class Admin_Base_Controller verlengt Controller public $ restful = true; public $ layout = 'admin :: layouts.main'; publieke functie __construct () parent :: __ construct (); Asset :: container ( 'header') -> bundel ( 'admin'); Activa :: container ('header') -> add ('bootstrap', 'css / bootstrap.min.css'); Asset :: container ( 'footer') -> bundel ( 'admin'); Activum :: container ('footer') -> add ('jquery', 'http://code.jquery.com/jquery-latest.min.js'); Activum :: container ('footer') -> add ('bootstrapjs', 'js / bootstrap.min.js'); / ** * Vangstmethode voor verzoeken die niet kunnen worden vergeleken. * * @param string $ methode * @param array $ parameters * @return Response * / public function __call ($ methode, $ parameters) return Response :: error ('404'); We hebben ook het catch-all-verzoek van de basiscontroller van de toepassing overgebracht om een 404-antwoord terug te sturen als er geen pagina wordt gevonden.
Voordat we iets anders doen, laten we het bestand voor die lay-out maken, views / lay-out / main.blade.php, zodat we later geen fouten tegenkomen.
Terwijl we een beheerdersvenster bouwen, willen we mensen buiten houden. Gelukkig kunnen we de ingebouwde Laravel's gebruiken Auth klas om dit gemakkelijk te bereiken ...
Eerst moeten we onze tafel maken; Ik ga 'admins' gebruiken als mijn tabelnaam, maar je kunt deze wijzigen als je dat wilt. Artisan genereert een migratie en plaatst deze in de migratiemap van onze bundel. Voer gewoon het volgende uit in de opdrachtregel.
php artisan migrate: make admin :: create_admins_table
Als u niet bekend bent met de schemabuilder, raad ik u aan de documentatie eens te bekijken. We gaan een paar kolommen toevoegen:
We nemen ook de standaardtijdstempels op om best practices te volgen.
/ ** * Breng wijzigingen aan in de database. * * @return void * / public function up () Schema :: create ('admins', function ($ table) $ table-> increments ('id'); $ table-> string ('name', 200 ); $ table-> string ('gebruikersnaam', 32) -> unique (); $ table-> string ('wachtwoord', 64); $ table-> string ('email', 320) -> unique () ; $ table-> string ('role', 32); $ table-> timestamps ();); / ** * Herstel de wijzigingen in de database. * * @return void * / public function down () Schema :: drop ('admins'); Nu we onze databasestructuur hebben geïnstalleerd, moeten we een gekoppeld model voor de tabel maken. Dit proces is in essentie identiek aan hoe we dit in onze hoofdtoepassing zouden kunnen bereiken. We maken het bestand en het model, op basis van de enkelvoudige vorm van onze tabelnaam - maar we moeten ervoor zorgen dat we de naamruimte correct weergeven.
naamruimte Admin \ Models; gebruik \ Laravel \ Database \ Eloquent \ Model als Weldadig; class Admin breidt Eloquent uit
Hierboven hebben we ervoor gezorgd dat we de naamruimte gebruiken die we hebben gedefinieerd start.php. Ook, dus we kunnen correct verwijzen naar Eloquent, we maken een alias.
Om onze bundel volledig op zichzelf te houden, moeten we uitbreiden auth. Hiermee kunnen we een tabel definiëren net om in te loggen op ons admin panel, en niet interfereren met de hoofdtoepassing.
Voordat we ons aangepaste stuurprogramma maken, maken we een configuratiebestand, waarin u kunt kiezen of u het wilt gebruiken gebruikersnaam of e-mail kolommen uit de databasetabel.
return array ('gebruikersnaam' => 'gebruikersnaam', 'wachtwoord' => 'wachtwoord',); Als u de kolommen die we gaan gebruiken wilt wijzigen, past u eenvoudig de waarden hier aan.
Vervolgens moeten we de driver maken. Laten we het 'AdminAuth' noemen en het opnemen in onze bibliothekenmap. Omdat we Auth uitbreiden, hoeven we maar een paar methoden te overschrijven om alles goed te laten werken, zoals we het bedoeld hadden.
naamruimte Admin \ Bibliotheken; gebruik Admin \ Models \ Admin als Admin, Laravel \ Auth \ Drivers \ Eloquent als Eloquent, Laravel \ Hash, Laravel \ Config; class AdminAuth breidt Eloquent uit / ** * Download de huidige gebruiker van de applicatie. * * Als de gebruiker een gast is, moet nul worden geretourneerd. * * @param int | object $ token * @return mixed | null * / public function retrieve ($ token) // We retourneren hier een object als het doorgegeven token een geheel getal (ID) // is of als we zijn geslaagd een modelobject van het juiste type if (filter_var ($ token, FILTER_VALIDATE_INT)! == false) return $ this-> model () -> find ($ token); else if (get_class ($ token) == new Admin) return $ token; / ** * Poging om een gebruiker in de toepassing te loggen. * * @param array $ arguments * @return void * / public function attempt ($ arguments = array ()) $ user = $ this-> model () -> where (function ($ query) use ($ arguments) $ username = Config :: get ('admin :: auth.username'); $ query-> where ($ username, '=', $ arguments ['username']); foreach (array_except ($ arguments, array (' gebruikersnaam ',' wachtwoord ',' onthouden ')) als $ kolom => $ val) $ query-> where ($ column,' = ', $ val);) -> first (); // Als de inloggegevens overeenkomen met die in de database, zullen we // de gebruiker in de toepassing loggen en ze onthouden als daarom wordt gevraagd. $ wachtwoord = $ argumenten ['wachtwoord']; $ password_field = Config :: get ('admin :: auth.password', 'password'); if (! is_null ($ user) and Hash :: check ($ password, $ user -> $ password_field)) return $ this-> login ($ user-> get_key (), array_get ($ arguments, 'remember ')); return false; protected function model () return new Admin; Nu we de driver hebben gemaakt, moeten we Laravel dit laten weten. We kunnen Auth's gebruiken uitbreiden methode om dit te doen in onze start.php het dossier.
Auth :: extend ('adminauth', function () return new Admin \ Libraries \ AdminAuth;); Een laatste ding dat we moeten doen, is Auth configureren om dit tijdens runtime te gebruiken. We kunnen dit doen in de constructor van onze basis controller met het volgende.
Config :: set ('auth.driver', 'adminauth'); Voordat we ergens naartoe kunnen gaan, moeten we een controller maken. Laten we onze dashboardcontroller maken, wat we zullen zien na het inloggen.
Omdat we willen dat dit wordt weergegeven aan de basis van onze bundel (dat wil zeggen de handle die we eerder hebben gedefinieerd), moeten we dit noemen home.php. Laravel gebruikt het trefwoord 'thuis' om vast te stellen wat u wilt laten zien aan de basis van uw toepassing of bundel.
Breid je basiscontroller uit en maak een indexweergave. Stuur voor nu gewoon 'Hello World' terug zodat we kunnen zorgen dat alles goed werkt.
class Admin_Home_Controller breidt Admin_Base_Controller uit public function get_index () terug 'Hello World';
Nu onze controller is ingesteld, kunnen we er naartoe gaan. Maak een routes.php binnen je bundel, als je dat nog niet hebt gedaan. Net als bij onze hoofdtoepassing, kan elke bundel een eigen routesbestand hebben dat identiek werkt.
Route :: controller (array ('admin :: home',)); Hier heb ik de thuisregelaar geregistreerd, die Laravel automatisch toewijst /. Later voegen we onze login-controller toe aan de array.
Als je naar toe gaat /beheerder (of welk handvat dan ook dat u eerder hebt gedefinieerd) in uw browser, dan zou u 'Hello World' moeten zien.
Laten we echter de login-controller maken, in plaats van de basiscontroller uit te breiden, zullen we in plaats daarvan Laravel's hoofdcontroller uitbreiden. De reden achter dit besluit zal binnenkort duidelijk worden.
Omdat we niet uitbreiden, moeten we eerst een paar dingen verzinnen voordat we van start gaan - namelijk rustige lay-outs, de juiste auth-driver en onze troeven.
class Admin_Login_Controller breidt Controller uit public $ restful = true; publieke functie __construct () parent :: __ construct (); Config :: set ('auth.driver', 'adminauth'); Asset :: container ( 'header') -> bundel ( 'admin'); Activa :: container ('header') -> add ('bootstrap', 'css / bootstrap.min.css'); Laten we ook ons beeld creëren. We gaan de sjabloon-engine van Blade gebruiken om de dingen een beetje te versnellen. Maak binnen de map met bundelweergaven een 'aanmeldingsdirectory' en een 'index.blade.php'-bestand daarin.
We duiken in een standaard HTML-paginastructuur en geven een echo van de items weer.
Log in Asset :: container ( 'header') -> stijlen ()
Laten we er nu voor zorgen dat de weergave wordt gemaakt in de controller. Omdat we rustgevende controllers gebruiken, kunnen we gebruik maken van het 'get'-werkwoord in onze methode.
openbare functie get_index () return View :: make ('admin :: login.index'); Geweldig! We zijn nu goed om te beginnen met het bouwen van ons formulier, dat we kunnen maken met de Het formulier klasse.
Formulier: open () Formulier: label ('gebruikersnaam', 'Gebruikersnaam') Formulier: tekst ('gebruikersnaam') Formulier: label ('wachtwoord') , 'Wachtwoord') Formulier :: wachtwoord ('wachtwoord') Formulier: submit ('Inloggen', array ('class' => 'btn btn-success')) Formulier :: token () Formulier: close () 
Hierboven hebben we een formulier gemaakt dat naar zichzelf zal posten (precies wat we willen), samen met verschillende formulierelementen en labels die daarbij horen. De volgende stap is om het formulier te verwerken.
Terwijl we het formulier naar zichzelf verzenden en rustige controllers gebruiken, hoeven we alleen het post_index methode en gebruik deze om onze login te verwerken. Als u nog nooit eerder gebruik hebt gemaakt van Auth, ga dan eerst een kijkje nemen in de documentatie voordat u verdergaat.
public function post_index () $ creds = array ('username' => Input :: get ('gebruikersnaam'), 'password' => Input :: get ('password'),); if (Auth :: poging ($ creds)) return Redirect :: to (URL :: to_action ('admin :: home @ index')); else return Redirect :: back () -> with ('error', true); Als de referenties juist zijn, wordt de gebruiker doorgestuurd naar het dashboard. Anders worden ze omgeleid met een fout die we kunnen controleren in de aanmeldingsweergave. Omdat dit slechts sessiegegevens zijn en geen validatiefouten, hoeven we slechts een eenvoudige controle uit te voeren.
@if (Session :: get ('error')) Sorry, je gebruikersnaam of wachtwoord was niet correct. @stop als We moeten ook gebruikers uitloggen; dus laten we een maken get_logout methode en voeg het volgende toe. Hiermee worden gebruikers uitgelogd en vervolgens omgeleid bij een bezoek / Admin / login / logout.
openbare functie get_logout () Auth :: logout (); return Redirect :: to (URL :: to_action ('admin :: home @ index')); Het laatste wat we moeten doen is de login-controller toevoegen aan ons routesbestand.
Route :: controller (array ('admin :: home', 'admin :: login',)); Om te voorkomen dat mensen ons inlogscherm omzeilen, moeten we onze routes filteren om te bepalen of ze geautoriseerde gebruikers zijn. We kunnen het filter maken in onze routes.php, en koppel deze aan onze basiscontroller om te filteren voordat de route wordt weergegeven.
Route :: filter ('auth', function () if (Auth :: guest ()) return Redirect :: to (URL :: to_action ('admin :: login'));); Op dit moment is het enige wat je hoeft te doen dit te noemen in de constructor van onze basis controller. Als we onze inlogcontroller vanaf onze basis zouden uitbreiden, dan zouden we een oneindige lus hebben die uiteindelijk zou verstrijken.
$ this-> filter ('before', 'auth'); Eerder hebben we onze main.blade.php lay-out; nu gaan we er iets mee doen. Laten we een HTML-pagina ophalen en onze activa binnenhalen.
$ Title Asset :: container ( 'header') -> stijlen ()$ InhoudAsset :: container ( 'footer') -> scripts ()
Je zult merken dat ik ook een aantal variabelen heb geëchood: $ title en $ inhoud. We kunnen magische methoden van onze controller gebruiken om gegevens door te geven aan deze. Ik ben ook uitgekomen $ inhoud in de container div dat Bootstrap de styling zal bieden.
Laten we vervolgens de weergave voor ons dashboard maken. Omdat we dit gaan nesten, hoeven we alleen de inhoud die we in onze container willen doen, te plaatsen.
Hallo
Dit is onze dashboardweergave
Bewaar deze als index.blade.php binnen de views / dashboard map in uw bundel.
We moeten nu onze controller instellen om te profiteren van de lay-out en de bestanden die we zojuist hebben gemaakt te bekijken. Binnen de get_index methode die we eerder hebben gemaakt, voeg het volgende toe.
$ this-> layout-> title = 'Dashboard'; $ this-> layout-> nest ('content', 'admin :: dashboard.index'); titel is een magische methode die we vervolgens kunnen uitschrijven als een variabele in onze lay-out. Door het gebruiken van nest, we kunnen een weergave in de lay-out rechtstreeks van onze controller opnemen.
Om de zaken te versnellen, biedt Laravel ons een eenvoudige manier om code vanaf de opdrachtregel uit te voeren. Dit worden "taken" genoemd; het is een goed idee om er een te maken om eenvoudig een nieuwe gebruiker aan de database toe te voegen.
We moeten er alleen voor zorgen dat het bestand de naam van onze taak aanneemt en het in de takendirectory van onze bundel plaatsen. Ik ga dit bellen setup.php, zoals we het zullen gebruiken net na het installeren van de bundel.
gebruik Laravel \ CLI \ Command als commando; gebruik Admin \ Models \ Admin als Admin; class 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' => $ argumenten [0]. ". $ argumenten [1], 'gebruikersnaam' => $ argumenten [2], 'email' => $ argumenten [3], 'wachtwoord' => hash: maken ($ argumenten [4 ]), 'role' => $ role,); $ user = Admin :: create ($ data); echo ($ user)? 'Admin created with!' : 'Fout bij aanmaken van admin!'; Laravel zal een reeks argumenten doormaken; we kunnen deze tellen om ervoor te zorgen dat we precies krijgen wat we willen. Zo niet, dan herhalen we een fout. Je zult ook merken dat we de gebruiken Commando klasse om uit te voeren bundel: publiceren. Hiermee kunt u alle opdrachtregeltaak uitvoeren die is ingebouwd in Laravel in uw toepassing of bundel.
Het belangrijkste wat deze taak doet, is de argumenten die eraan zijn doorgegeven, hash het wachtwoord en een nieuwe admin invoegen in de Admins tafel. Om dit uit te voeren, moeten we het volgende in de opdrachtregel gebruiken.
php artisan admin :: setup voornaam achternaam gebruikersnaam [email protected] wachtwoord
In deze zelfstudie hebben we een dashboardpaneel gemaakt dat gemakkelijk uit te breiden is. Bijvoorbeeld de rollen kolom die we hebben gemaakt, zou u kunnen toestaan te beperken wat uw klanten kunnen zien.
Een bundel kan van alles zijn, van een beheerderspaneel, zoals we vandaag hebben gebouwd, tot Markdown-parsers - of zelfs het volledige Zend Framework (ik maak geen grapje). Alles wat we hier bespreken, zal je op weg helpen naar het schrijven van geweldige Laravel-bundels, die kunnen worden gepubliceerd in de bundelmap van Laravel.
Lees hier meer over het maken van Laravel-bundels op Nettuts+.
