Vandaag zullen we het concept van controllers in OpenCart 2.x doornemen. Met de release van de OpenCart 2.x-versie hebben ze framework-wijzigingen geïntroduceerd die een upgrade vereisen als je aangepaste modules hebt gemaakt in de eerdere versie-OpenCart 1.x. We zullen een praktisch voorbeeld bekijken van wat we Gastenboek zullen noemen in deze tutorial.

Voordat we verder gaan in dit artikel, zou je dit kunnen beschouwen als een vervolg op wat ik eerder schreef. In dat artikel legde ik uit hoe je een aangepaste pagina maakt in OpenCart 1.x, en als je dat artikel al hebt gevolgd, kun je vandaag snel de meeste secties overslaan.! 

Natuurlijk is het OpenCart 2.x dat vandaag wordt besproken, dus zorg ervoor dat je de code nauwgezet volgt.

Als u meer theorie over het OpenCart framework patroon en controllers wilt zien, kunt u een paar van de eerste delen van dat artikel doornemen. Dat gezegd hebbende, is er niets dat je ervan weerhoudt dit artikel te volgen, want ik zal geen essentie overslaan.

Waarom een ​​aangepaste controller?

Iets dat u misschien in de eerste plaats vraagt: waarom een ​​aangepaste controller? Laten we snel begrijpen waar de controller over gaat in OpenCart voordat we hierin ingaan.

In de context van OpenCart, de controleur is een onmisbaar onderdeel van het raamwerk dat rechtstreeks betrekking heeft op het routeringsproces en de UI rendert. In dit proces worden andere belangrijke componenten behandeld, zoals taal, model en weergave om het uiteindelijke resultaat te bereiken.

Wanneer u een pagina in OpenCart opent, zoekt het OpenCart-framework naar de bijbehorende controller en delegeert het verdere verwerking ervan. Omdat het modulair van aard is, biedt het OpenCart-framework verschillende controllers die omgaan met logisch gegroepeerde functionaliteiten.

Bijvoorbeeld de account groep bevat controllers die zich bezighouden met aanmeldings-, registratie-, profiel- en soortgelijke use-cases. Evenzo is de uitchecken groep controllers behandelt het ordercreatieproces.

Kort gezegd: als u een functie wilt maken die niet in de kern van OpenCart staat en als u een nieuwe URL nodig hebt, een route in de terminologie van OpenCart, moet u een aangepaste controller kiezen. Hiermee hebt u volledige controle over het proces voor het maken van de pagina, welke elementen u op uw aangepaste pagina wilt weergeven.

Maak een aangepaste controller

Vandaag zullen we een eenvoudige Guestbook-functionaliteit implementeren die het concept van aangepaste controllers laat zien. In de loop van dat proces zullen we een interface aan de voorkant bouwen waarmee gastgebruikers hun feedback kunnen indienen door hun naam en bericht in te voeren.

Voordat u doorgaat, moet u zorgen voor een werkende installatie van OpenCart 2.3.x. En dat is zo ongeveer om aan onze Guestbook-functie te werken.

Voor degenen die niet bekend zijn met de OpenCart-structuur, is de plaats waar moet worden gezocht naar de front-end controllers catalogus / controller. Het is de directory die alle controllers per groep beheert, op basis van de functies die ze bieden.

In ons geval maken we een afzonderlijke groep met de naam gastenboek. Ga je gang en maak een map aan catalogus / controller / gastenboek. Maak in die map een entry.php bestand met de volgende inhoud. Het is een controllerbestand dat de applicatielogica en indieningslogica van onze gastenboekfunctionaliteit verwerkt.

