upgrade

vendor/symfony/doctrine-bridge/Security/RememberMe/DoctrineTokenProvider.php

@@ -0,0 +1,126 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Bridge\Doctrine\Security\RememberMe;
+
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\Types\Type as DoctrineType;
+use Symfony\Component\Security\Core\Authentication\RememberMe\PersistentToken;
+use Symfony\Component\Security\Core\Authentication\RememberMe\PersistentTokenInterface;
+use Symfony\Component\Security\Core\Authentication\RememberMe\TokenProviderInterface;
+use Symfony\Component\Security\Core\Exception\TokenNotFoundException;
+
+/**
+ * This class provides storage for the tokens that is set in "remember me"
+ * cookies. This way no password secrets will be stored in the cookies on
+ * the client machine, and thus the security is improved.
+ *
+ * This depends only on doctrine in order to get a database connection
+ * and to do the conversion of the datetime column.
+ *
+ * In order to use this class, you need the following table in your database:
+ *
+ *     CREATE TABLE `rememberme_token` (
+ *         `series`   char(88)     UNIQUE PRIMARY KEY NOT NULL,
+ *         `value`    char(88)     NOT NULL,
+ *         `lastUsed` datetime     NOT NULL,
+ *         `class`    varchar(100) NOT NULL,
+ *         `username` varchar(200) NOT NULL
+ *     );
+ */
+class DoctrineTokenProvider implements TokenProviderInterface
+{
+    private $conn;
+
+    public function __construct(Connection $conn)
+    {
+        $this->conn = $conn;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function loadTokenBySeries($series)
+    {
+        // the alias for lastUsed works around case insensitivity in PostgreSQL
+        $sql = 'SELECT class, username, value, lastUsed AS last_used'
+            .' FROM rememberme_token WHERE series=:series';
+        $paramValues = array('series' => $series);
+        $paramTypes = array('series' => \PDO::PARAM_STR);
+        $stmt = $this->conn->executeQuery($sql, $paramValues, $paramTypes);
+        $row = $stmt->fetch(\PDO::FETCH_ASSOC);
+
+        if ($row) {
+            return new PersistentToken($row['class'], $row['username'], $series, $row['value'], new \DateTime($row['last_used']));
+        }
+
+        throw new TokenNotFoundException('No token found.');
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function deleteTokenBySeries($series)
+    {
+        $sql = 'DELETE FROM rememberme_token WHERE series=:series';
+        $paramValues = array('series' => $series);
+        $paramTypes = array('series' => \PDO::PARAM_STR);
+        $this->conn->executeUpdate($sql, $paramValues, $paramTypes);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function updateToken($series, $tokenValue, \DateTime $lastUsed)
+    {
+        $sql = 'UPDATE rememberme_token SET value=:value, lastUsed=:lastUsed'
+            .' WHERE series=:series';
+        $paramValues = array(
+            'value' => $tokenValue,
+            'lastUsed' => $lastUsed,
+            'series' => $series,
+        );
+        $paramTypes = array(
+            'value' => \PDO::PARAM_STR,
+            'lastUsed' => DoctrineType::DATETIME,
+            'series' => \PDO::PARAM_STR,
+        );
+        $updated = $this->conn->executeUpdate($sql, $paramValues, $paramTypes);
+        if ($updated < 1) {
+            throw new TokenNotFoundException('No token found.');
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createNewToken(PersistentTokenInterface $token)
+    {
+        $sql = 'INSERT INTO rememberme_token'
+            .' (class, username, series, value, lastUsed)'
+            .' VALUES (:class, :username, :series, :value, :lastUsed)';
+        $paramValues = array(
+            'class' => $token->getClass(),
+            'username' => $token->getUsername(),
+            'series' => $token->getSeries(),
+            'value' => $token->getTokenValue(),
+            'lastUsed' => $token->getLastUsed(),
+        );
+        $paramTypes = array(
+            'class' => \PDO::PARAM_STR,
+            'username' => \PDO::PARAM_STR,
+            'series' => \PDO::PARAM_STR,
+            'value' => \PDO::PARAM_STR,
+            'lastUsed' => DoctrineType::DATETIME,
+        );
+        $this->conn->executeUpdate($sql, $paramValues, $paramTypes);
+    }
+}

vendor/symfony/doctrine-bridge/Security/User/EntityUserProvider.php

@@ -0,0 +1,143 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Bridge\Doctrine\Security\User;
+
+use Doctrine\Common\Persistence\ManagerRegistry;
+use Symfony\Component\Security\Core\Exception\UnsupportedUserException;
+use Symfony\Component\Security\Core\Exception\UsernameNotFoundException;
+use Symfony\Component\Security\Core\User\UserInterface;
+use Symfony\Component\Security\Core\User\UserProviderInterface;
+
+/**
+ * Wrapper around a Doctrine ObjectManager.
+ *
+ * Provides easy to use provisioning for Doctrine entity users.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class EntityUserProvider implements UserProviderInterface
+{
+    private $registry;
+    private $managerName;
+    private $classOrAlias;
+    private $class;
+    private $property;
+
+    public function __construct(ManagerRegistry $registry, $classOrAlias, $property = null, $managerName = null)
+    {
+        $this->registry = $registry;
+        $this->managerName = $managerName;
+        $this->classOrAlias = $classOrAlias;
+        $this->property = $property;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function loadUserByUsername($username)
+    {
+        $repository = $this->getRepository();
+        if (null !== $this->property) {
+            $user = $repository->findOneBy(array($this->property => $username));
+        } else {
+            if (!$repository instanceof UserLoaderInterface) {
+                if (!$repository instanceof UserProviderInterface) {
+                    throw new \InvalidArgumentException(sprintf('You must either make the "%s" entity Doctrine Repository ("%s") implement "Symfony\Bridge\Doctrine\Security\User\UserLoaderInterface" or set the "property" option in the corresponding entity provider configuration.', $this->classOrAlias, \get_class($repository)));
+                }
+
+                @trigger_error('Implementing Symfony\Component\Security\Core\User\UserProviderInterface in a Doctrine repository when using the entity provider is deprecated since Symfony 2.8 and will not be supported in 3.0. Make the repository implement Symfony\Bridge\Doctrine\Security\User\UserLoaderInterface instead.', E_USER_DEPRECATED);
+            }
+
+            $user = $repository->loadUserByUsername($username);
+        }
+
+        if (null === $user) {
+            throw new UsernameNotFoundException(sprintf('User "%s" not found.', $username));
+        }
+
+        return $user;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function refreshUser(UserInterface $user)
+    {
+        $class = $this->getClass();
+        if (!$user instanceof $class) {
+            throw new UnsupportedUserException(sprintf('Instances of "%s" are not supported.', \get_class($user)));
+        }
+
+        $repository = $this->getRepository();
+        if ($repository instanceof UserProviderInterface) {
+            $refreshedUser = $repository->refreshUser($user);
+        } else {
+            // The user must be reloaded via the primary key as all other data
+            // might have changed without proper persistence in the database.
+            // That's the case when the user has been changed by a form with
+            // validation errors.
+            if (!$id = $this->getClassMetadata()->getIdentifierValues($user)) {
+                throw new \InvalidArgumentException('You cannot refresh a user '.
+                    'from the EntityUserProvider that does not contain an identifier. '.
+                    'The user object has to be serialized with its own identifier '.
+                    'mapped by Doctrine.'
+                );
+            }
+
+            $refreshedUser = $repository->find($id);
+            if (null === $refreshedUser) {
+                throw new UsernameNotFoundException(sprintf('User with id %s not found', json_encode($id)));
+            }
+        }
+
+        return $refreshedUser;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function supportsClass($class)
+    {
+        return $class === $this->getClass() || is_subclass_of($class, $this->getClass());
+    }
+
+    private function getObjectManager()
+    {
+        return $this->registry->getManager($this->managerName);
+    }
+
+    private function getRepository()
+    {
+        return $this->getObjectManager()->getRepository($this->classOrAlias);
+    }
+
+    private function getClass()
+    {
+        if (null === $this->class) {
+            $class = $this->classOrAlias;
+
+            if (false !== strpos($class, ':')) {
+                $class = $this->getClassMetadata()->getName();
+            }
+
+            $this->class = $class;
+        }
+
+        return $this->class;
+    }
+
+    private function getClassMetadata()
+    {
+        return $this->getObjectManager()->getClassMetadata($this->classOrAlias);
+    }
+}

vendor/symfony/doctrine-bridge/Security/User/UserLoaderInterface.php

@@ -0,0 +1,39 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Bridge\Doctrine\Security\User;
+
+use Symfony\Component\Security\Core\User\UserInterface;
+
+/**
+ * Represents a class that loads UserInterface objects from Doctrine source for the authentication system.
+ *
+ * This interface is meant to facilitate the loading of a User from Doctrine source using a custom method.
+ * If you want to implement your own logic of retrieving the user from Doctrine your repository should implement this
+ * interface.
+ *
+ * @see UserInterface
+ *
+ * @author Michal Trojanowski <michal@kmt-studio.pl>
+ */
+interface UserLoaderInterface
+{
+    /**
+     * Loads the user for the given username.
+     *
+     * This method must return null if the user is not found.
+     *
+     * @param string $username The username
+     *
+     * @return UserInterface|null
+     */
+    public function loadUserByUsername($username);
+}