vendor/nzo/url-encryptor-bundle/Annotations/AnnotationResolver.php line 29

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the NzoUrlEncryptorBundle package.
  5.  *
  6.  * (c) Ala Eddine Khefifi <alakfpro@gmail.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Nzo\UrlEncryptorBundle\Annotations;
  14. use Doctrine\Common\Annotations\AnnotationReader;
  15. use Nzo\UrlEncryptorBundle\Encryptor\Encryptor;
  16. use Symfony\Component\HttpKernel\Event\ControllerEvent;
  18. class AnnotationResolver
  19. {
  20.     private $encryptor;
  21.     private $reader;
  23.     public function __construct(Encryptor $encryptor, ?AnnotationReader $reader = null)
  24.     {
  25.         $this->encryptor = $encryptor;
  26.         $this->reader = $reader;
  27.     }
  29.     public function onKernelController(ControllerEvent $event)
  30.     {
  31.         if (is_array($controller = $event->getController())) {
  32.             $objectController = new \ReflectionObject($controller[0]);
  33.             $method = $objectController->getMethod($controller[1]);
  34.         } elseif (is_object($controller) && method_exists($controller, '__invoke')) {
  35.             $objectController = new \ReflectionObject($controller);
  36.             $method = $objectController->getMethod('__invoke');
  37.         } else {
  38.             return;
  39.         }
  41.         // Handle PHP8 Attributes
  42.         if (class_exists('ReflectionAttribute')) {
  43.             if ($this->hasAnnotation($method) && !$this->reader instanceof AnnotationReader) {
  44.                 throw new \InvalidArgumentException('NzoEncryptor:  Annotation service not loaded, PHP Attributes should be used instead.');
  45.             }
  46.             $annotations = $this->getAnnotation($method);
  47.         } elseif ($this->reader instanceof AnnotationReader) { // Handle Annotation only without Attributes
  48.             $annotations = $this->reader->getMethodAnnotations($method);
  49.         } else {
  50.             throw new \InvalidArgumentException('NzoEncryptor: Doctrine Annotation package must be installed, doctrine/annotations.');
  51.         }
  53.         foreach ($annotations as $configuration) {
  54.             // handle php8 attribute
  55.             if (class_exists('ReflectionAttribute')) {
  56.                 $configuration = $this->handleReflectionAttribute($configuration);
  57.             }
  59.             if ($configuration instanceof ParamEncryptor) {
  60.                 if (null !== $configuration->getParams()) {
  61.                     $request = $event->getRequest();
  62.                     foreach ($configuration->getParams() as $param) {
  63.                         if ($request->attributes->has($param)) {
  64.                             $decrypted = $this->encryptor->encrypt($request->attributes->get($param));
  65.                             $request->attributes->set($param, $decrypted);
  66.                         } elseif ($request->request->has($param)) {
  67.                             $decrypted = $this->encryptor->encrypt($request->request->get($param));
  68.                             $request->request->set($param, $decrypted);
  69.                         }
  70.                     }
  71.                 }
  72.             } elseif ($configuration instanceof ParamDecryptor) {
  73.                 if (null !== $configuration->getParams()) {
  74.                     $request = $event->getRequest();
  75.                     foreach ($configuration->getParams() as $param) {
  76.                         if ($request->attributes->has($param)) {
  77.                             $decrypted = $this->encryptor->decrypt($request->attributes->get($param));
  78.                             $request->attributes->set($param, $decrypted);
  79.                         } elseif ($request->request->has($param)) {
  80.                             $decrypted = $this->encryptor->decrypt($request->request->get($param));
  81.                             $request->request->set($param, $decrypted);
  82.                         }
  83.                     }
  84.                 }
  85.             }
  86.         }
  87.     }
  89.     private function handleReflectionAttribute($configuration)
  90.     {
  91.         if ($configuration instanceof \ReflectionAttribute
  92.             && \in_array($configuration->getName(), [ParamEncryptor::class, ParamDecryptor::class], true)) {
  93.             $class = $configuration->getName();
  94.             $arguments = $configuration->getArguments();
  95.             $params = \is_array($arguments) && [] !== $arguments && \is_array($arguments[0]) ? $arguments[0] : [];
  97.             return new $class($params);
  98.         }
  100.         return $configuration;
  101.     }
  103.     /**
  104.      * @return array|mixed
  105.      */
  106.     private function getAnnotation($method)
  107.     {
  108.         return $this->reader instanceof AnnotationReader && !empty($this->reader->getMethodAnnotations($method))
  109.             ? $this->reader->getMethodAnnotations($method)
  110.             : $method->getAttributes();
  111.     }
  113.     /**
  114.      * @param \ReflectionMethod $method
  115.      *
  116.      * @return bool
  117.      */
  118.     private function hasAnnotation($method)
  119.     {
  120.         $docComment = $method->getDocComment();
  122.         return false !== $docComment && (false !== strpos($docComment, '@ParamEncryptor') || false !== strpos($docComment, '@ParamDecryptor'));
  123.     }
  124. }