load> taal ( 'gastenboek / gastenboek'); $ This-> document-> setTitle ($ this-> language-> krijgen ( 'HEADING_TITLE')); if (($ this-> request-> server ['REQUEST_METHOD'] == 'POST') && $ this-> validate ()) $ this-> load-> model ('gastenboek / gastenboek'); $ data ['subject'] = sprintf ('Nieuw gastenboekinvoer ingediend door% s', $ this-> request-> post ['gast_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-> data [ 'succes']);  $ data ['breadcrumbs'] = array (); $ data ['breadcrumbs'] [] = array ('text' => $ this-> language-> get ('text_home'), 'href' => $ this-> url-> link ('common / home' )); $ data ['breadcrumbs'] [] = array ('text' => $ this-> language-> get ('heading_title'), 'href' => $ this-> url-> link ('gastenboek / item' , ", 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 ['gast_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 ['gast_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;  

Volgens naamgevingsconventies van OpenCart begint de klassenaam met de controleur sleutelwoord gevolgd door de naam van de map, gastenboek in ons geval, waarin het klassenbestand zich bevindt. Verder de naam van het klassenbestand, binnenkomst in ons geval is aan het einde toegevoegd.

Elke controllerklasse biedt de facto inhoudsopgave methode die het grootste deel van de logica van de controller afhandelt. Vervolgens gaan we door de code in de inhoudsopgave methode, en we zullen ook andere bestanden maken als dat nodig is.

Meestal beginnen we met het toevoegen van het taalbestand voor de specifieke groep. Het is de manier waarop OpenCart statische taallabels in de hele applicatie beheert. Dat maakt de implementatie van meertalige sites natuurlijk een eitje.

$ This-> load-> taal ( 'gastenboek / gastenboek');

Voordat we verdergaan, maken we het bijbehorende taalbestand zodat onze controller het kan vinden. Maak een catalogus / language / nl-nl / gastenboek / guestbook.php bestand met de volgende inhoud.

Zoals u ziet, wijzen we alleen labels aan met hun waarden in de taalarray.
Terug naar onze controller, het volgende is om de HTML-title-tag voor onze pagina in te stellen.
$ This-> document-> setTitle ($ this-> language-> krijgen ( 'HEADING_TITLE'));
Gebruikers met scherpe ogen hebben gemerkt dat we de HEADING_TITLE taalvariabele gedefinieerd in het taalbestand dat zojuist is gemaakt.
Om het volgende stuk code te begrijpen, moeten we een modeldossier maken. Dus voor een moment zal ik u omleiden om het modelbestand te maken op catalogus / model / gastenboek / guestbook.php met de volgende inhoud.
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-> krijgen ( 'config_email')); $ Mail-> setFrom ($ this-> config-> krijgen ( 'config_email')); $ mail-> setSender (html_entity_decode ($ this-> config-> get ('config_name'), ENT_QUOTES, 'UTF-8')); $ Mail-> SetSubject ($ data [ 'subject']); $ Mail-> setText ($ data [ 'boodschap']); $ Mail-> send ();  
In OpenCart is het model verantwoordelijk voor het verwerken van de bedrijfslogica van de toepassing. Als u logica wilt implementeren die betrekking heeft op een database, dan is dit de plaats waar het moet gaan.
De naamgevingsconventie van de modelklasse is vergelijkbaar met die van de controllerklasse. Om de dingen eenvoudig te houden, hebben we een methode geïmplementeerd processGuestbookEntry die de beheerder van de winkel via e-mail op de hoogte brengt wanneer een gebruiker een gastenboekvermelding indient. Vrij eenvoudig, he?
Laten we teruggaan naar onze controller en het volgende stukje code in de wachtrij bekijken.
if (($ this-> request-> server ['REQUEST_METHOD'] == 'POST') && $ this-> validate ()) $ this-> load-> model ('gastenboek / gastenboek'); $ data ['subject'] = sprintf ('Nieuw gastenboekinvoer ingediend door% s', $ this-> request-> post ['gast_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));
Het controleert op een geldige POST aanvraag en doet basis validatie van door de gebruiker aangeleverde gegevens door te bellen naar de bevestigen methode.
De code $ This-> load-> model ( 'gastenboek / gastenboek') wordt gebruikt om het model te laden dat we zojuist hebben gedefinieerd. Onmiddellijk daarna bereiden we de $ data array op basis van de gebruikersinvoer en bel de processGuestbookEntry methode, die de winkelbeheerder op de hoogte stelt van het gastenboek. Uiteindelijk leiden we de gebruiker terug naar de gastenpagina van het gastenboek.
In het vervolg van de controller stelt het volgende fragment het succesbericht in dat wordt weergegeven bij het indienen van het formulier.
$ data ['succes'] = "; if (isset ($ this-> session-> data ['success'])) $ data ['success'] = $ this-> session-> data ['succes' ]; unset ($ this-> session-> data ['success']);
Hierna is er een fragment dat wordt gebruikt om broodkruimelkoppelingen voor de pagina te maken.
$ data ['breadcrumbs'] = array (); $ data ['breadcrumbs'] [] = array ('text' => $ this-> language-> get ('text_home'), 'href' => $ this-> url-> link ('common / home' )); $ data ['breadcrumbs'] [] = array ('text' => $ this-> language-> get ('heading_title'), 'href' => $ this-> url-> link ('gastenboek / item' , ", waar));
Het volgende fragment is een belangrijk fragment, en het is iets dat u meestal zult gebruiken om informatie van de controlemechanismemethode door te geven aan de weergavesjabloon.
$ 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');
Net als bij het toewijzen van variabelen, initialiseert OpenCart algemene elementen van de koptekst, voettekst en dergelijke van de pagina zoals afgebeeld in het volgende fragment.
$ 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');
Ten slotte roept het de weergavesjabloon op om de daadwerkelijke pagina te renderen!
$ this-> response-> setOutput ($ this-> load-> view ('guestbook / entry', $ data));
Natuurlijk hebben we nog geen weergavesjabloon gebouwd. Het is de perfecte tijd om dat te doen! Ga je gang en maak een catalogus / view / theme / default / template / gastenboek / entry.tpl bestand met de volgende inhoud.
 
 
  
">
  
  
 
  
        
 
 
 
  
   
  
 
 
  
 <?php echo $guest_message; ?>  
  
 
 
   
  
 
 
 
 
 
  
Dit is ons sjabloon voor de hoofdsitemaker die verantwoordelijk is voor het weergeven van de inhoud van onze gastenboekpagina. In dit bestand hebben we zojuist de variabelen gebruikt die in de controller zijn ingesteld inhoudsopgave methode.
Het is belangrijk op te merken dat responsiviteit iets is dat ingebouwd is met de recente versies van OpenCart die worden ondersteund door het Bootstrap-framework. Anders dan dat, het is vrij normale HTML-dingen die vrij gemakkelijk te begrijpen zijn.
Dus dat is het voor zover het de configuratie van het bestand betreft.
We hebben nu alles op zijn plek, maar hoe zou je dat van de voorkant benaderen??
In de front-end kunt u de Guestbook-pagina openen door de variabele route-querystring toe te voegen, dus de URL moet zoiets zijn als http: //uw-opencart-store-url/index.php? Route = gastenboek / item.
Laten we begrijpen hoe OpenCart elke URL toewijst aan het specifieke controllerbestand. Het formaat van de routevariabele is Directory / bestandsnaam / methodname.
 
De Directory componentmappen naar de map onder catalogus / controller.
 
De bestandsnaam wijst naar de naam van het controllerbestand onder catalogus / controller / directory.
 
Ten slotte zal het zoeken naar de genoemde methode van de controller  MethodName als het in de route is opgegeven, anders wordt dit de standaardinstelling inhoudsopgave methode.
 
Dit is hoe het eindresultaat eruit ziet.
U kunt natuurlijk doorgaan en het testen door het formulier in te dienen en u ontvangt een e-mailmelding naar het e-mailadres dat is geregistreerd als winkelbeheerder.
Conclusie
In elk kader is het altijd spannend om door te gaan en uw eigen aangepaste functionaliteit te implementeren. Dat was precies het onderwerp van de tutorial van vandaag, waarin we OpenCart hebben uitgebreid en aangepaste controllers hebben ontwikkeld door een vrij eenvoudige maar nuttige functionaliteit van Gastenboek te bouwen.
Tijdens het proces beseften we dat het niet alleen om de controllers gaat - er waren maar weinig andere belangrijke elementen die onvermijdelijk waren. Daarom hebben we die ook geïntroduceerd: model, taal en weergave.
Aan het eind was het leuk om de werkende use-case te zien van wat ik aan het begin van het artikel beloofde. Dus dat is het voor vandaag en aarzel niet om uw vragen en opmerkingen achter te laten. Ik zou ook graag van je horen of er een bepaald onderwerp is waarvan je zou willen dat ik dit in mijn volgende artikel bedacht!
Zoals altijd, als u op zoek bent naar aanvullende OpenCart-hulpmiddelen, hulpprogramma's, uitbreidingen en dergelijke die u kunt gebruiken in uw eigen projecten of voor uw eigen opleiding, vergeet dan niet te zien wat we beschikbaar hebben op de markt.
Als je dit artikel leuk vond, heb ik er nog een paar voor het geval je ze zou willen doornemen!



		
			
	   
	




Code