src/EventSubscriber/AppCacheSubscriber.php line 110

Open in your IDE?
  1. <?php
  2. /**
  3.  * @license SILK SOFTWARE HOUSE SP Z O O
  4.  */
  6. namespace App\EventSubscriber;
  8. use App\Annotation\AppCache;
  9. use Symfony\Component\HttpKernel\Event\ControllerArgumentsEvent;
  10. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  11. use Symfony\Component\HttpKernel\Event\ResponseEvent;
  12. use Symfony\Component\HttpKernel\KernelEvents;
  13. use Doctrine\Common\Annotations\Reader;
  14. use ReflectionClass;
  15. use ReflectionException;
  16. use Symfony\Component\Security\Core\Security;
  17. use Symfony\Contracts\Cache\TagAwareCacheInterface as CacheInterface;
  18. use Symfony\Contracts\Cache\ItemInterface;
  20. /**
  21.  * Class AppCacheSubscriber.
  22.  */
  23. class AppCacheSubscriber implements EventSubscriberInterface
  24. {
  25.     /**
  26.      * Annotation reader.
  27.      *
  28.      * @var Reader
  29.      */
  30.     private $annotationReader;
  32.     /**
  33.      * Cache.
  34.      *
  35.      * @var CacheInterface
  36.      */
  37.     private $cache;
  39.     /**
  40.      * Cache key.
  41.      *
  42.      * @var string
  43.      */
  44.     private $key;
  46.     /**
  47.      * Security.
  48.      *
  49.      * @var Security
  50.      */
  51.     private $security;
  53.     /**
  54.      * AppCacheSubscriber constructor.
  55.      *
  56.      * @param CacheInterface $cache
  57.      * @param Reader         $reader
  58.      * @param Security       $security
  59.      */
  60.     public function __construct(CacheInterface $cache, Reader $reader, Security $security)
  61.     {
  62.         $this->cache = $cache;
  63.         $this->annotationReader = $reader;
  64.         $this->security = $security;
  65.     }
  67.     /**
  68.      * Get subscribed events.
  69.      *
  70.      * @return array
  71.      */
  72.     public static function getSubscribedEvents()
  73.     {
  74.         // return the subscribed events, their methods and priorities
  75.         return [
  76.             KernelEvents::CONTROLLER_ARGUMENTS => [
  77.                 ['onKernelController', 1],
  78.             ],
  79.             KernelEvents::RESPONSE => [
  80.                 ['onKernelResponse', 10],
  81.             ],
  82.         ];
  83.     }
  85.     /**
  86.      * On kernel controller.
  87.      *
  88.      * @param ControllerArgumentsEvent $event
  89.      */
  90.     public function onKernelController(ControllerArgumentsEvent $event)
  91.     {
  92.         $annotation = $this->getAppCacheAnnotation($event->getController());
  93.         if (!$event->getRequest()->isMethod('GET') || !$this->security->getUser() || null === $annotation) {
  94.             return;
  95.         }
  96.         $this->key = 'measurement_'.$event->getRequest()->get('id').'_'.preg_replace("/[^A-Za-z0-9 ]/", '', $event->getRequest()->getPathInfo()).$this->security->getUser()->getId();
  97.         if ($cached = $this->cache->getItem($this->key)->get()) {
  98.             $event->setController(function () use ($cached) {
  99.                 return $cached;
  100.             });
  101.             $event->stopPropagation();
  102.         }
  103.     }
  105.     /**
  106.      * On kernel response.
  107.      *
  108.      * @param ResponseEvent $event
  109.      */
  110.     public function onKernelResponse(ResponseEvent $event)
  111.     {
  113.         if (200 !== $event->getResponse()->getStatusCode()) {
  114.             return;
  115.         }
  116.         if (!isset($this->key)) {
  117.             return;
  118.         }
  119.         $tag = 'measurement_'.$event->getRequest()->get('id');
  120.         $response = $event->getResponse();
  121.         $this->cache->get($this->key, function (ItemInterface $item) use ($response, $tag) {
  122.             $item->tag([$tag, 'user_'.$this->security->getUser()->getId()]);
  124.             return $response;
  125.         });
  126.     }
  128.     /**
  129.      * Does controller have idempotent annotation.
  130.      *
  131.      * @param callable $controllerData
  132.      *
  133.      * @return AppCache|null
  134.      */
  135.     private function getAppCacheAnnotation($controllerData)
  136.     {
  137.         $annotation = null;
  138.         if (!is_array($controllerData)) {
  139.             return null;
  140.         }
  142.         list($controllerObject, $methodName) = $controllerData;
  143.         try {
  144.             $controller = new ReflectionClass($controllerObject);
  145.             $method = $controller->getMethod($methodName);
  146.             $annotation = $this->annotationReader->getMethodAnnotation($method, AppCache::class);
  147.         } catch (ReflectionException $e) {
  148.             return null;
  149.         }
  151.         return $annotation instanceof AppCache ? $annotation : null;
  152.     }
  153. }