core/lib/Thelia/Action/Template.php line 44

  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\EventDispatcher\EventDispatcherInterface;
  17. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  18. use Thelia\Core\Event\Template\TemplateAddAttributeEvent;
  19. use Thelia\Core\Event\Template\TemplateAddFeatureEvent;
  20. use Thelia\Core\Event\Template\TemplateCreateEvent;
  21. use Thelia\Core\Event\Template\TemplateDeleteAttributeEvent;
  22. use Thelia\Core\Event\Template\TemplateDeleteEvent;
  23. use Thelia\Core\Event\Template\TemplateDeleteFeatureEvent;
  24. use Thelia\Core\Event\Template\TemplateDuplicateEvent;
  25. use Thelia\Core\Event\Template\TemplateUpdateEvent;
  26. use Thelia\Core\Event\TheliaEvents;
  27. use Thelia\Core\Event\UpdatePositionEvent;
  28. use Thelia\Core\Translation\Translator;
  29. use Thelia\Model\AttributeTemplate;
  30. use Thelia\Model\AttributeTemplateQuery;
  31. use Thelia\Model\CategoryQuery;
  32. use Thelia\Model\FeatureTemplate;
  33. use Thelia\Model\FeatureTemplateQuery;
  34. use Thelia\Model\Map\TemplateTableMap;
  35. use Thelia\Model\ProductQuery;
  36. use Thelia\Model\Template as TemplateModel;
  37. use Thelia\Model\TemplateQuery;
  39. class Template extends BaseAction implements EventSubscriberInterface
  40. {
  41.     /**
  42.      * Create a new template entry.
  43.      */
  44.     public function create(TemplateCreateEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  45.     {
  46.         $template = new TemplateModel();
  48.         $template
  50.             ->setLocale($event->getLocale())
  51.             ->setName($event->getTemplateName())
  53.             ->save()
  54.         ;
  56.         $event->setTemplate($template);
  57.     }
  59.     /**
  60.      * Dupliucate an existing template entry.
  61.      *
  62.      * @param \Thelia\Core\Event\Template\TemplateCreateEvent $event
  63.      */
  64.     public function duplicate(TemplateDuplicateEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  65.     {
  66.         if (null !== $source = TemplateQuery::create()->findPk($event->getSourceTemplateId())) {
  67.             $source->setLocale($event->getLocale());
  69.             $createEvent = new TemplateCreateEvent();
  70.             $createEvent
  71.                 ->setLocale($event->getLocale())
  72.                 ->setTemplateName(
  73.                     Translator::getInstance()->trans('Copy of %tpl', ['%tpl' => $source->getName()])
  74.                 );
  76.             $dispatcher->dispatch($createEvent, TheliaEvents::TEMPLATE_CREATE);
  78.             $clone = $createEvent->getTemplate();
  80.             $attrList = AttributeTemplateQuery::create()->findByTemplateId($source->getId());
  82.             /** @var $feat AttributeTemplate */
  83.             foreach ($attrList as $feat) {
  84.                 $dispatcher->dispatch(
  85.                     new TemplateAddAttributeEvent($clone, $feat->getAttributeId()),
  86.                     TheliaEvents::TEMPLATE_ADD_ATTRIBUTE
  87.                 );
  88.             }
  90.             $featList = FeatureTemplateQuery::create()->findByTemplateId($source->getId());
  92.             /** @var $feat FeatureTemplate */
  93.             foreach ($featList as $feat) {
  94.                 $dispatcher->dispatch(
  95.                     new TemplateAddFeatureEvent($clone, $feat->getFeatureId()),
  96.                     TheliaEvents::TEMPLATE_ADD_FEATURE
  97.                 );
  98.             }
  100.             $event->setTemplate($clone);
  101.         }
  102.     }
  104.     /**
  105.      * Change a product template.
  106.      */
  107.     public function update(TemplateUpdateEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  108.     {
  109.         if (null !== $template = TemplateQuery::create()->findPk($event->getTemplateId())) {
  110.             $template
  112.                 ->setLocale($event->getLocale())
  113.                 ->setName($event->getTemplateName())
  114.                 ->save();
  116.             $event->setTemplate($template);
  117.         }
  118.     }
  120.     /**
  121.      * Delete a product template entry.
  122.      *
  123.      * @throws \Exception
  124.      */
  125.     public function delete(TemplateDeleteEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  126.     {
  127.         if (null !== ($template = TemplateQuery::create()->findPk($event->getTemplateId()))) {
  128.             // Check if template is used by a product
  129.             $productCount = ProductQuery::create()->findByTemplateId($template->getId())->count();
  131.             if ($productCount <= 0) {
  132.                 $con = Propel::getWriteConnection(TemplateTableMap::DATABASE_NAME);
  133.                 $con->beginTransaction();
  135.                 try {
  136.                     $template
  138.                         ->delete($con);
  140.                     // We have to also delete any reference of this template in category tables
  141.                     // We can't use a FK here, as the DefaultTemplateId column may be NULL
  142.                     // so let's take care of this.
  143.                     CategoryQuery::create()
  144.                         ->filterByDefaultTemplateId($event->getTemplateId())
  145.                         ->update(['DefaultTemplateId' => null], $con);
  147.                     $con->commit();
  148.                 } catch (\Exception $ex) {
  149.                     $con->rollback();
  151.                     throw $ex;
  152.                 }
  153.             }
  155.             $event->setTemplate($template);
  157.             $event->setProductCount($productCount);
  158.         }
  159.     }
  161.     public function addAttribute(TemplateAddAttributeEvent $event): void
  162.     {
  163.         if (null === AttributeTemplateQuery::create()
  164.                 ->filterByAttributeId($event->getAttributeId())
  165.                 ->filterByTemplate($event->getTemplate())
  166.                 ->findOne()) {
  167.             $attributeTemplate = new AttributeTemplate();
  169.             $attributeTemplate
  170.                 ->setAttributeId($event->getAttributeId())
  171.                 ->setTemplate($event->getTemplate())
  172.                 ->save()
  173.             ;
  174.         }
  175.     }
  177.     /**
  178.      * Changes position, selecting absolute ou relative change.
  179.      */
  180.     public function updateAttributePosition(UpdatePositionEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  181.     {
  182.         $this->genericUpdatePosition(AttributeTemplateQuery::create(), $event, $dispatcher);
  183.     }
  185.     /**
  186.      * Changes position, selecting absolute ou relative change.
  187.      */
  188.     public function updateFeaturePosition(UpdatePositionEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  189.     {
  190.         $this->genericUpdatePosition(FeatureTemplateQuery::create(), $event, $dispatcher);
  191.     }
  193.     public function deleteAttribute(TemplateDeleteAttributeEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  194.     {
  195.         $attributeTemplate = AttributeTemplateQuery::create()
  196.             ->filterByAttributeId($event->getAttributeId())
  197.             ->filterByTemplate($event->getTemplate())->findOne()
  198.         ;
  200.         if ($attributeTemplate !== null) {
  201.             $attributeTemplate
  203.                 ->delete();
  204.         } else {
  205.             // Prevent event propagation
  206.             $event->stopPropagation();
  207.         }
  208.     }
  210.     public function addFeature(TemplateAddFeatureEvent $event): void
  211.     {
  212.         if (null === FeatureTemplateQuery::create()
  213.                 ->filterByFeatureId($event->getFeatureId())
  214.                 ->filterByTemplate($event->getTemplate())
  215.                 ->findOne()
  216.         ) {
  217.             $featureTemplate = new FeatureTemplate();
  219.             $featureTemplate
  220.                 ->setFeatureId($event->getFeatureId())
  221.                 ->setTemplate($event->getTemplate())
  222.                 ->save()
  223.             ;
  224.         }
  225.     }
  227.     public function deleteFeature(TemplateDeleteFeatureEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  228.     {
  229.         $featureTemplate = FeatureTemplateQuery::create()
  230.             ->filterByFeatureId($event->getFeatureId())
  231.             ->filterByTemplate($event->getTemplate())->findOne()
  232.         ;
  234.         if ($featureTemplate !== null) {
  235.             $featureTemplate
  237.                 ->delete();
  238.         } else {
  239.             // Prevent event propagation
  240.             $event->stopPropagation();
  241.         }
  242.     }
  244.     /**
  245.      * {@inheritDoc}
  246.      */
  247.     public static function getSubscribedEvents()
  248.     {
  249.         return [
  250.             TheliaEvents::TEMPLATE_CREATE => ['create', 128],
  251.             TheliaEvents::TEMPLATE_UPDATE => ['update', 128],
  252.             TheliaEvents::TEMPLATE_DELETE => ['delete', 128],
  253.             TheliaEvents::TEMPLATE_DUPLICATE => ['duplicate', 128],
  255.             TheliaEvents::TEMPLATE_ADD_ATTRIBUTE => ['addAttribute', 128],
  256.             TheliaEvents::TEMPLATE_DELETE_ATTRIBUTE => ['deleteAttribute', 128],
  258.             TheliaEvents::TEMPLATE_ADD_FEATURE => ['addFeature', 128],
  259.             TheliaEvents::TEMPLATE_DELETE_FEATURE => ['deleteFeature', 128],
  261.             TheliaEvents::TEMPLATE_CHANGE_ATTRIBUTE_POSITION => ['updateAttributePosition', 128],
  262.             TheliaEvents::TEMPLATE_CHANGE_FEATURE_POSITION => ['updateFeaturePosition', 128],
  263.         ];
  264.     }
  265. }