core/lib/Thelia/Action/Module.php line 202

  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 Propel\Runtime\Propel;
  16. use Symfony\Component\DependencyInjection\ContainerInterface;
  17. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  18. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  19. use Symfony\Component\Filesystem\Exception\IOException;
  20. use Symfony\Component\Filesystem\Filesystem;
  21. use Symfony\Component\HttpFoundation\Response;
  22. use Thelia\Core\Event\Cache\CacheEvent;
  23. use Thelia\Core\Event\Module\ModuleDeleteEvent;
  24. use Thelia\Core\Event\Module\ModuleEvent;
  25. use Thelia\Core\Event\Module\ModuleInstallEvent;
  26. use Thelia\Core\Event\Module\ModuleToggleActivationEvent;
  27. use Thelia\Core\Event\Order\OrderPaymentEvent;
  28. use Thelia\Core\Event\TheliaEvents;
  29. use Thelia\Core\Event\UpdatePositionEvent;
  30. use Thelia\Core\Translation\Translator;
  31. use Thelia\Exception\FileNotFoundException;
  32. use Thelia\Exception\ModuleException;
  33. use Thelia\Log\Tlog;
  34. use Thelia\Model\Base\OrderQuery;
  35. use Thelia\Model\Map\ModuleTableMap;
  36. use Thelia\Model\ModuleQuery;
  37. use Thelia\Module\BaseModule;
  38. use Thelia\Module\ModuleManagement;
  39. use Thelia\Module\Validator\ModuleValidator;
  41. /**
  42.  * Class Module.
  43.  *
  44.  * @author  Manuel Raynaud <manu@raynaud.io>
  45.  */
  46. class Module extends BaseAction implements EventSubscriberInterface
  47. {
  48.     /** @var ContainerInterface */
  49.     protected $container;
  51.     public function __construct(ContainerInterface $container)
  52.     {
  53.         $this->container = $container;
  54.     }
  56.     public function toggleActivation(ModuleToggleActivationEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  57.     {
  58.         if (null !== $module = ModuleQuery::create()->findPk($event->getModuleId())) {
  59.             $moduleInstance = $module->createInstance();
  61.             if (method_exists($moduleInstance, 'setContainer')) {
  62.                 $moduleInstance->setContainer($this->container);
  63.                 if ($module->getActivate() == BaseModule::IS_ACTIVATED) {
  64.                     $moduleInstance->deActivate($module);
  65.                 } else {
  66.                     $moduleInstance->activate($module);
  67.                 }
  68.             }
  70.             $event->setModule($module);
  72.             $this->cacheClear($dispatcher);
  73.         }
  74.     }
  76.     public function checkToggleActivation(ModuleToggleActivationEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  77.     {
  78.         if (true === $event->isNoCheck()) {
  79.             return;
  80.         }
  82.         if (null !== $module = ModuleQuery::create()->findPk($event->getModuleId())) {
  83.             try {
  84.                 if ($module->getActivate() == BaseModule::IS_ACTIVATED) {
  85.                     if ($module->getMandatory() == BaseModule::IS_MANDATORY && $event->getAssumeDeactivate() === false) {
  86.                         throw new \Exception(
  87.                             Translator::getInstance()->trans('Can\'t deactivate a secure module')
  88.                         );
  89.                     }
  91.                     if ($event->isRecursive()) {
  92.                         $this->recursiveDeactivation($event, $eventName, $dispatcher);
  93.                     }
  94.                     $this->checkDeactivation($module);
  95.                 } else {
  96.                     if ($event->isRecursive()) {
  97.                         $this->recursiveActivation($event, $eventName, $dispatcher);
  98.                     }
  99.                     $this->checkActivation($module);
  100.                 }
  101.             } catch (\Exception $ex) {
  102.                 $event->stopPropagation();
  103.                 throw $ex;
  104.             }
  105.         }
  106.     }
  108.     /**
  109.      * Check if module can be activated : supported version of Thelia, module dependencies.
  110.      *
  111.      * @param \Thelia\Model\Module $module
  112.      *
  113.      * @throws \Exception if activation fails
  114.      *
  115.      * @return bool true if the module can be activated, otherwise false
  116.      */
  117.     private function checkActivation($module)
  118.     {
  119.         try {
  120.             $moduleValidator = new ModuleValidator($module->getAbsoluteBaseDir());
  121.             $moduleValidator->validate(false);
  122.         } catch (\Exception $ex) {
  123.             throw $ex;
  124.         }
  126.         return true;
  127.     }
  129.     /**
  130.      * Check if module can be deactivated safely because other modules
  131.      * could have dependencies to this module.
  132.      *
  133.      * @param \Thelia\Model\Module $module
  134.      *
  135.      * @return bool true if the module can be deactivated, otherwise false
  136.      */
  137.     private function checkDeactivation($module)
  138.     {
  139.         $moduleValidator = new ModuleValidator($module->getAbsoluteBaseDir());
  141.         $modules = $moduleValidator->getModulesDependOf();
  143.         if (\count($modules) > 0) {
  144.             $moduleList = implode(', ', array_column($modules, 'code'));
  146.             $message = (\count($modules) == 1)
  147.                 ? Translator::getInstance()->trans(
  148.                     '%s has dependency to module %s. You have to deactivate this module before.'
  149.                 )
  150.                 : Translator::getInstance()->trans(
  151.                     '%s have dependencies to module %s. You have to deactivate these modules before.'
  152.                 );
  154.             throw new ModuleException(
  155.                 sprintf($message, $moduleList, $moduleValidator->getModuleDefinition()->getCode())
  156.             );
  157.         }
  159.         return true;
  160.     }
  162.     /**
  163.      * Get dependencies of the current module and activate it if needed.
  164.      */
  165.     public function recursiveActivation(ModuleToggleActivationEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  166.     {
  167.         if (null !== $module = ModuleQuery::create()->findPk($event->getModuleId())) {
  168.             $moduleValidator = new ModuleValidator($module->getAbsoluteBaseDir());
  169.             $dependencies = $moduleValidator->getCurrentModuleDependencies();
  170.             foreach ($dependencies as $defMod) {
  171.                 $submodule = ModuleQuery::create()
  172.                     ->findOneByCode($defMod['code']);
  173.                 if ($submodule && $submodule->getActivate() != BaseModule::IS_ACTIVATED) {
  174.                     $subevent = new ModuleToggleActivationEvent($submodule->getId());
  175.                     $subevent->setRecursive(true);
  176.                     $dispatcher->dispatch($subevent, TheliaEvents::MODULE_TOGGLE_ACTIVATION);
  177.                 }
  178.             }
  179.         }
  180.     }
  182.     /**
  183.      * Get modules having current module in dependence and deactivate it if needed.
  184.      */
  185.     public function recursiveDeactivation(ModuleToggleActivationEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  186.     {
  187.         if (null !== $module = ModuleQuery::create()->findPk($event->getModuleId())) {
  188.             $moduleValidator = new ModuleValidator($module->getAbsoluteBaseDir());
  189.             $dependencies = $moduleValidator->getModulesDependOf(true);
  190.             foreach ($dependencies as $defMod) {
  191.                 $submodule = ModuleQuery::create()
  192.                     ->findOneByCode($defMod['code']);
  193.                 if ($submodule && $submodule->getActivate() == BaseModule::IS_ACTIVATED) {
  194.                     $subevent = new ModuleToggleActivationEvent($submodule->getId());
  195.                     $subevent->setRecursive(true);
  196.                     $dispatcher->dispatch($subevent, TheliaEvents::MODULE_TOGGLE_ACTIVATION);
  197.                 }
  198.             }
  199.         }
  200.     }
  202.     public function delete(ModuleDeleteEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  203.     {
  204.         $con = Propel::getWriteConnection(ModuleTableMap::DATABASE_NAME);
  205.         $con->beginTransaction();
  207.         if (null !== $module = ModuleQuery::create()->findPk($event->getModuleId(), $con)) {
  208.             try {
  209.                 if (null === $module->getFullNamespace()) {
  210.                     throw new \LogicException(
  211.                         Translator::getInstance()->trans(
  212.                             'Cannot instantiate module "%name%": the namespace is null. Maybe the model is not loaded ?',
  213.                             ['%name%' => $module->getCode()]
  214.                         )
  215.                     );
  216.                 }
  218.                 // If the module is referenced by an order, display a meaningful error
  219.                 // instead of 'delete cannot delete' caused by a constraint violation.
  220.                 // FIXME: we hav to find a way to delete modules used by order.
  221.                 if (OrderQuery::create()->filterByDeliveryModuleId($module->getId())->count() > 0
  222.                     ||
  223.                     OrderQuery::create()->filterByPaymentModuleId($module->getId())->count() > 0
  224.                 ) {
  225.                     throw new \LogicException(
  226.                         Translator::getInstance()->trans(
  227.                             'The module "%name%" is currently in use by at least one order, and can\'t be deleted.',
  228.                             ['%name%' => $module->getCode()]
  229.                         )
  230.                     );
  231.                 }
  233.                 try {
  234.                     if ($module->getMandatory() == BaseModule::IS_MANDATORY && $event->getAssumeDelete() === false) {
  235.                         throw new \Exception(
  236.                             Translator::getInstance()->trans('Can\'t remove a core module')
  237.                         );
  238.                     }
  239.                     // First, try to create an instance
  240.                     $instance = $module->createInstance();
  242.                     // Then, if module is activated, check if we can deactivate it
  243.                     if ($module->getActivate()) {
  244.                         // check for modules that depend of this one
  245.                         $this->checkDeactivation($module);
  246.                     }
  248.                     $instance->setContainer($this->container);
  250.                     $path = $module->getAbsoluteBaseDir();
  252.                     $instance->destroy($con, $event->getDeleteData());
  254.                     $fs = new Filesystem();
  255.                     $fs->remove($path);
  256.                 } catch (\ReflectionException $ex) {
  257.                     // Happens probably because the module directory has been deleted.
  258.                     // Log a warning, and delete the database entry.
  259.                     Tlog::getInstance()->addWarning(
  260.                         Translator::getInstance()->trans(
  261.                             'Failed to create instance of module "%name%" when trying to delete module. Module directory has probably been deleted',
  262.                             ['%name%' => $module->getCode()]
  263.                         )
  264.                     );
  265.                 } catch (FileNotFoundException $fnfe) {
  266.                     // The module directory has been deleted.
  267.                     // Log a warning, and delete the database entry.
  268.                     Tlog::getInstance()->addWarning(
  269.                         Translator::getInstance()->trans(
  270.                             'Module "%name%" directory was not found',
  271.                             ['%name%' => $module->getCode()]
  272.                         )
  273.                     );
  274.                 }
  276.                 $module->delete($con);
  278.                 $con->commit();
  280.                 $event->setModule($module);
  281.                 $this->cacheClear($dispatcher);
  282.             } catch (\Exception $e) {
  283.                 $con->rollBack();
  284.                 throw $e;
  285.             }
  286.         }
  287.     }
  289.     public function update(ModuleEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  290.     {
  291.         if (null !== $module = ModuleQuery::create()->findPk($event->getId())) {
  292.             $module
  294.                 ->setLocale($event->getLocale())
  295.                 ->setTitle($event->getTitle())
  296.                 ->setChapo($event->getChapo())
  297.                 ->setDescription($event->getDescription())
  298.                 ->setPostscriptum($event->getPostscriptum());
  300.             $module->save();
  302.             $event->setModule($module);
  303.         }
  304.     }
  306.     /**
  307.      * @throws \Exception
  308.      * @throws \Symfony\Component\Filesystem\Exception\IOException
  309.      * @throws \Exception
  310.      */
  311.     public function install(ModuleInstallEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  312.     {
  313.         $moduleDefinition = $event->getModuleDefinition();
  315.         $oldModule = ModuleQuery::create()->findOneByFullNamespace($moduleDefinition->getNamespace());
  317.         $fs = new Filesystem();
  319.         $activated = false;
  321.         // check existing module
  322.         if (null !== $oldModule) {
  323.             $activated = $oldModule->getActivate();
  325.             if ($activated) {
  326.                 // deactivate
  327.                 $toggleEvent = new ModuleToggleActivationEvent($oldModule->getId());
  328.                 // disable the check of the module because it's already done
  329.                 $toggleEvent->setNoCheck(true);
  331.                 $dispatcher->dispatch($toggleEvent, TheliaEvents::MODULE_TOGGLE_ACTIVATION);
  332.             }
  334.             // delete
  335.             $modulePath = $oldModule->getAbsoluteBaseDir();
  337.             $deleteEvent = new ModuleDeleteEvent($oldModule);
  339.             try {
  340.                 $dispatcher->dispatch($deleteEvent, TheliaEvents::MODULE_DELETE);
  341.             } catch (\Exception $ex) {
  342.                 // if module has not been deleted
  343.                 if ($fs->exists($modulePath)) {
  344.                     throw $ex;
  345.                 }
  346.             }
  347.         }
  349.         // move new module
  350.         $modulePath = sprintf('%s%s', THELIA_MODULE_DIR, $event->getModuleDefinition()->getCode());
  352.         try {
  353.             $fs->mirror($event->getModulePath(), $modulePath);
  354.         } catch (IOException $ex) {
  355.             if (!$fs->exists($modulePath)) {
  356.                 throw $ex;
  357.             }
  358.         }
  360.         // Update the module
  361.         $moduleDescriptorFile = sprintf('%s%s%s%s%s', $modulePath, DS, 'Config', DS, 'module.xml');
  362.         $moduleManagement = new ModuleManagement($this->container);
  363.         $file = new \SplFileInfo($moduleDescriptorFile);
  364.         $module = $moduleManagement->updateModule($file, $this->container);
  366.         // activate if old was activated
  367.         if ($activated) {
  368.             $toggleEvent = new ModuleToggleActivationEvent($module->getId());
  369.             $toggleEvent->setNoCheck(true);
  371.             $dispatcher->dispatch($toggleEvent, TheliaEvents::MODULE_TOGGLE_ACTIVATION);
  372.         }
  374.         $event->setModule($module);
  375.     }
  377.     /**
  378.      * Call the payment method of the payment module of the given order.
  379.      *
  380.      * @throws \RuntimeException if no payment module can be found
  381.      */
  382.     public function pay(OrderPaymentEvent $event): void
  383.     {
  384.         $order = $event->getOrder();
  386.         /* call pay method */
  387.         if (null === $paymentModule = ModuleQuery::create()->findPk($order->getPaymentModuleId())) {
  388.             throw new \RuntimeException(
  389.                 Translator::getInstance()->trans(
  390.                     'Failed to find a payment Module with ID=%mid for order ID=%oid',
  391.                     [
  392.                         '%mid' => $order->getPaymentModuleId(),
  393.                         '%oid' => $order->getId(),
  394.                     ]
  395.                 )
  396.             );
  397.         }
  399.         $paymentModuleInstance = $paymentModule->getPaymentModuleInstance($this->container);
  401.         $response = $paymentModuleInstance->pay($order);
  403.         if (null !== $response && $response instanceof Response) {
  404.             $event->setResponse($response);
  405.         }
  406.     }
  408.     /**
  409.      * Changes position, selecting absolute ou relative change.
  410.      */
  411.     public function updatePosition(UpdatePositionEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  412.     {
  413.         $this->genericUpdatePosition(ModuleQuery::create(), $event, $dispatcher);
  415.         $this->cacheClear($dispatcher);
  416.     }
  418.     protected function cacheClear(EventDispatcherInterface $dispatcher): void
  419.     {
  420.         $cacheEvent = new CacheEvent(
  421.             $this->container->getParameter('kernel.cache_dir')
  422.         );
  424.         $dispatcher->dispatch($cacheEvent, TheliaEvents::CACHE_CLEAR);
  425.     }
  427.     /**
  428.      * {@inheritdoc}
  429.      */
  430.     public static function getSubscribedEvents()
  431.     {
  432.         return [
  433.             TheliaEvents::MODULE_TOGGLE_ACTIVATION => [
  434.                 ['checkToggleActivation', 255],
  435.                 ['toggleActivation', 128],
  436.             ],
  437.             TheliaEvents::MODULE_UPDATE_POSITION => ['updatePosition', 128],
  438.             TheliaEvents::MODULE_DELETE => ['delete', 128],
  439.             TheliaEvents::MODULE_UPDATE => ['update', 128],
  440.             TheliaEvents::MODULE_INSTALL => ['install', 128],
  441.             TheliaEvents::MODULE_PAY => ['pay', 128],
  442.         ];
  443.     }
  444. }