local/modules/StockAlert/EventListeners/StockAlertManager.php line 124

  1. <?php
  2. /*************************************************************************************/
  3. /*      This file is part of the Thelia package.                                     */
  4. /*                                                                                   */
  5. /*      Copyright (c) OpenStudio                                                     */
  6. /*      email : dev@thelia.net                                                       */
  7. /*      web : http://www.thelia.net                                                  */
  8. /*                                                                                   */
  9. /*      For the full copyright and license information, please view the LICENSE.txt  */
  10. /*      file that was distributed with this source code.                             */
  11. /*************************************************************************************/
  13. namespace StockAlert\EventListeners;
  15. use Propel\Runtime\ActiveQuery\Criteria;
  16. use StockAlert\Event\ProductSaleElementAvailabilityEvent;
  17. use StockAlert\Event\StockAlertEvent;
  18. use StockAlert\Event\StockAlertEvents;
  19. use StockAlert\Model\RestockingAlert;
  20. use StockAlert\Model\RestockingAlertQuery;
  21. use StockAlert\StockAlert;
  22. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  23. use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
  24. use Thelia\Core\Event\Newsletter\NewsletterEvent;
  25. use Thelia\Core\Event\Order\OrderEvent;
  26. use Thelia\Core\Event\ProductSaleElement\ProductSaleElementUpdateEvent;
  27. use Thelia\Core\Event\TheliaEvents;
  28. use Thelia\Core\Translation\Translator;
  29. use Thelia\Log\Tlog;
  30. use Thelia\Mailer\MailerFactory;
  31. use Thelia\Model\ConfigQuery;
  32. use Thelia\Model\Lang;
  33. use Thelia\Model\NewsletterQuery;
  34. use Thelia\Model\ProductQuery;
  35. use Thelia\Model\ProductSaleElementsQuery;
  37. /**
  38.  * Class StockAlertManager
  39.  * @package StockAlert\EventListeners
  40.  * @author Baixas Alban <abaixas@openstudio.fr>
  41.  * @author Julien Chanséaume <julien@thelia.net>
  42.  */
  43. class StockAlertManager implements EventSubscriberInterface
  44. {
  45.     protected $mailer;
  47.     protected $dispatcher;
  49.     public function __construct(MailerFactory $mailer, EventDispatcherInterface $dispatcher)
  50.     {
  51.         $this->mailer = $mailer;
  52.         $this->dispatcher = $dispatcher;
  53.     }
  55.     /**
  56.      * Returns an array of event names this subscriber wants to listen to.
  57.      * @return array The event names to listen to
  58.      *
  59.      * @api
  60.      */
  61.     public static function getSubscribedEvents()
  62.     {
  63.         return [
  64.             StockAlertEvents::STOCK_ALERT_SUBSCRIBE => ['subscribe', 128],
  65.             TheliaEvents::PRODUCT_UPDATE_PRODUCT_SALE_ELEMENT => ['checkStock', 120],
  66.             TheliaEvents::ORDER_UPDATE_STATUS => ['checkStockForAdmin', 128],
  67.         ];
  68.     }
  70.     public function subscribe(StockAlertEvent $event)
  71.     {
  72.         $productSaleElementsId = $event->getProductSaleElementsId();
  73.         $email = $event->getEmail();
  74.         $subscribeToNewsLetter = $event->getSubscribeToNewsLetter();
  77.         if (!isset($productSaleElementsId)) {
  78.             throw new \Exception("missing param");
  79.         }
  81.         if (!isset($email)) {
  82.             throw new \Exception("missing param");
  83.         }
  84.         $productSaleList = $this->getProductSaleElementsArray($productSaleElementsId);
  85.         foreach($productSaleList as $productSale){
  86.              // test if it already exists
  87.             $subscribe = RestockingAlertQuery::create()
  88.             ->filterByEmail($email)
  89.             ->filterByProductSaleElementsId($productSaleElementsId)
  90.             ->findOne();
  92.         if (null === $subscribe) {
  93.             $subscribe = new RestockingAlert();
  94.             $subscribe
  95.                 ->setProductSaleElementsId($productSale->getId())
  96.                 ->setEmail($email)
  97.                 ->setLocale($event->getLocale())
  98.                 ->save();
  99.         }
  101.         if ($subscribeToNewsLetter) {
  102.             $this->subscribeNewsletter($email,$event);
  103.         }
  106.         $event->setRestockingAlert($subscribe);
  107.             }
  108.        
  109.     }
  111.     protected function subscribeNewsletter($email, StockAlertEvent $event)
  112.     {
  113.         $customer = NewsletterQuery::create()->findOneByEmail($email);
  115.         if (!$customer) {
  117.             $newsletter = new NewsletterEvent($email,"fr_FR");
  118.             $this->dispatcher->dispatch($newsletter, TheliaEvents::NEWSLETTER_SUBSCRIBE);
  120.         }
  121.     }
  124.     public function checkStock(ProductSaleElementUpdateEvent $productSaleElementUpdateEvent)
  125.     {
  126.         if ($productSaleElementUpdateEvent->getQuantity() > 0) {
  127.             // add extra checking
  128.             $pse = ProductSaleElementsQuery::create()->findPk(
  129.                 $productSaleElementUpdateEvent->getProductSaleElementId()
  130.             );
  131.             $availabilityEvent = new ProductSaleElementAvailabilityEvent(
  132.                 $pse
  133.             );
  135.             $this->dispatcher->dispatch(
  136.                 $availabilityEvent,
  137.                 StockAlertEvents::STOCK_ALERT_CHECK_AVAILABILITY
  138.             );
  140.             if ($availabilityEvent->isAvailable()) {
  141.                 $subscribers = RestockingAlertQuery::create()
  142.                     ->filterByProductSaleElementsId($productSaleElementUpdateEvent->getProductSaleElementId())
  143.                     ->find();
  145.                 if (null !== $subscribers) {
  146.                     foreach ($subscribers as $subscriber) {
  147.                         try {
  148.                             $this->sendEmail($subscriber);
  149.                             $subscriber->delete();
  150.                         } catch (\Exception $ex) {
  151.                             ;
  152.                         }
  153.                     }
  154.                 }
  155.             }
  156.         }
  157.     }
  158.     /**FCA */
  159.     /**
  160.      * @param int $pseId
  161.      */
  162.     protected function getProductSaleElementsArray(int $pseId){
  163.         $pse = ProductSaleElementsQuery::create()->findPk( $pseId);
  164.         $productId = $pse->getProductId();
  165.         $productSales = ProductSaleElementsQuery::create()
  166.         ->filterByProductId($productId)
  167.         ->find();
  168.         return $productSales;
  169.     }
  170.     /**FCA */
  171.     /**
  172.      * @param RestockingAlert $subscriber
  173.      * @throws \Propel\Runtime\Exception\PropelException
  174.      */
  175.     public function sendEmail(RestockingAlert $subscriber)
  176.     {
  177.         $contactEmail = ConfigQuery::read('store_email');
  179.         if ($contactEmail) {
  180.             $pse = ProductSaleElementsQuery::create()->findPk($subscriber->getProductSaleElementsId());
  182.             $this->mailer->sendEmailMessage(
  183.                 'stockalert_customer',
  184.                 [ $contactEmail => ConfigQuery::read('store_name') ],
  185.                 [ $subscriber->getEmail() => ConfigQuery::read('store_name') ],
  186.                 [
  187.                     'locale' => $subscriber->getLocale(),
  188.                     'pse_id' => $pse->getId(),
  189.                     'product_id' => $pse->getProductId(),
  190.                     'product_title' => $pse->getProduct()->setLocale($subscriber->getLocale())->getTitle()
  191.                 ],
  192.                 $subscriber->getLocale()
  193.             );
  195.             Tlog::getInstance()->debug("Restocking Alert sent to customer " . $subscriber->getEmail());
  196.         } else {
  197.             Tlog::getInstance()->debug(
  198.                 "Restocking Alert: no contact email is defined !"
  199.             );
  200.         }
  201.     }
  203.     public function checkStockForAdmin(OrderEvent $event)
  204.     {
  205.         $order = $event->getOrder();
  207.         $config = StockAlert::getConfig();
  209.         $pseIds = [];
  211.         foreach ($order->getOrderProducts() as $orderProduct) {
  212.             $pseIds[] = $orderProduct->getProductSaleElementsId();
  213.         }
  215.         if ($config['enabled']) {
  216.             $threshold = $config['threshold'];
  218.             $productIds = ProductQuery::create()
  219.                 ->useProductSaleElementsQuery()
  220.                 ->filterById($pseIds, Criteria::IN)
  221.                 ->filterByQuantity($threshold, Criteria::LESS_EQUAL)
  222.                 // exclude virtual product with weight at 0
  223.                 ->filterByWeight(0, Criteria::NOT_EQUAL)
  224.                 ->endUse()
  225.                 ->select('Id')
  226.                 ->find()
  227.                 ->toArray();
  229.             if (!empty($productIds)) {
  230.                 $this->sendEmailForAdmin($config['emails'], $productIds);
  231.             }
  232.         }
  233.     }
  235.     public function sendEmailForAdmin($emails, $productIds): void
  236.     {
  237.         $config = StockAlert::getConfig();
  239.         if ($config['notify']) {
  240.             $locale = Lang::getDefaultLanguage()->getLocale();
  242.             $contactEmail = ConfigQuery::read('store_email');
  244.             if ($contactEmail) {
  245.                 $storeName = ConfigQuery::read('store_name');
  247.                 $to = [];
  249.                 foreach ($emails as $recipient) {
  250.                     $to[$recipient] = $storeName;
  251.                 }
  253.                 $this->mailer->sendEmailMessage(
  254.                     'stockalert_administrator',
  255.                     [ $contactEmail => $storeName ],
  256.                     $to,
  257.                     [
  258.                         'locale' => $locale,
  259.                         'products_id' => $productIds
  260.                     ],
  261.                     $locale
  262.                 );
  264.                 Tlog::getInstance()->debug("Stock Alert sent to administrator " . implode(', ', $emails));
  265.             } else {
  266.                 Tlog::getInstance()->debug("Restocking Alert: no contact email is defined !");
  267.             }
  268.         }
  269.     }
  270. }