SSHVersionControl / git-web-client

app/src/VersionControl/DoctrineEncryptBundle/Subscribers/DoctrineEncryptSubscriber.php

<?php

namespace VersionControl\DoctrineEncryptBundle\Subscribers;

use Doctrine\ORM\Events;
use Doctrine\Common\EventSubscriber;
use Doctrine\ORM\Event\LifecycleEventArgs;
use Doctrine\ORM\Event\PreUpdateEventArgs;
use Doctrine\Common\Annotations\Reader;
use Doctrine\ORM\EntityManager;
use ReflectionClass;
use VersionControl\DoctrineEncryptBundle\Encryptors\EncryptorInterface;

/**
 * Doctrine event subscriber which encrypt/decrypt entities.
 */
class DoctrineEncryptSubscriber implements EventSubscriber
{
    /**
     * Encryptor interface namespace.
     */
    const ENCRYPTOR_INTERFACE_NS = 'VersionControl\DoctrineEncryptBundle\Encryptors\EncryptorInterface';

    /**
     * Encrypted annotation full name.
     */
    const ENCRYPTED_ANN_NAME = 'VersionControl\DoctrineEncryptBundle\Configuration\Encrypted';

    /**
     * Encryptor.
     *
     * @var EncryptorInterface
     */
    private $encryptor;

    /**
     * Annotation reader.
     *
     * @var Doctrine\Common\Annotations\Reader

The type VersionControl\DoctrineEncryptBundle\Subscribers\Doctrine\Common\Annotations\Reader was not found. Did you mean Doctrine\Common\Annotations\Reader? If so, make sure to prefix the type with \.

     */
    private $annReader;

    /**
     * Registr to avoid multi decode operations for one entity.
     *
     * @var array
     */
    private $decodedRegistry = array();

    /**
     * Initialization of subscriber.
     *
     * @param string $encryptorClass
     * @param string $secretKey
     */
    public function __construct(Reader $annReader, $encryptorClass, $secretKey)
    {
        $this->annReader = $annReader;

It seems like $annReader of type Doctrine\Common\Annotations\Reader is incompatible with the declared type VersionControl\DoctrineEncryptBundle\Subscribers\Doctrine\Common\Annotations\Reader of property $annReader.

        $this->encryptor = $this->encryptorFactory($encryptorClass, $secretKey);
    }

    /**
     * Listen a prePersist lifecycle event. Checking and encrypt entities
     * which have @Encrypted annotation.
     *
     * @param LifecycleEventArgs $args
     */
    public function prePersist(LifecycleEventArgs $args)
    {
        $entity = $args->getEntity();
        $this->processFields($entity);
    }

    /**
     * Listen a preUpdate lifecycle event. Checking and encrypt entities fields
     * which have @Encrypted annotation. Using changesets to avoid preUpdate event
     * restrictions.
     *
     * @param LifecycleEventArgs $args
     */
    public function preUpdate(PreUpdateEventArgs $args)
    {
        $reflectionClass = new ReflectionClass($args->getEntity());
        $properties = $reflectionClass->getProperties();
        foreach ($properties as $refProperty) {
            if ($this->annReader->getPropertyAnnotation($refProperty, self::ENCRYPTED_ANN_NAME)) {
                $propName = $refProperty->getName();
                if ($args->hasChangedField($propName)) {
                    $args->setNewValue($propName, $this->encryptor->encrypt($args->getNewValue($propName)));
                }
            }
        }
    }

    /**
     * Listen a postLoad lifecycle event. Checking and decrypt entities
     * which have @Encrypted annotations.
     *
     * @param LifecycleEventArgs $args
     */
    public function postLoad(LifecycleEventArgs $args)
    {
        $entity = $args->getEntity();
        if (!$this->hasInDecodedRegistry($entity, $args->getEntityManager())) {
            if ($this->processFields($entity, false)) {
                $this->addToDecodedRegistry($entity, $args->getEntityManager());
            }
        }
    }

    /**
     * Realization of EventSubscriber interface method.
     *
     * @return array Return all events which this subscriber is listening
     */
    public function getSubscribedEvents()
    {
        return array(
            Events::prePersist,
            Events::preUpdate,
            Events::postLoad,
        );
    }

