core/lib/Thelia/Action/ModuleHook.php line 195

  1. <?php
  3. /*
  4.  * This file is part of the Thelia package.
  5.  * http://www.thelia.net
  6.  *
  7.  * (c) OpenStudio <info@thelia.net>
  8.  *
  9.  * For the full copyright and license information, please view the LICENSE
  10.  * file that was distributed with this source code.
  11.  */
  13. namespace Thelia\Action;
  15. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  16. use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
  17. use Thelia\Core\Event\Cache\CacheEvent;
  18. use Thelia\Core\Event\Hook\HookToggleActivationEvent;
  19. use Thelia\Core\Event\Hook\HookUpdateEvent;
  20. use Thelia\Core\Event\Hook\ModuleHookCreateEvent;
  21. use Thelia\Core\Event\Hook\ModuleHookDeleteEvent;
  22. use Thelia\Core\Event\Hook\ModuleHookToggleActivationEvent;
  23. use Thelia\Core\Event\Hook\ModuleHookUpdateEvent;
  24. use Thelia\Core\Event\Module\ModuleDeleteEvent;
  25. use Thelia\Core\Event\Module\ModuleToggleActivationEvent;
  26. use Thelia\Core\Event\TheliaEvents;
  27. use Thelia\Core\Event\UpdatePositionEvent;
  28. use Thelia\Core\Translation\Translator;
  29. use Thelia\Model\Base\IgnoredModuleHookQuery;
  30. use Thelia\Model\HookQuery;
  31. use Thelia\Model\IgnoredModuleHook;
  32. use Thelia\Model\ModuleHook as ModuleHookModel;
  33. use Thelia\Model\ModuleHookQuery;
  34. use Thelia\Model\ModuleQuery;
  35. use Thelia\Module\BaseModule;
  37. /**
  38.  * Class ModuleHook.
  39.  *
  40.  * @author  Julien Chanséaume <jchanseaume@openstudio.fr>
  41.  */
  42. class ModuleHook extends BaseAction implements EventSubscriberInterface
  43. {
  44.     /** @var string */
  45.     protected $cacheDir;
  47.     /** @var EventDispatcherInterface */
  48.     protected $dispatcher;
  50.     public function __construct($kernelCacheDir, EventDispatcherInterface $dispatcher)
  51.     {
  52.         $this->cacheDir = $kernelCacheDir;
  53.         $this->dispatcher = $dispatcher;
  54.     }
  56.     public function toggleModuleActivation(ModuleToggleActivationEvent $event)
  57.     {
  58.         if (null !== $module = ModuleQuery::create()->findPk($event->getModuleId())) {
  59.             ModuleHookQuery::create()
  60.                 ->filterByModuleId($module->getId())
  61.                 ->update(['ModuleActive' => ($module->getActivate() == BaseModule::IS_ACTIVATED)]);
  62.         }
  64.         return $event;
  65.     }
  67.     public function deleteModule(ModuleDeleteEvent $event)
  68.     {
  69.         if ($event->getModuleId()) {
  70.             ModuleHookQuery::create()
  71.                 ->filterByModuleId($event->getModuleId())
  72.                 ->delete();
  73.         }
  75.         return $event;
  76.     }
  78.     protected function isModuleActive($module_id)
  79.     {
  80.         if (null !== $module = ModuleQuery::create()->findPk($module_id)) {
  81.             return $module->getActivate();
  82.         }
  84.         return false;
  85.     }
  87.     protected function isHookActive($hook_id)
  88.     {
  89.         if (null !== $hook = HookQuery::create()->findPk($hook_id)) {
  90.             return $hook->getActivate();
  91.         }
  93.         return false;
  94.     }
  96.     protected function getLastPositionInHook($hook_id)
  97.     {
  98.         $result = ModuleHookQuery::create()
  99.             ->filterByHookId($hook_id)
  100.             ->withColumn('MAX(ModuleHook.position)', 'maxPos')
  101.             ->groupBy('ModuleHook.hook_id')
  102.             ->select(['maxPos'])
  103.             ->findOne();
  105.         return (int) $result + 1;
  106.     }
  108.     public function createModuleHook(ModuleHookCreateEvent $event): void
  109.     {
  110.         $moduleHook = new ModuleHookModel();
  112.         // todo: test if classname and method exists
  113.         $moduleHook
  114.             ->setModuleId($event->getModuleId())
  115.             ->setHookId($event->getHookId())
  116.             ->setActive(false)
  117.             ->setClassname($event->getClassname())
  118.             ->setMethod($event->getMethod())
  119.             ->setModuleActive($this->isModuleActive($event->getModuleId()))
  120.             ->setHookActive($this->isHookActive($event->getHookId()))
  121.             ->setPosition($this->getLastPositionInHook($event->getHookId()))
  122.             ->setTemplates($event->getTemplates())
  123.             ->save();
  125.         // Be sure to delete this module hook from the ignored module hook table
  126.         IgnoredModuleHookQuery::create()
  127.             ->filterByHookId($event->getHookId())
  128.             ->filterByModuleId($event->getModuleId())
  129.             ->delete();
  131.         $event->setModuleHook($moduleHook);
  132.     }
  134.     public function updateModuleHook(ModuleHookUpdateEvent $event): void
  135.     {
  136.         if (null !== $moduleHook = ModuleHookQuery::create()->findPk($event->getModuleHookId())) {
  137.             // todo: test if classname and method exists
  138.             $moduleHook
  139.                 ->setHookId($event->getHookId())
  140.                 ->setModuleId($event->getModuleId())
  141.                 ->setClassname($event->getClassname())
  142.                 ->setMethod($event->getMethod())
  143.                 ->setActive($event->getActive())
  144.                 ->setHookActive($this->isHookActive($event->getHookId()))
  145.                 ->setTemplates($event->getTemplates())
  146.                 ->save();
  148.             $event->setModuleHook($moduleHook);
  150.             $this->cacheClear();
  151.         }
  152.     }
  154.     public function deleteModuleHook(ModuleHookDeleteEvent $event): void
  155.     {
  156.         if (null !== $moduleHook = ModuleHookQuery::create()->findPk($event->getModuleHookId())) {
  157.             $moduleHook->delete();
  158.             $event->setModuleHook($moduleHook);
  160.             // Prevent hook recreation by RegisterListenersPass::registerHook()
  161.             // We store the method here to be able to retreive it when
  162.             // we need to get all hook declared by a module
  163.             $imh = new IgnoredModuleHook();
  164.             $imh
  165.                 ->setModuleId($moduleHook->getModuleId())
  166.                 ->setHookId($moduleHook->getHookId())
  167.                 ->setMethod($moduleHook->getMethod())
  168.                 ->setClassname($moduleHook->getClassname())
  169.                 ->save();
  171.             $this->cacheClear();
  172.         }
  173.     }
  175.     public function toggleModuleHookActivation(ModuleHookToggleActivationEvent $event)
  176.     {
  177.         if (null !== $moduleHook = $event->getModuleHook()) {
  178.             if ($moduleHook->getModuleActive()) {
  179.                 $moduleHook->setActive(!$moduleHook->getActive());
  180.                 $moduleHook->save();
  181.             } else {
  182.                 throw new \LogicException(Translator::getInstance()->trans('The module has to be activated.'));
  183.             }
  184.         }
  185.         $this->cacheClear();
  187.         return $event;
  188.     }
  190.     /**
  191.      * Changes position, selecting absolute ou relative change.
  192.      *
  193.      * @return UpdatePositionEvent $event
  194.      */
  195.     public function updateModuleHookPosition(UpdatePositionEvent $event)
  196.     {
  197.         $this->genericUpdatePosition(ModuleHookQuery::create(), $event);
  198.         $this->cacheClear();
  200.         return $event;
  201.     }
  203.     public function updateHook(HookUpdateEvent $event): void
  204.     {
  205.         if ($event->hasHook()) {
  206.             $hook = $event->getHook();
  207.             ModuleHookQuery::create()
  208.                 ->filterByHookId($hook->getId())
  209.                 ->update(['HookActive' => $hook->getActivate()]);
  210.             $this->cacheClear();
  211.         }
  212.     }
  214.     public function toggleHookActivation(HookToggleActivationEvent $event): void
  215.     {
  216.         if ($event->hasHook()) {
  217.             $hook = $event->getHook();
  218.             ModuleHookQuery::create()
  219.                 ->filterByHookId($hook->getId())
  220.                 ->update(['HookActive' => $hook->getActivate()]);
  221.             $this->cacheClear();
  222.         }
  223.     }
  225.     protected function cacheClear(): void
  226.     {
  227.         $cacheEvent = new CacheEvent($this->cacheDir);
  229.         $this->dispatcher->dispatch($cacheEvent, TheliaEvents::CACHE_CLEAR);
  230.     }
  232.     /**
  233.      * {@inheritdoc}
  234.      */
  235.     public static function getSubscribedEvents()
  236.     {
  237.         return [
  238.             TheliaEvents::MODULE_HOOK_CREATE => ['createModuleHook', 128],
  239.             TheliaEvents::MODULE_HOOK_UPDATE => ['updateModuleHook', 128],
  240.             TheliaEvents::MODULE_HOOK_DELETE => ['deleteModuleHook', 128],
  241.             TheliaEvents::MODULE_HOOK_UPDATE_POSITION => ['updateModuleHookPosition', 128],
  242.             TheliaEvents::MODULE_HOOK_TOGGLE_ACTIVATION => ['toggleModuleHookActivation', 128],
  244.             TheliaEvents::MODULE_TOGGLE_ACTIVATION => ['toggleModuleActivation', 64],
  245.             TheliaEvents::MODULE_DELETE => ['deleteModule', 64],
  247.             TheliaEvents::HOOK_TOGGLE_ACTIVATION => ['toggleHookActivation', 64],
  248.             TheliaEvents::HOOK_UPDATE => ['updateHook', 64],
  249.         ];
  250.     }
  251. }