src/Service/Gatherer.php line 50

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace App\Service;
  7. use App\Entity\Menu\Item;
  8. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  9. use App\Event\Content\ContentDisplayEvent;
  10. use App\Menu\MenuResolver;
  11. use LogicException;
  12. use Symfony\Contracts\Cache\ItemInterface;
  13. use Symfony\Contracts\Cache\TagAwareCacheInterface;
  15. /**
  16.  * Gatherer service
  17.  *
  18.  * @author  Przemysław Chrupek <przemyslaw.chrupek@avt.pl>
  19.  * @package App\Service
  20.  */
  21. class Gatherer implements EventSubscriberInterface
  22. {
  23.     protected MenuResolver $menuResolver;
  24.     protected CacheHelper $cacheHelper;
  25.     protected TagAwareCacheInterface $appCache;
  26.     protected ?Item $activeMenuItem;
  27.     protected bool $cacheEnabled;
  28.     private $data = [];
  30.     public function __construct(MenuResolver $menuResolver, CacheHelper $cacheHelper, TagAwareCacheInterface $appCache)
  31.     {
  32.         $this->menuResolver = $menuResolver;
  33.         $this->activeMenuItem = $this->menuResolver->getActiveMenuEntityItem();
  34.         $this->appCache = $appCache;
  35.         $this->cacheHelper = $cacheHelper;
  36.         $this->cacheEnabled = $this->cacheHelper->cacheEnabled();
  38.         $this->loadCache();
  39.     }
  41.     public static function getSubscribedEvents()
  42.     {
  43.         return [
  44.             ContentDisplayEvent::NAME => [
  45.                 ['preContentDisplay', 10],
  46.             ]
  47.         ];
  48.     }
  50.     public function preContentDisplay(ContentDisplayEvent $event): void
  51.     {
  52.         $this->add('content', $event->getContent());
  53.     }
  55.     public function add(string $key, $value, $cache = false): Gatherer
  56.     {
  57.         if (array_key_exists($key, $this->data))
  58.             throw new LogicException(sprintf('Can\'t override existing value: [%s]', $key));
  60.         $this->setDataValue($key, $value, $cache);
  61.         return $this;
  62.     }
  64.     public function addOrReplace(string $key, $value, $cache = false): Gatherer
  65.     {
  66.         if (!array_key_exists($key, $this->data)) {
  67.             $this->add($key, $value, $cache);
  68.             return $this;
  69.         }
  71.         $this->setDataValue($key, $value, $cache);
  72.         return $this;
  73.     }
  75.     public function remove(string $key): Gatherer
  76.     {
  77.         if (array_key_exists($key, $this->data)) {
  78.             unset($this->data[$key]);
  79.             $this->reloadCache();
  80.         }
  81.         return $this;
  82.     }
  84.     public function get(string $key)
  85.     {
  86.         return array_key_exists($key, $this->data) ? $this->data[$key]['value'] : null;
  87.     }
  89.     public function getData(): array
  90.     {
  91.         $data = [];
  93.         foreach ($this->data as $k => $d) {
  94.             $data[$k] = $d['value'];
  95.         }
  97.         return $data;
  98.     }
  100.     protected function setDataValue(string $key, $value, $cache = false): Gatherer
  101.     {
  102.         $this->data[$key] = [
  103.             'value' => $value,
  104.             'cache' => $cache
  105.         ];
  107.         $this->reloadCache();
  108.         return $this;
  109.     }
  111.     protected function getCacheKey(): string
  112.     {
  113.         /**
  114.          * ID based on menu item id
  115.          * 0 for homepage
  116.         */
  117.         $id = $this->activeMenuItem ? $this->activeMenuItem->getId() : 0;
  118.         return sprintf('%s_%d', $this->cacheHelper::TAG_GATHERER, $id);
  119.     }
  121.     /**
  122.      * If cache empty and data empty - load current data to cache (empty array).
  123.      * If cache hits - set data from cache.
  124.      * If cache miss and data not empty - save data to cache
  125.      */
  126.     protected function loadCache(): void
  127.     {
  128.         if (!$this->cacheEnabled)
  129.             return;
  131.         $cachedData = $this->appCache->get($this->getCacheKey(), function (ItemInterface $item)
  132.         {
  133.             $item->tag(CacheHelper::TAG_GATHERER);
  134.             $item->tag($this->getCacheKey());
  135.             $cachedData = [];
  137.             foreach ($this->data as $k => $d) {
  138.                 if (!$d['cache'])
  139.                     continue;
  141.                 $cachedData[$k] = $d;               
  142.             }
  143.             
  144.             return $cachedData; // Get current data value
  145.         });
  147.         $this->data = array_merge($this->data, $cachedData);
  148.     }
  150.     protected function reloadCache(): void
  151.     {
  152.         if (!$this->cacheEnabled)
  153.             return;
  155.         $this->appCache->delete($this->getCacheKey());
  156.         $this->loadCache();
  157.     }
  158. }