    /**
     * Capitalize string.
     *
     * @param string $word
     *
     * @return string
     */
    public static function capitalize($word)
    {
        if (is_array($word)) {

The condition is_array($word) is always false.

            $word = $word[0];
        }

        return str_replace(' ', '', ucwords(str_replace(array('-', '_'), ' ', $word)));
    }

    /**
     * Process (encrypt/decrypt) entities fields.
     *
     * @param Obj  $entity             Some doctrine entity

The type VersionControl\DoctrineEncryptBundle\Subscribers\Obj was not found. Maybe you did not declare it correctly or list all dependencies?

     * @param bool $isEncryptOperation If true - encrypt, false - decrypt entity
     */
    private function processFields($entity, $isEncryptOperation = true)
    {
        $encryptorMethod = $isEncryptOperation ? 'encrypt' : 'decrypt';
        $reflectionClass = new ReflectionClass($entity);
        $properties = $reflectionClass->getProperties();
        $withAnnotation = false;
        foreach ($properties as $refProperty) {
            if ($this->annReader->getPropertyAnnotation($refProperty, self::ENCRYPTED_ANN_NAME)) {
                $withAnnotation = true;
                // we have annotation and if it decrypt operation, we must avoid duble decryption
                $propName = $refProperty->getName();
                if ($refProperty->isPublic()) {
                    $entity->$propName = $this->encryptor->$encryptorMethod($refProperty->getValue());
                } else {
                    $methodName = self::capitalize($propName);
                    if ($reflectionClass->hasMethod($getter = 'get'.$methodName) && $reflectionClass->hasMethod($setter = 'set'.$methodName)) {
                        $currentPropValue = $this->encryptor->$encryptorMethod($entity->$getter());
                        $entity->$setter($currentPropValue);
                    } else {
                        throw new \RuntimeException(sprintf("Property %s isn't public and doesn't has getter/setter"));
                    }
                }
            }
        }

        return $withAnnotation;
    }

    /**
     * Encryptor factory. Checks and create needed encryptor.
     *
     * @param string $classFullName Encryptor namespace and name
     * @param string $secretKey     Secret key for encryptor
     *
     * @return EncryptorInterface
     *
     * @throws \RuntimeException
     */
    private function encryptorFactory($classFullName, $secretKey)
    {
        $refClass = new \ReflectionClass($classFullName);
        if ($refClass->implementsInterface(self::ENCRYPTOR_INTERFACE_NS)) {
            return new $classFullName($secretKey);
        } else {
            throw new \RuntimeException('Encryptor must implements interface EncryptorInterface');
        }
    }

    /**
     * Check if we have entity in decoded registry.
     *
     * @param object                      $entity Some doctrine entity
     * @param \Doctrine\ORM\EntityManager $em
     *
     * @return bool
     */
    private function hasInDecodedRegistry($entity, EntityManager $em)
    {
        $className = get_class($entity);
        $metadata = $em->getClassMetadata($className);
        $getter = 'get'.self::capitalize($metadata->getIdentifier());

$metadata->getIdentifier() of type array is incompatible with the type string expected by parameter $word of VersionControl\DoctrineEncryptBundle\Subscribers\DoctrineEncryptSubscriber::capitalize().

        return isset($this->decodedRegistry[$className][$entity->$getter()]);
    }

    /**
     * Adds entity to decoded registry.
     *
     * @param object                      $entity Some doctrine entity
     * @param \Doctrine\ORM\EntityManager $em
     */
    private function addToDecodedRegistry($entity, EntityManager $em)
    {
        $className = get_class($entity);
        $metadata = $em->getClassMetadata($className);
        $getter = 'get'.self::capitalize($metadata->getIdentifier());

$metadata->getIdentifier() of type array is incompatible with the type string expected by parameter $word of VersionControl\DoctrineEncryptBundle\Subscribers\DoctrineEncryptSubscriber::capitalize().

        $this->decodedRegistry[$className][$entity->$getter()] = true;
    }
}