Oggi passeremo attraverso il concetto di controller in OpenCart 2.x. Con il rilascio della versione OpenCart 2.x, hanno introdotto modifiche al framework che richiedono un aggiornamento se sono stati creati moduli personalizzati nella versione precedente: OpenCart 1.x. Esamineremo un esempio pratico di ciò che chiameremo Guestbook in questo tutorial.

Prima di andare avanti in questo articolo, potresti considerare questo come un seguito a ciò che ho scritto in precedenza. In quell'articolo ho spiegato come creare una pagina personalizzata in OpenCart 1.x e se hai già seguito quell'articolo, puoi saltare rapidamente la maggior parte delle sezioni oggi! 

Ovviamente OpenCart 2.x sarà discusso oggi, quindi assicurati di seguire da vicino il codice.

Se ti piacerebbe vedere più teoria sul modello di framework OpenCart e sui controller, potresti passare attraverso un paio delle sezioni iniziali di quell'articolo. Detto questo, non c'è nulla che ti impedisca di seguire subito questo articolo, perché non salterò alcun elemento essenziale.

Perché un controller personalizzato?

Qualcosa che potresti chiedere in primo luogo: perché un controller personalizzato? Comprendiamo rapidamente a cosa serve il controller in OpenCart prima di iniziare.

Nel contesto di OpenCart, il controllore è una componente indispensabile del framework che tratta direttamente il processo di routing e rende l'interfaccia utente. Nel processo, si occupa di altri componenti importanti come lingua, modello e vista per costruire il risultato finale.

Quando accedi a qualsiasi pagina in OpenCart, il framework OpenCart cerca il controller corrispondente e delega ulteriormente l'elaborazione ad esso. Essendo modulare per natura, il framework OpenCart fornisce diversi controller che gestiscono funzionalità raggruppate logicamente.

Ad esempio, il account gruppo contiene controller che gestiscono login, registrazione, profilo e casi d'uso simili. Allo stesso modo, il check-out gruppo di controllori gestisce il processo di creazione degli ordini.

In poche parole, quando si desidera creare una funzionalità che non si trova nel nucleo di OpenCart e se richiede un nuovo URL, ovvero una route nella terminologia di OpenCart, è consigliabile utilizzare un controller personalizzato. Ti dà il controllo completo del processo di creazione della pagina, quali elementi vuoi mostrare sulla tua pagina personalizzata.

Crea un controller personalizzato

Oggi implementeremo una funzionalità di Guestbook di base che dimostra il concetto di controller personalizzati. Nel fare ciò, costruiremo un'interfaccia nel front-end che consenta agli utenti ospiti di inviare il proprio feedback inserendo il proprio nome e il proprio messaggio.

Prima di procedere, assicurati di avere un'installazione funzionante di OpenCart 2.3.x. E questo è praticamente tutto per iniziare a lavorare sulla nostra funzione Guestbook.

Per coloro che non hanno familiarità con la struttura OpenCart, il posto dove cercare i controller front-end è Catalogo / regolatore. È la directory che gestisce tutti i controller per gruppo, in base alle funzionalità che forniscono.

Nel nostro caso, creeremo un gruppo separato chiamato libro degli ospiti. Vai avanti e crea una directory Catalogo / regolatore / guestbook. All'interno di quella directory, crea un entry.php file con il seguente contenuto. È un file controller che gestisce la logica dell'applicazione e la logica di invio delle funzionalità del nostro Guestbook.

