Magento 2 modul fejlesztés lépésről lépésre – 3. rész (Observer-ek)

Ebben a cikkben az alábbiakról fogok írni:

  • Alap példa modul felépítése
  • Observer-ek létrehozása és implementálása

 

1) Alap példa modul felépítése

 

Az előző cikkekben (1. rész, 2. rész) megismerkedtünk egy példa Magento 2.0 modul elkészítésével, a hozzá tartozó adatbázis táblák, admin táblázat (grid), a modulhoz tartozó adatok létrehozásával, editálásával, mentésével és törlésével. Most egy másik egyszerű Magento 2.0 modulban az Observer-ek működésével foglalkozunk.

Ehhez első lépésben elkészítünk egy alap példa modult. Mivel korábbi cikkünk erre már kitért, most csak a modul felépítése kerül bemutatásra.

 

magento 2 modul szerkezet

 

2) Observer-ek létrehozása és implementálása

 

A Magento 2.0 példa modulban két Observer-t hozunk létre, melyeket két külön eseményre „kötünk” rá. A Magento 1.x modulok esetében egy Observer osztályban kerültek megvalósításra a különböző események során megvalósítandó függvények és azokban történő üzleti logikák. A Magento 2.0-ban minden egyes eseményhez külön saját Observer osztályt kell létrehozni, melyekben az execute(…) függvényben kerül az üzleti logika megvalósításra.

Mielőtt az Observer osztály létrehozásra kerül, definiálni kell, hogy melyik eseményre szeretnénk a saját üzleti logikánkat alkalmazni. Itt fontos eldönteni, hogy a frontend vagy az admin oldalon (adminhtml) szeretnénk használni, így a definíciós xml fájlt a megfelelő helyen kell elhelyezni.

Globálisan is el lehet helyezni, de célszerű ezt mindig külön választani. Első példában egy frontend oldali eseményre, az alap Magento 2.0 contact form (kapcsolat) elküldése után szeretnénk az elküldött adatokat „elkapni” a saját Observer osztályunkkal.

Ehhez szükségünk lesz egy events.xml fájlra, ami az alábbi helyen található a példa modulunkban: app/code/Aion/Sample/etc/frontend/events.xml. A fájl tartalma:

<?xml version="1.0"?>
    <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:Event/etc/events.xsd">
    <event name="controller_action_postdispatch_contact_index_post">
        <observer name="aion_sample_post_capture" instance="Aion\Sample\Observer\CapturePost" />
    </event>
</config>

A fájl felépítése nagyon egyszerű. Az event tag-ben lévő name paraméterben kerül meghatározásra, hogy melyik eseményt szeretnénk „elkapni”.

Az esetünkben a Magento 2.0 alap Contact moduljában lévő post controller utáni esemény. Az event tag-en belül pedig definiáljuk az observer tag-ben a saját Observer osztályunkat, ami majd meghívásra kerül és egyedi név paramétert is adunk neki. Az event tag-ben egymás alatt több saját Observer-t is definiálhatunk ugyanezen eseményhez, illetve az xml fájlban több event tag-et is megadhatunk, ha más eseményekhez is szeretnénk további saját Observer-t használni.

Ezt követően a saját Observer osztályunkat kell létrehozni és megvalósítani benne a szükséges üzleti logikát. A fájl az alábbi helyen található a példa modulunkban: app/code/Aion/Sample/Observer/CapturePost.php. A fájl tartalma:

<?php
namespace Aion\Sample\Observer;

use Magento\Framework\Event\ObserverInterface;
use Aion\Sample\Helper\Data as DataHelper;
use Psr\Log\LoggerInterface;
use Magento\Framework\Event\Observer;
use Magento\Customer\Model\Customer;
use Magento\Framework\Exception\LocalizedException;

class CapturePost implements ObserverInterface
{
    /**
     * Aion Sample helper
     *
     * @var DataHelper
     */
    protected $_helper;

    /**
     * @var LoggerInterface
     */
    protected $_logger;

    /**
     * Capture Post Observer constructor
     *
     * @param DataHelper $helper
     * @param LoggerInterface $logger
     */
    public function __construct(
        DataHelper $helper,
        LoggerInterface $logger
    ) {
        $this->_helper = $helper;
        $this->_logger = $logger;
    }

    /**
     * Sample post capture event handler
     *
     * @param Observer $observer
     * @return self
     */
    public function execute(Observer $observer)
    {
        if ($this->_helper->isEnabled()) {

            $controller = $observer->getEvent()->getControllerAction();
            $post = $controller->getRequest()->getPostValue();

            if ($post) {

                try {

                    $this->_logger->debug('CapturePostObserver');
                    $this->_logger->log(100, print_r($post, true));

                    // comment out to check data
                    //\Zend_Debug::dump($post);
                    //die();

                    // do some logic

                } catch (LocalizedException $e) {
                    $this->_logger->error($e->getMessage());
                } catch (\Exception $e) {
                    $this->_logger->critical($e);
                }

            }

        }

        return $this;
    }
}

