Share
Grazie alla classe fieldset di FuelPHP, lavorare con i moduli non potrebbe essere più facile. Con poche righe di codice, puoi facilmente generare e convalidare un modulo. Oggi, impareremo come fare proprio questo!
Il
fieldsetla classe viene utilizzata per creare un modulo e gestirne la convalida in modo orientato agli oggetti. Usa ilModuloeValidazioneclassi. Questa classe, di per sé, ha il solo scopo di modellare il fieldset e i suoi campi, mentre le altre due classi eseguono il peso del lavoro.
Abbiamo bisogno di un'installazione di FuelPHP con un pacchetto RM abilitato. Userò un database MySQL con una tabella di esempio. Mentre il fieldset la classe può essere configurata per utilizzare un modello normale, l'utilizzo di un ORM ci farà risparmiare un po 'di tempo.
Se non hai recensito le prime due parti della serie FuelPHP qui su Nettuts +, ora è un ottimo momento per verificare la prima e la seconda parte, di Phil Sturgeon.
Impostare una connessione al database a carburante / app / config / sviluppo / db.php.
Accentsconagua
return array ('default' => array ('connection' => array ('dsn' => 'mysql: host = localhost; dbname = blog', 'username' => 'root', 'password' => 'root ',),),); Abilita il pacchetto ORM attraverso carburante / app / config.php
'packages' => array ('orm',), E, infine, ecco l'SQL per il tavolo che sto usando per questo tutorial.
CREATE TABLE 'blog'. 'Posts' ('id' INT NOT NULL AUTO_INCREMENT PRIMARY KEY, 'post_title' VARCHAR (100) NOT NULL, 'post_content' TESTO NON NULL, 'author_name' VARCHAR (65) NOT NULL, 'author_email' VARCHAR (80) NOT NULL, 'author_website' VARCHAR (60) NULL, 'post_status' TINYINT NULL) ENGINE = INNODB; Abbiamo bisogno di un modello per il nostro controller per interagire con la tabella dei post. Vai avanti e crea un post.php dentro app / classes / modello /. Creare un Model_Post classe e assicurarsi che si estenda \ Orm \ modello. L'ORM utilizzerà automaticamente il messaggi tabella nel nostro database dal momento che abbiamo utilizzato il singolare di "post". Se si desidera impostare una tabella diversa, impostare una proprietà statica chiamata $ _table_name.
class Model_Post estende \ Orm \ Model protected static $ _table_name = 'posts'; // imposta manualmente il nome della tabella
Dovremmo specificare le colonne della nostra tabella dei post all'interno del nostro modello. Allo stesso tempo, possiamo anche impostare etichette, formare regole di convalida da utilizzare con la nostra classe fieldset per generare il modulo. Tutti questi vanno in un array associato, chiamato $ _properies. Con tutto ciò che è a posto, il nostro modello finale dovrebbe assomigliare così:
class Model_Post estende \ Orm \ Model protected static $ _table_name = 'posts'; statico protetto $ _properties = array ('id', 'post_title' => array (// nome colonna 'data_type' => 'stringa', 'etichetta' => 'Post Title', // etichetta per la convalida del campo di input ' '=> array (' required ',' max_length '=> array (100),' min_length '=> array (10)) // regole di convalida),' post_content '=> array (' data_type '=>' string ' , 'label' => 'Post Content', 'validation' => array ('required')), 'author_name' => array ('data_type' => 'string', 'label' => 'Nome autore', 'validation' => array ('required', 'max_length' => array (65), 'min_length' => array (2))), 'author_email' => array ('data_type' => 'stringa', ' label '=>' Email autore ',' validation '=> array (' richiesto ',' valid_email ')),' author_website '=> array (' data_type '=>' stringa ',' etichetta '=>' sito web dell'autore ',' validation '=> array (' required ',' valid_url ',' max_length '=> array (60))),' post_status '=> array (' data_type '=>' stringa ',' etichetta '=> 'Post Status', 'validation' => array ('required'), 'form' => array ('type' => 'select', 'options' => array (1 => 'Publ ished ', 2 =>' Draft ')),)); Esaminiamo quali opzioni possiamo usare. tipo di dati tiene semplicemente il tipo dei campi. Potrebbe essere stringa, intero o mysql_date. Il valore per il etichetta la proprietà verrà mostrata come etichetta del campo una volta generato il modulo. convalida accetta una serie di regole di convalida. Per impostazione predefinita, questi campi saranno campi di inserimento del testo. Usando il modulo, puoi renderlo un select o texarea.
L'ORM tratta la colonna denominata id come principale e non verrà mostrato quando si genera un modulo. Se la colonna della chiave primaria del tuo tavolo è diversa, usa il $ _primary_key proprietà per specificarlo.
/ ** * Post Model * / class Model_Post estende \ Orm \ Model protected static $ _table_name = 'posts'; statico protetto $ _primary_key = array ('id'); // puoi impostare più colonne, ... $ _primary_key => array ('id', 'user_id') Ora che il modello è pronto, creiamo il controller. I controller dovrebbero essere collocati all'interno carburante / app / classes / regolatore /. Ho creato un controller, chiamato Controller_Posts (posts.php) e esteso da Controller_Template.
/ ** * Post Controller fuel / app / classes / controller / posts.php * / class Controller_Posts estende \ Controller_Template // elenco post funzione action_index () // aggiungi una nuova funzione action_add () // funzione di modifica action_edit ($ id)
Gli utenti potranno visualizzare un elenco di post, aggiungerne di nuovi o modificarne uno esistente. Poiché sto utilizzando il controller modello, posso utilizzare un file modello di base con cui lavorare. I modelli vanno dentro carburante / app / views / template.php
0):?>
', $ messaggio,''; ?>
Questo è semplicemente un markup HTML standard con il bootstrap di Twitter. Il $ content la variabile avrà il contenuto. Possiamo impostare una serie di messaggi e, se lo facciamo, verrà stampato come lista non ordinata.
È qui che inizia il divertimento. Stiamo per generare il modulo per l'aggiunta di nuovi post. Come avrai intuito, lavoreremo con il action_add () metodo. Generiamo il modulo e lo passiamo al nostro modello.
// aggiungi una nuova funzione action_add () $ fieldset = Fieldset :: forge () -> add_model ('Model_Post'); $ form = $ fieldset-> form (); $ this-> template-> set ('content', $ form-> build (), false); // false indicherà al carburante di non convertire i tag html in una stringa sicura. Fieldset :: fucina () restituirà una nuova istanza della classe fieldset. È lo stesso di fare nuovo Fieldset. Tuttavia, utilizzando il fucina metodo qui, possiamo nominare le nostre istanze. Se chiamiamo due volte un'istanza con lo stesso nome, verrà restituita un'istanza esistente se disponibile [il modello di fabbrica]. Per denominare la tua istanza, passa il nome al fucina metodo. Fieldset :: forgia ( 'new_post')
Usando il add_model metodo, passiamo il modello da cui vogliamo generare i moduli. Fieldset prenderà i dati da $ _properties per generare il modulo. Chiamando il modulo() il metodo dall'oggetto fieldset restituirà un'istanza Modulo classe, e chiamando il costruire() metodo, possiamo ottenere un output html (stringa) del modulo.
$ this-> template-> set ('content', $ form, false); Alla fine, passiamo al modulo $ al modello come contenuto. È un altro metodo per passare variabili a un modello $ this-> template-> content = $ form.
Avvia il browser e naviga verso http: //path_to_site/index.php/posts/add. Dovresti vedere una forma identica a questa.
Nessun pulsante di invio? Risolviamolo. Abbiamo bisogno di aggiungere un nuovo campo al nostro oggetto modulo.
$ form-> add ('submit', ", array ('type' => 'submit', 'value' => 'Aggiungi', 'class' => 'btn medium primary')); Usando il Inserisci metodo possiamo aggiungere campi aggiuntivi al nostro modulo. Il primo parametro è il nostro nuovo nome di campo, il secondo è per l'etichetta, per il terzo parametro passiamo una serie di attributi.
Dopo aver aggiunto questo, il nostro action_add () sarà simile a questo.
function action_add () $ fieldset = Fieldset :: forge () -> add_model ('Model_Post'); $ form = $ fieldset-> form (); $ form-> add ('submit', ", array ('type' => 'submit', 'value' => 'Aggiungi', 'class' => 'btn medium primary')); $ this-> template -> set ('content', $ form-> build (), false); E la nostra forma ...
Ora che abbiamo un bel modulo, lo convalidiamo e salviamo nel database. L'oggetto fieldset include un'istanza dalla classe di convalida di FuelPHP. Tutte le regole sono state applicate e pronte per l'uso.
function action_add () $ fieldset = Fieldset :: forge () -> add_model ('Model_Post'); $ form = $ fieldset-> form (); $ form-> add ('submit', ", array ('type' => 'submit', 'value' => 'Aggiungi', 'class' => 'btn medium primary')); if ($ fieldset- > validation () -> run () == true) $ fields = $ fieldset-> validated (); $ post = new Model_Post; $ post-> post_title = $ fields ['post_title']; $ post-> post_content = $ fields ['post_content']; $ post-> nome_origine = $ campi ['nome_autore']; $ post-> author_email = $ campi ['author_email']; $ post-> author_website = $ campi ['author_website'] ; $ post-> post_status = $ campi ['post_status']; if ($ post-> save ()) \ Response :: redirect ('posts / edit /'.$ post-> id); else $ this-> template-> messages = $ fieldset-> validation () -> errors (); $ this-> template-> set ('content', $ form-> build (), false); $ Fieldset-> convalida () restituisce un'istanza della classe di convalida e accedendone correre() metodo possiamo controllare se la convalida è passata. Se è così, aggiungiamo un nuovo post al nostro database. $ Fieldset-> convalidato () restituirà una matrice di campi convalidati. Se la convalida viene superata e il post viene salvato, l'utente verrà reindirizzato alla pagina di modifica, altrimenti passerà gli errori di convalida al nostro modello come variabile del messaggio.
Se provi a inviare alcuni dati non validi, otterrai un risultato come questo:
Tutto sembra a posto, tranne per un problema: i dati inviati non vengono visualizzati dopo l'aggiornamento della pagina. Non preoccuparti, una chiamata al metodo e il gioco è fatto.
$ fieldset = Fieldset :: forge () -> add_model ('Model_Post') -> repopulate (); // Il metodo ripopolare popola il modulo con i dati inviati Splendido, no? Aggiungi alcuni dati validi e reindirizzerà a action_edit () metodo, che non è ancora pronto.
La modifica di una sezione è praticamente la stessa della nostra sezione per aggiungere post. Tranne che dobbiamo popolare i dati con un post esistente. Ho intenzione di duplicare il action_add codice.
function action_edit ($ id) $ post = \ Model_Post :: find ($ id); $ fieldset = Fieldset :: forge () -> add_model ('Model_Post') -> populate ($ post); // model post object viene passato al metodo populate $ form = $ fieldset-> form (); $ form-> add ('submit', ", array ('type' => 'submit', 'value' => 'Save', 'class' => 'btn medium primary')); if ($ fieldset- > validation () -> run () == true) $ fields = $ fieldset-> validated (); // $ post = new Model_Post; $ post-> post_title = $ fields ['post_title']; $ post- > post_content = $ fields ['post_content']; $ post-> author_name = $ campi ['author_name']; $ post-> author_email = $ campi ['author_email']; $ post-> author_website = $ campi ['author_website ']; $ post-> post_status = $ campi [' post_status ']; if ($ post-> save ()) \ Response :: redirect (' posts / edit /'.$ id); else $ questo-> modello-> messaggi = $ fieldset-> validation () -> errors (); $ this-> template-> set ('content', $ form-> build (), false); Con alcune piccole modifiche al nostro action_add () metodo, abbiamo il nostro metodo di modifica. ripopolare() il metodo è stato sostituito da popolare() metodo. Usando il popolare metodo, possiamo popolare un modulo con i dati di un post esistente.
In questo caso, prendiamo il post dal nostro database usando il $ id parametro, quindi passarlo al metodo richiesto. Non abbiamo bisogno $ post = new Model_Post; più perché non aggiungiamo nulla al database. Il $ postale l'oggetto che creiamo all'inizio viene utilizzato per assegnare i nuovi valori. Una volta modificato, verrà reindirizzato alla sua schermata di modifica. Sono stati fatti! Aggiungi alcuni post e prova a modificarli.
Costruiamo la sezione dell'elenco in modo che gli utenti possano vedere tutti i post in un unico posto.
La quotazione è gestita dal action_index () metodo
// lista messaggi funzione action_index () $ posts = \ Model_Post :: find ('all'); $ view = \ View :: forge ('listing'); $ view-> set ('posts', $ posts, false); $ this-> template-> content = $ view; // Nel file di configurazione Gli oggetti di visualizzazione sono inseriti nella whitelist in modo che Fuelphp non sfugga all'html. Model_Post :: trovare ( 'all') restituirà una serie di oggetti post per tutti i nostri post. utilizzando Vista :: fucina (), un nuovo oggetto vista è istanziato. Il parametro per Vista :: fucina () è il nome per la nostra vista specifica. Si trova a app / views / listing.php. La matrice di oggetti post ($ messaggi) viene quindi passato alla nostra vista. La visualizzazione dell'elenco si occuperà dell'inserzione e alla fine assegneremo la vista a $ This-> template-> contenuti.
Nella vista, passiamo attraverso $ messaggi e generare la lista.
titolo del post; ?> id, '[Modifica]');?>
POST_CONTENT; ?>
Di nome dell'autore; ?>
email_autore; ?>
author_website; ?>
Se hai qualche post nel database, sarà simile a questo.
Tutto sembra funzionare correttamente; tuttavia, ci sono alcuni problemi minori. Il modulo generato ha un campo di testo per il contenuto del post, che sarebbe meglio come una textarea.
// Model_Post 'post_content' => array ('data_type' => 'string', 'label' => 'Post Content', 'validation' => array ('richiesto'), 'form' => array ('tipo '=>' textarea ') // ci darà una textarea), È possibile passare tutti i tipi di campo testo, area di testo, selezione, radio ecc. Per gli elementi di selezione o radio, è possibile impostare le opzioni. È anche possibile impostare le opzioni per una selezione usando un'altra tabella. Se si desidera modificare il layout predefinito, inserire un file di configurazione del modulo in carburante / app / config / form.php Se non sei sicuro di cosa mettere lì, copia le cose da carburante / core / config / form.php. Carburante utilizza questo file per generare i moduli.
Spero che ora abbia una chiara comprensione della classe fieldset. Se avete domande, fatemelo sapere nei commenti qui sotto. Grazie mille per la lettura!