load-> lingua ( 'libro degli ospiti / guestbook'); $ This-> documento-> setTitle ($ this-> language-> get ( 'HEADING_TITLE')); se (($ this-> request-> server ['REQUEST_METHOD'] == 'POST') && $ this-> validate ()) $ this-> load-> model ('guestbook / guestbook'); $ data ['subject'] = sprintf ('Nuova voce del guestbook inviata da% s', $ this-> request-> post ['guest_name']); $ data ['message'] = $ this-> request-> post ['guest_message']; $ This-> model_guestbook_guestbook-> processGuestbookEntry ($ data); $ this-> session-> data ['success'] = $ this-> language-> get ('text_success'); $ this-> response-> redirect ($ this-> url-> link ('guestbook / entry', ", true)); $ data ['success'] ="; if (isset ($ this-> session-> data ['success'])) $ data ['success'] = $ this-> session-> data ['success']; unset ($ this-> session-> dati [ 'successo']);  $ data ['breadcrumbs'] = array (); $ data ['breadcrumbs'] [] = array ('testo' => $ this-> lingua-> get ('text_home'), 'href' => $ this-> url-> link ('common / home' )); $ data ['breadcrumbs'] [] = array ('text' => $ this-> language-> get ('heading_title'), 'href' => $ this-> url-> link ('guestbook / entry' , ", true)); $ data ['heading_title'] = $ this-> language-> get ('heading_title'); $ data ['entry_guest_name'] = $ this-> language-> get ('entry_guest_name') ; $ data ['entry_guest_message'] = $ this-> language-> get ('entry_guest_message'); $ data ['entry_submit'] = $ this-> language-> get ('entry_submit'); if (isset ($ this-> error ['guest_name'])) $ data ['error_guest_name'] = $ this-> error ['guest_name']; else $ data ['error_guest_name'] = ";  if (isset ($ this-> error ['guest_message'])) $ data ['error_guest_message'] = $ this-> error ['guest_message'];  else $ data ['error_guest_message'] = "; $ data ['action'] = $ this-> url-> link ('guestbook / entry',", true); if (isset ($ this-> request-> post ['guest_name'])) $ data ['guest_name'] = $ this-> request-> post ['guest_name'];  else $ data ['guest_name'] = "; if (isset ($ this-> request-> post ['guest_message'])) $ data ['guest_message'] = $ this-> request-> post ['guest_message']; else $ data ['guest_message'] = ";  $ data ['column_left'] = $ this-> load-> controller ('common / column_left'); $ data ['column_right'] = $ this-> load-> controller ('common / column_right'); $ data ['content_top'] = $ this-> load-> controller ('common / content_top'); $ data ['content_bottom'] = $ this-> load-> controller ('common / content_bottom'); $ data ['footer'] = $ this-> load-> controller ('common / footer'); $ data ['header'] = $ this-> load-> controller ('common / header'); $ this-> response-> setOutput ($ this-> load-> view ('guestbook / entry', $ data));  protected function validate () if (utf8_strlen (trim ($ this-> request-> post ['guest_name']))) < 1)  $this->error ['guest_name'] = $ this-> language-> get ('error_guest_name');  if (utf8_strlen (trim ($ this-> request-> post ['guest_message']))) < 1)  $this->error ['guest_message'] = $ this-> language-> get ('error_guest_message');  return! $ this-> error;  

Secondo le convenzioni di denominazione di OpenCart, il nome della classe inizia con controllore parola chiave seguita dal nome della directory, Guestbook nel nostro caso, in cui risiede il file di classe. Inoltre, il nome del file di classe, Iscrizione nel nostro caso, viene aggiunto alla fine.

Ogni classe di controller fornisce di fatto indice metodo che gestisce la maggior parte della logica del controller. Successivamente, passeremo attraverso il codice in indice metodo, e creeremo anche altri file se necessario.

La maggior parte delle volte inizieremo includendo il file di lingua per il gruppo specifico. È il modo in cui OpenCart gestisce le etichette in linguaggio statico in tutta l'applicazione. Ovviamente, ciò rende l'implementazione di siti multilingua un gioco da ragazzi.

$ This-> load-> lingua ( 'libro degli ospiti / guestbook');

Prima di andare avanti, creiamo il file di lingua corrispondente in modo che il nostro controller possa trovarlo. Creare un Catalogo / lingua / it-IT / guestbook / guestbook.php file con il seguente contenuto.

Come puoi vedere, stiamo solo assegnando etichette con i loro valori nella matrice del linguaggio.
Tornando al nostro controller, la prossima cosa è impostare il tag title HTML per la nostra pagina.
$ This-> documento-> setTitle ($ this-> language-> get ( 'HEADING_TITLE'));
Gli utenti con gli occhi acuti avranno notato che abbiamo usato il HEADING_TITLE variabile di lingua definita nel file di lingua creato un momento fa.
Per capire la prossima parte di codice, dobbiamo creare un file di modello. Quindi per un momento, ti dividerò per creare il file del modello su Catalogo / modello / guestbook / guestbook.php con i seguenti contenuti.
protocol = $ this-> config-> get ('config_mail_protocol'); $ mail-> parameter = $ this-> config-> get ('config_mail_parameter'); $ mail-> smtp_hostname = $ this-> config-> get ('config_mail_smtp_hostname'); $ mail-> smtp_username = $ this-> config-> get ('config_mail_smtp_username'); $ mail-> smtp_password = html_entity_decode ($ this-> config-> get ('config_mail_smtp_password'), ENT_QUOTES, 'UTF-8'); $ mail-> smtp_port = $ this-> config-> get ('config_mail_smtp_port'); $ mail-> smtp_timeout = $ this-> config-> get ('config_mail_smtp_timeout'); $ Mail-> Setto ($ this-> config-> get ( 'config_email')); $ Mail-> setFrom ($ this-> config-> get ( 'config_email')); $ mail-> setSender (html_entity_decode ($ this-> config-> get ('config_name'), ENT_QUOTES, 'UTF-8')); $ Mail-> SetSubject ($ dati [ 'soggetto']); $ Mail-> setText ($ dati [ 'messaggio']); $ Mail-> send ();  
In OpenCart, il modello è responsabile della gestione della logica di business dell'applicazione. Se desideri implementare qualsiasi logica che coinvolga un database, questo è il posto in cui dovrebbe andare.
La convenzione di denominazione della classe del modello è simile a quella della classe controller. Per semplificare le cose, abbiamo implementato un metodo processGuestbookEntry che avvisa l'amministratore dello store via email quando un utente invia una voce del Guestbook. Abbastanza semplice, eh?
Torniamo al nostro controller ed esaminiamo il prossimo pezzo di codice nella coda.
se (($ this-> request-> server ['REQUEST_METHOD'] == 'POST') && $ this-> validate ()) $ this-> load-> model ('guestbook / guestbook'); $ data ['subject'] = sprintf ('Nuova voce del guestbook inviata da% s', $ this-> request-> post ['guest_name']); $ data ['message'] = $ this-> request-> post ['guest_message']; $ This-> model_guestbook_guestbook-> processGuestbookEntry ($ data); $ this-> session-> data ['success'] = $ this-> language-> get ('text_success'); $ this-> response-> redirect ($ this-> url-> link ('guestbook / entry', ", true));
Controlla un valido INVIARE richiede e fa la convalida di base dei dati inviati dall'utente chiamando il convalidare metodo.
Il codice $ This-> load-> modello ( 'libro degli ospiti / guestbook') è usato per caricare il modello che abbiamo definito un momento fa. Subito dopo, prepariamo il $ data array basato sull'input dell'utente e chiamare il processGuestbookEntry metodo, che informa l'amministratore del negozio sulla voce del Guestbook. Infine, reindirizziamo l'utente alla pagina di iscrizione del Guestbook.
Andando avanti nel controller, il frammento seguente imposta il messaggio di successo che verrà visualizzato dopo l'invio del modulo.
$ data ['success'] = "; if (isset ($ this-> session-> data ['success'])) $ data ['success'] = $ this-> session-> data ['success' ]; unset ($ this-> session-> data ['success']);
In seguito, c'è uno snippet che viene usato per costruire i link breadcrumb per la pagina.
$ data ['breadcrumbs'] = array (); $ data ['breadcrumbs'] [] = array ('testo' => $ this-> lingua-> get ('text_home'), 'href' => $ this-> url-> link ('common / home' )); $ data ['breadcrumbs'] [] = array ('text' => $ this-> language-> get ('heading_title'), 'href' => $ this-> url-> link ('guestbook / entry' ,", vero) );
Il frammento successivo è importante, ed è qualcosa che userai la maggior parte del tempo per passare le informazioni dal metodo del controller al modello di visualizzazione.
$ data ['heading_title'] = $ this-> language-> get ('heading_title'); $ data ['entry_guest_name'] = $ this-> language-> get ('entry_guest_name'); $ data ['entry_guest_message'] = $ this-> language-> get ('entry_guest_message'); $ data ['entry_submit'] = $ this-> language-> get ('entry_submit');
Simile a quello di assegnare variabili, OpenCart inizializza elementi comuni dell'intestazione della pagina, del piè di pagina e simili, come illustrato nello snippet seguente.
$ data ['column_left'] = $ this-> load-> controller ('common / column_left'); $ data ['column_right'] = $ this-> load-> controller ('common / column_right'); $ data ['content_top'] = $ this-> load-> controller ('common / content_top'); $ data ['content_bottom'] = $ this-> load-> controller ('common / content_bottom'); $ data ['footer'] = $ this-> load-> controller ('common / footer'); $ data ['header'] = $ this-> load-> controller ('common / header');
Infine, chiama il modello di visualizzazione per rendere la pagina effettiva!
$ this-> response-> setOutput ($ this-> load-> view ('guestbook / entry', $ data));
Ovviamente, non abbiamo ancora creato un modello di visualizzazione. È il momento perfetto per farlo! Vai avanti e crea un Catalogo / view / theme / default / template / guestbook / entry.tpl file con il seguente contenuto.
 
 
  
">
  
  
 
  
        
 
 
 
  
   
  
 
 
  
 <?php echo $guest_message; ?>  
  
 
 
   
  
 
 
 
 
 
  
Questo è il nostro file modello di visualizzazione principale che è responsabile della visualizzazione del contenuto della nostra pagina Guestbook. In questo file, abbiamo appena usato le variabili che sono state impostate nel controller indice metodo.
È importante notare che la reattività è qualcosa che viene integrato con le recenti versioni di OpenCart supportate dal framework Bootstrap. Oltre a questo, è abbastanza normale materiale HTML che è abbastanza facile da capire.
Quindi, è tutto ciò che riguarda l'installazione del file.
Ora abbiamo tutto a posto, ma come lo accetteresti dal front-end?
Nel front-end, puoi accedere alla pagina del Guestbook aggiungendo la variabile querystring del percorso, quindi l'URL dovrebbe essere qualcosa come http: //your-opencart-store-url/index.php? Route = guestbook / entry.
Capiamo come OpenCart mappa qualsiasi URL al file del controller specifico. Il formato della variabile di percorso è Directory / filename /  methodname.
 
Il Directory componente si associa alla directory sotto Catalogo / regolatore.
 
Il nome del file esegue il mapping al nome del file del controller in Catalogo / regolatore / directory.
 
Infine, cercherà il nome del metodo controller  Methodname se è specificato nel percorso, altrimenti chiamerà il valore predefinito indice metodo.
 
Ecco come si presenta il risultato finale.
Naturalmente, puoi andare avanti e testarlo inviando il modulo, e dovresti ricevere una notifica via email all'indirizzo di posta elettronica registrato come amministratore del negozio.
Conclusione
In qualsiasi contesto, è sempre emozionante andare avanti e implementare le proprie funzionalità personalizzate. Questo era esattamente l'argomento del tutorial di oggi, in cui abbiamo esteso OpenCart e sviluppato controller personalizzati creando una funzionalità abbastanza semplice ma utile del libro degli ospiti.
Nel processo, ci siamo resi conto che non si tratta solo dei controller: c'erano pochi altri elementi chiave che erano inevitabili. Quindi abbiamo finito per introdurre anche quelli: Modello, Lingua e Vista.
Alla fine, è stato bello vedere il caso d'uso funzionante di ciò che ho promesso all'inizio dell'articolo. Quindi, è tutto per oggi, e non esitare a lasciare le tue domande e commenti. Inoltre, mi piacerebbe sapere da te se c'è qualche argomento particolare che vorresti che io inventassi nel mio prossimo articolo!
Come sempre, se stai cercando altri strumenti, utility, estensioni e così via che puoi sfruttare nei tuoi progetti o per la tua istruzione, non dimenticare di vedere cosa abbiamo a disposizione sul mercato.
Se ti è piaciuto questo articolo, ne ho qualcuna solo nel caso in cui ti piacerebbe affrontarli!



		
			
	   
	




Codice