Share
È difficile negare il fatto che la comunità PHP sia entusiasta di Laravel 4. Tra le altre cose, il framework sfrutta la potenza di Composer, il che significa che è in grado di utilizzare qualsiasi pacchetto o script di Packagist.
Nel frattempo, Laravel offre "Bundles", che ci permettono di modulare il codice per l'uso in progetti futuri. La directory del pacchetto è piena di script e pacchetti eccellenti che è possibile utilizzare nelle applicazioni. In questa lezione, ti mostrerò come costruirne uno da zero!
I pacchetti offrono un modo semplice per raggruppare il codice correlato. Se hai familiarità con CodeIgniter, i pacchetti sono abbastanza simili a "Sparks". Questo è evidente quando dai un'occhiata alla struttura delle cartelle.
La creazione di un pacchetto è abbastanza semplice. Per illustrare il processo, costruiremo una piastra di comando del pannello di amministrazione che possiamo utilizzare nei progetti futuri. Innanzitutto, dobbiamo creare una directory "admin" nella nostra cartella "bundle". Prova a replicare la struttura delle cartelle dall'immagine sopra.
Prima di iniziare ad aggiungere qualcosa al nostro pacchetto, dobbiamo prima registrarlo con Laravel. Questo è fatto nella tua applicazione bundles.php file. Una volta aperto questo file, dovresti vedere un array che viene restituito; abbiamo semplicemente bisogno di aggiungere il nostro pacchetto e definire a maniglia. Questo diventerà l'URI in cui accediamo al nostro pannello di amministrazione.
Accentsconagua
'admin' => array ('handles' => 'admin') Qui, ho chiamato il mio, "admin", ma sentiti libero di chiamare il tuo qualunque cosa desideri.
Una volta ottenuta questa impostazione, dobbiamo creare un start.php file. Qui, imposteremo alcune cose, come i nostri spazi dei nomi. Se non ti preoccupi di questo, allora non hai realmente bisogno di un file di avvio per far funzionare il tuo bundle, come previsto.
La classe di autoloader di Laravel ci consente di fare un paio di cose: mappare il nostro controller di base e caricare gli spazi dei nomi.
Autoloader :: map (array ('Admin_Base_Controller' => Bundle :: path ('admin'). 'Controller / base.php',)); Autoloader :: namespaces (array ('Admin \ Models' => Pacchetto :: percorso ('admin'). 'Models', 'Admin \ Libraries' => Pacchetto :: percorso ('admin'). 'Librerie',) ); Namespacing garantirà che non entriamo in conflitto con altri modelli o librerie già inclusi nella nostra applicazione. Noterai che non abbiamo optato per non assegnare spazio ai nostri controller per semplificare le cose.
Per il pannello di amministrazione, sfrutteremo il Bootstrap di Twitter, quindi prendine una copia. Possiamo inserire questo in a pubblico cartella all'interno del nostro pacchetto per poter pubblicare successivamente nella nostra applicazione.
Quando sei pronto per pubblicarli, basta eseguire il seguente comando tramite artigiano.
bundle php artisan: pubblicare admin
Questo copierà la struttura della cartella ei file nella gruppi directory nel nostro pubblico cartella, all'interno della radice dell'installazione di Laravel. Possiamo quindi usarlo nel controller di base del nostro bundle.
È sempre una buona idea impostare un controller di base ed estenderlo da lì. Qui possiamo configurare controller riposanti, definire il layout e includere eventuali risorse. Abbiamo solo bisogno di chiamare questo file, base.php, e inseriscilo nella directory del nostro controller.
In primo luogo, togliamo un po 'di pulizia. Ovviamente vorremmo usare i controller riposanti di Laravel.
pubblico $ restful = true;
E specificheremo un layout che creeremo a breve. Se non sei abituato a controllare i layout, allora sei pronto per una sorpresa.
public $ layout = 'admin :: layouts.main';
Il nome del pacchetto, seguito da due punti, è un paradigma in Laravel che vedremo più in futuro, quindi tieni d'occhio.
Quando gestiamo le risorse all'interno del nostro pacchetto, possiamo fare le cose come previsto e specificare il percorso dalla radice della cartella pubblica. Per fortuna, Laravel è lì per rendere più facile la nostra vita. Nel nostro costrutto, dobbiamo specificare il pacchetto, prima di aggiungerlo ai nostri contenitori di risorse.
Asset :: contenitore ( 'colpo di testa') -> fascio ( 'admin'); Asset :: contenitore ( 'footer') -> fascio ( 'admin');
Se non conosci i contenitori delle risorse, non preoccuparti; sono solo sezioni di una pagina in cui si desidera ospitare le proprie risorse. Qui, inseriremo i fogli di stile nell'intestazione e gli script nel piè di pagina.
Ora, con quello fuori mano, possiamo includere facilmente i nostri stili e script di bootstrap. Il nostro controller di base completato dovrebbe essere simile a:
la classe Admin_Base_Controller estende Controller public $ restful = true; public $ layout = 'admin :: layouts.main'; funzione pubblica __construct () parent :: __ construct (); Asset :: contenitore ( 'colpo di testa') -> fascio ( 'admin'); Asset :: container ('header') -> add ('bootstrap', 'css / bootstrap.min.css'); Asset :: contenitore ( 'footer') -> fascio ( 'admin'); Asset :: container ('footer') -> add ('jquery', 'http://code.jquery.com/jquery-latest.min.js'); Asset :: container ('footer') -> add ('bootstrapjs', 'js / bootstrap.min.js'); / ** * Metodo catch-all per richieste che non possono essere abbinate. * * @param stringa $ metodo * @param array $ parametri * @return Risposta * / public function __call ($ metodo, $ parametri) return Response :: error ('404'); Abbiamo anche portato la richiesta catch-all dal controller di base dell'applicazione per restituire una risposta 404, nel caso non fosse possibile trovare una pagina.
Prima di fare qualsiasi altra cosa, creiamo il file per quel layout, views / layout / main.blade.php, quindi non riscontriamo errori in seguito.
Mentre creiamo un pannello di amministrazione, vorremmo tenere lontane le persone. Per fortuna, possiamo usare il built-in di Laravel auth classe per realizzare questo con facilità ...
In primo luogo, dobbiamo creare la nostra tabella; Userò 'admins' come nome del mio tavolo, ma puoi cambiarlo, se lo desideri. Artisan genererà una migrazione e la inserirà nella directory delle migrazioni del nostro pacchetto. Basta eseguire quanto segue nella riga di comando.
php artisan migrate: make admin :: create_admins_table
Se non conosci il costruttore di schemi, ti consiglio di dare un'occhiata alla documentazione. Includeremo alcune colonne:
Includeremo anche i timestamp predefiniti, al fine di seguire le migliori pratiche.
/ ** * Apportare modifiche al database. * * @return void * / public function up () Schema :: create ('admins', function ($ table) $ table-> increments ('id'); $ table-> string ('name', 200 ); $ table-> string ('username', 32) -> unique (); $ table-> string ('password', 64); $ table-> string ('email', 320) -> unique () ; $ table-> string ('role', 32); $ table-> timestamps ();); / ** * Ripristina le modifiche al database. * * @return void * / public function down () Schema :: drop ('admins'); Ora che abbiamo la nostra struttura di database in atto, dobbiamo creare un modello associato per la tabella. Questo processo è essenzialmente identico a come potremmo ottenere ciò nella nostra applicazione principale. Creiamo il file e il modello, in base alla forma singolare del nostro nome di tabella, ma dobbiamo assicurarci di avere uno spazio dei nomi corretto.
spazio dei nomi Admin \ Models; usa \ Laravel \ Database \ Eloquent \ Model come Eloquent; l'amministratore della classe estende Eloquent
In alto, ci siamo assicurati che stiamo usando lo spazio dei nomi in cui abbiamo definito start.php. Inoltre, in modo che possiamo fare riferimento a Eloquent correttamente, creiamo un alias.
Per mantenere il nostro pacchetto completamente autonomo, dovremo estendere auth. Questo ci permetterà di definire una tabella appena per accedere al nostro pannello di amministrazione e non interferire con l'applicazione principale.
Prima di creare il nostro driver personalizzato, creeremo un file di configurazione, in cui puoi scegliere se desideri utilizzare il nome utente o e-mail colonne dalla tabella del database.
return array ('username' => 'username', 'password' => 'password',); Se vuoi modificare le colonne che utilizzeremo, regola qui i valori.
Abbiamo quindi bisogno di creare il driver. Chiamiamolo "AdminAuth" e includilo nella cartella delle nostre librerie. Poiché stiamo estendendo Auth, dobbiamo solo sovrascrivere un paio di metodi per far funzionare tutto, come previsto.
spazio dei nomi Admin \ Libraries; utilizzare Admin \ Models \ Admin come Admin, Laravel \ Auth \ Drivers \ Eloquent come Eloquent, Laravel \ Hash, Laravel \ Config; la classe AdminAuth estende Eloquent / ** * Ottieni l'utente corrente dell'applicazione. * * Se l'utente è un ospite, è necessario restituire null. * * @param int | oggetto $ token * @return mixed | null * / public function retrieve ($ token) // Restituiamo qui un oggetto se il token passato è un intero (ID) // o se siamo passati un oggetto modello del tipo corretto if (filter_var ($ token, FILTER_VALIDATE_INT)! == false) return $ this-> model () -> find ($ token); else if (get_class ($ token) == new Admin) return $ token; / ** * Tentativo di registrare un utente nell'applicazione. * * @param array $ argomenti * @return void * / tentativo di funzione pubblica ($ arguments = array ()) $ user = $ this-> model () -> where (function ($ query) use ($ arguments) $ username = Config :: get ('admin :: auth.username'); $ query-> where ($ username, '=', $ arguments ['username']); foreach (array_except ($ argomenti, array (' username ',' password ',' remember ')) come $ column => $ val) $ query-> where ($ column,' = ', $ val);) -> first (); // Se le credenziali corrispondono a quelle presenti nel database, sarà solo // registrare l'utente nell'applicazione e ricordarlo se richiesto. $ password = $ argomenti ['password']; $ password_field = Config :: get ('admin :: auth.password', 'password'); se (! is_null ($ utente) e Hash :: check ($ password, $ utente -> $ password_field)) return $ this-> login ($ user-> get_key (), array_get ($ argomenti, 'ricorda ')); return false; protected function model () return new Admin; Ora che abbiamo creato il driver, dobbiamo far sapere a Laravel. Possiamo usare Auth's estendere metodo per farlo nel nostro start.php file.
Auth :: extend ('adminauth', function () return new Admin \ Libraries \ AdminAuth;); Un'ultima cosa che dobbiamo fare è configurare Auth per usarlo in fase di runtime. Possiamo farlo nel costruttore del nostro controller di base con il seguente.
Config :: set ('auth.driver', 'adminauth'); Prima di poter accedere a qualsiasi cosa, dobbiamo creare un controller. Creiamo il nostro controller dashboard, che è quello che vedremo dopo l'accesso.
Dato che vorremmo che fosse mostrato alla radice del nostro pacchetto (ovvero l'handle definito in precedenza), dovremo chiamare questo home.php. Laravel usa la parola chiave 'home' per stabilire cosa vuoi mostrare alla radice della tua applicazione o bundle.
Estendi il controller di base e crea una vista indice. Per ora, semplicemente ritorna "Hello World" in modo che possiamo assicurarci che tutto funzioni correttamente.
la classe Admin_Home_Controller estende Admin_Base_Controller public function get_index () return 'Hello World';
Ora che il nostro controller è configurato, possiamo instradarci verso di esso. Creare un routes.php nel tuo pacchetto, se non l'hai già fatto. Simile alla nostra applicazione principale, ogni pacchetto può avere il proprio file di percorsi che funziona in modo identico.
Route :: controller (array ('admin :: home',)); Qui, ho registrato il controller di casa, a cui Laravel assegnerà automaticamente /. Successivamente, aggiungeremo il nostro controller di login all'array.
Se ti dirigi / admin (o qualsiasi handle definito in precedenza) nel tuo browser, dovresti vedere "Hello World".
Creiamo il controller di login, invece di estendere il controller di base, estenderemo invece il controller principale di Laravel. La ragione di questa decisione apparirà presto.
Poiché non stiamo estendendo, abbiamo bisogno di impostare un paio di cose prima di iniziare: i layout riposanti, il driver di autenticazione corretto e le nostre risorse.
la classe Admin_Login_Controller estende Controller public $ restful = true; funzione pubblica __construct () parent :: __ construct (); Config :: set ('auth.driver', 'adminauth'); Asset :: contenitore ( 'colpo di testa') -> fascio ( 'admin'); Asset :: container ('header') -> add ('bootstrap', 'css / bootstrap.min.css'); Creiamo anche la nostra visione. Useremo Blade, il motore dei modelli di Laravel, per accelerare un po 'le cose. All'interno della directory views dei bundle, crea una directory 'login' e un file 'index.blade.php' al suo interno.
Inseriremo una struttura di pagina HTML standard e faremo eco alle risorse.
Accesso Asset :: contenitore ( 'header') -> stili ()
Ora, assicuriamoci che la vista sia stata creata nel controller. Poiché stiamo usando controller riposanti, possiamo sfruttare il verbo "get" nel nostro metodo.
funzione pubblica get_index () return View :: make ('admin :: login.index'); Eccezionale! Ora siamo pronti per iniziare a costruire il nostro modulo, che possiamo creare con il Modulo classe.
Form :: open () Form :: label ('username', 'Username') Form :: text ('username') Form :: label ('password') , 'Password') Form :: password ('password') Form :: submit ('Login', array ('classe' => 'btn btn-success')) Form :: token () Form :: close () 
Sopra, abbiamo creato un modulo che pubblicherà su se stesso (esattamente ciò che vogliamo), insieme a vari elementi di forma e etichette per accompagnarlo. Il prossimo passo è elaborare il modulo.
Mentre pubblichiamo il modulo su se stesso e usiamo controller riposanti, abbiamo solo bisogno di creare il post_index metodo e usarlo per elaborare il nostro login. Se non hai mai usato Auth prima, vai a dare un'occhiata alla documentazione prima di proseguire.
public function post_index () $ creds = array ('username' => Input :: get ('username'), 'password' => Input :: get ('password'),); if (Auth :: attempt ($ creds)) return Redirect :: to (URL :: to_action ('admin :: home @ index')); else return Redirect :: back () -> with ('error', true); Se le credenziali sono corrette, l'utente verrà reindirizzato alla dashboard. In caso contrario, verranno reindirizzati con un errore che è possibile verificare nella vista di accesso. Poiché si tratta solo di dati di sessione e non di errori di convalida, è sufficiente implementare un semplice controllo.
@if (Session :: get ('error')) Spiacenti, il tuo nome utente o password non sono corretti. @finisci se Dovremo anche registrare gli utenti; quindi creiamo un get_logout metodo e aggiungere quanto segue. Questo registrerà gli utenti, quindi li reindirizzerà durante la visita / Admin / login / logout.
funzione pubblica get_logout () Auth :: logout (); return Redirect :: to (URL :: to_action ('admin :: home @ index')); L'ultima cosa che dovremmo fare è aggiungere il controller di login al nostro file di rotte.
Route :: controller (array ('admin :: home', 'admin :: login',)); Per impedire alle persone di aggirare la nostra schermata di accesso, dobbiamo filtrare i nostri percorsi per determinare se sono utenti autorizzati. Possiamo creare il filtro nel nostro routes.php, e collegalo al nostro controller di base, per filtrare prima che venga visualizzato il percorso.
Route :: filter ('auth', function () if (Auth :: guest ()) restituisce Redirect :: to (URL :: to_action ('admin :: login'));); A questo punto, tutto ciò che resta da fare è chiamare questo nel costruttore del nostro controller di base. Se estendessimo il nostro controller di login dalla nostra base, avremmo un ciclo infinito che alla fine scadrà.
$ this-> filter ('before', 'auth'); In precedenza, abbiamo creato il nostro main.blade.php disposizione; ora, faremo qualcosa con esso. Prendiamo una pagina HTML e le nostre risorse vengono portate in.
$ Title Asset :: contenitore ( 'header') -> stili ()$ ContentAsset :: contenitore ( 'footer') -> script ()
Noterai che ho anche echeggiato un paio di variabili: $ titolo e $ content. Saremo in grado di utilizzare i metodi magici del nostro controller per passare i dati a questi. Ho anche spuntato $ content all'interno del contenitore div che Bootstrap fornirà lo styling per.
Successivamente, creiamo la vista per la nostra dashboard. Mentre annideriamo questo, abbiamo solo bisogno di mettere il contenuto che vogliamo mettere nel nostro contenitore.
Ciao
Questa è la nostra vista dashboard
Salva questo come index.blade.php all'interno del visualizzazioni / cruscotto directory all'interno del tuo pacchetto.
Ora abbiamo bisogno di impostare il nostro controller per sfruttare il layout e visualizzare i file che abbiamo appena creato. All'interno del get_index metodo che abbiamo creato in precedenza, aggiungere il seguente.
$ this-> layout-> title = 'Dashboard'; $ this-> layout-> nest ('content', 'admin :: dashboard.index'); titolo è un metodo magico che possiamo quindi echeggiare come variabile nel nostro layout. Usando nido, siamo in grado di includere una vista all'interno del layout direttamente dal nostro controller.
Per velocizzare le cose, Laravel ci fornisce un modo semplice per eseguire codice dalla riga di comando. Questi sono chiamati "Compiti"; è una buona idea crearne uno per aggiungere facilmente un nuovo utente al database.
Dobbiamo solo assicurarci che il file assuma il nome del nostro compito e inserirlo nella directory dei compiti del nostro bundle. Lo chiamerò setup.php, come lo useremo subito dopo l'installazione del bundle.
usa Laravel \ CLI \ Command as Command; utilizzare Admin \ Models \ Admin come amministratore; classe Admin_Setup_Task esecuzione funzione pubblica ($ argomenti) if (vuoto ($ argomenti) | | conteggio ($ argomenti) < 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' => $ argomenti [0]. ". $ argomenti [1], 'nomeutente' => $ argomenti [2], 'email' => $ argomenti [3], 'password' => Hash :: make ($ argomenti [4 ]), 'role' => $ role,); $ user = Admin :: create ($ data); echo ($ user)? 'Admin creato con successo!' : 'Errore nella creazione di admin!'; Laravel passerà attraverso una serie di argomenti; possiamo contarli per assicurarci di ottenere esattamente ciò che vogliamo. In caso contrario, echeggeremo un errore. Noterai anche che stiamo usando il Comando classe da eseguire Bundle: pubblicare. Ciò ti consentirà di eseguire qualsiasi attività da riga di comando incorporata in Laravel all'interno dell'applicazione o del pacchetto.
La cosa principale che fa questa operazione è afferrare gli argomenti passati, hash la password e inserire un nuovo admin nel file amministratori tavolo. Per eseguire ciò, è necessario utilizzare quanto segue nella riga di comando.
php artisan admin :: setup firstname cognome username [email protected] password
In questo tutorial, abbiamo creato un pannello di amministrazione standard molto semplice da estendere. Ad esempio, il ruoli la colonna che abbiamo creato potrebbe consentire di limitare ciò che i tuoi clienti sono in grado di vedere.
Un bundle può essere qualsiasi cosa, da un pannello di amministrazione, come quello che abbiamo costruito oggi, ai parser di Markdown - o persino all'intero Zend Framework (non sto scherzando). Tutto ciò che abbiamo trattato qui ti metterà sulla buona strada per scrivere fantastici pacchetti Laravel, che possono essere pubblicati nella directory dei pacchetti di Laravel.
Ulteriori informazioni sulla creazione di bundle Laravel qui su Nettuts+.