Amennyiben a fent említett events.xml fájlban definiált esemény megtörténik, a CapturePost osztályban lévő execute függvény hajtódik végre. A függvény első lépésben megvizsgálja, hogy a saját modulunk engedélyezve van-e. Abban az esetben, ha engedélyezve van, az említett Magento 2.0 alap Contact form által elposztolt adatokat „elkapja”. Az egyszerűség kedvéért a példában csak logoljuk a tömböt a debug.log file-ban. Az így megkapott adatokat felhasználva megírhatjuk a saját üzleti logikánkat.

A második példában egy admin oldali eseménynél, az alap Magento 2.0 felhasználó mentés után szeretnénk az felhasználó (customer) objektumot és adatokat „elkapni” a saját Observer osztályunkkal.

Ehhez szükségünk lesz egy events.xml fájlra, ami az alábbi helyen található a példa modulunkban: app/code/Aion/Sample/etc/adminhtml/events.xml. A fájl tartalma:

<?xml version="1.0"?>
    <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:Event/etc/events.xsd">
    <event name="controller_action_postdispatch_contact_index_post">
        <observer name="aion_sample_post_capture" instance="Aion\Sample\Observer\CaptureCustomer" />
    </event>
</config>

 

 

 

A fájl felépítése ugyanaz, mint az előző példában említett events.xml esetében, csak ezúttal az adminhtml könyvtár van elhelyezve, így a definiált CaptureCustomer osztály csak az admin scope-ban fog meghívódni a felhasználó mentés utáni eseményre (customer_save_commit_after).

 

Ezt követően az előző példához hasonlóan a saját Observer osztályunkat kell létrehozni és megvalósítani benne a szükséges üzleti logikát. A fájl az alábbi helyen található a példa modulunkban: app/code/Aion/Sample/Observer/CaptureCustomer.php. A fájl tartalma:

 

 

<?php
namespace Aion\Sample\Observer;

use Magento\Framework\Event\ObserverInterface;
use Aion\Sample\Helper\Data as DataHelper;
use Psr\Log\LoggerInterface;
use Magento\Framework\Event\Observer;
use Magento\Customer\Model\Customer;
use Magento\Framework\Exception\LocalizedException;

class CaptureCustomer implements ObserverInterface
{
    /**
     * Aion Sample helper
     *
     * @var DataHelper
     */
    protected $_helper;

    /**
     * @var LoggerInterface
     */
    protected $_logger;

    /**
     * Capture Customer Observer constructor
     *
     * @param DataHelper $helper
     * @param LoggerInterface $logger
     */
    public function __construct(
        DataHelper $helper,
        LoggerInterface $logger
    ) {
        $this->_helper = $helper;
        $this->_logger = $logger;
    }

    /**
     * Sample customer capture event handler
     *
     * @param Observer $observer
     * @return self
     */
    public function execute(Observer $observer)
    {
        if ($this->_helper->isEnabled()) {

            /* @var Customer $customer */
            $customer = $observer->getEvent()->getCustomer();

            if (!is_null($customer) && $customer->getEntityId()) {

                try {

                    $this->_logger->debug('CaptureCustomerObserver');
                    $this->_logger->log(100, print_r($customer->getData(), true));
                    // comment out to check data
                    //\Zend_Debug::dump($customer->getData());
                    //die();

                    // do some logic

                } catch (LocalizedException $e) {
                    $this->_logger->error($e->getMessage());
                } catch (\Exception $e) {
                    $this->_logger->critical($e);
                }

            }

        }

        return $this;
    }
}

 

Amennyiben a fent említett második events.xml file-ban definiált esemény megtörténik, a CaptureCustomer osztályban lévő execute függvény hajtódik végre. A függvény első lépésben megvizsgálja, hogy a saját modulunk engedélyezve van-e.

Abban az esetben, ha engedélyezve van, az említett Magento 2.0 admin felhasználó mentés után „elkapja” a customer objektumot. Az egyszerűség kedvéért a példában csak logoljuk az objektum adatait a debug.log file-ban. Az így megkapott objektumot és adatokat felhasználva megírhatjuk a saját üzleti logikánkat.

 

Összegzés

A cikkben két példával próbáltuk illusztrálni a Magento 2.0 rendszerben, hogyan kell saját egyedi modulunkban Observer-eket definiálni és megvalósítani különböző eseményekre a frontend és az admin oldalon.

 

0 válaszok

Hagyjon egy választ

Want to join the discussion?
Feel free to contribute!

Vélemény, hozzászólás?

Az email címet nem tesszük közzé.