Discussion :

[davidbouv]

Salut les experts !

je reviens pour une nouvelle mésaventure, j'essaye d'adapter le UserBundle qui est à première vu pas fait pour la version PR7.
Je pense qu'il doit y avoir un moyen de l'adapter après plusieurs problème de configuration enfin résolus j'arrive à l'erreur suivante :

Fatal error: Class FOS\UserBundle\Entity\UserManager contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (Symfony\Component\Security\Core\User\UserProviderInterface::loadUserByAccount) in C:\wamp\www\MyProject\src\FOS\UserBundle\Entity\UserManager.php on line 13

En cherchant un peu sur le net j'ai trouvé que se serait donc un problème de compatibilité.
Alors voila je poste mon problème en espérant que quelqu'un a réussi à l'adapter ou alors que certain on déjà cherché dans le même sens et aurai des pistes pour progresser...

[stealth35]

visiblement t'as pas déclaré la méthode loadUserByUsername

[RapotOR]

Salut,

De quel UserBundle parles tu? il y a déjà eu pas mal de versions.

La dernière se trouve sur github : https://github.com/FriendsOfSymfony/UserBundle
Maintenant, je n'ai pas vraiment joué avec mais l'installation se trouve la : https://github.com/FriendsOfSymfony/.../doc/index.rst

As tu essayé de jouer avec la sécurité de base et avec une entité classique?
Par exemple; je vois que tu utilises directement un provider. As tu essayé de baser tout simplement sur Symfony\Component\Security\Core\User\UserInterface ?

[davidbouv]

J'ai mis la dernière version re-téléchargé hier.

J'ai pas encore trop farfouillé dans les options de sécurité pour l'instant ma config ressemble à ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
security:
        providers:
            fos_userbundle:
                id: fos_user.user_manager
        firewalls:
            main:
                form_login:
                    provider: fos_userbundle
 
fos_user:
        db_driver: orm
        provider_key: fos_userbundle
        class:
            model:
                user: FOS\UserBundle\Model\User
                group: FOS\UserBundle\Entity\DefaultGroup

J'ai essayé avec à la place du modèle user de userbundle de mettre le mien ça ne fonctionne pas non plus toujours la même erreur.
J'ai essayer de déclarer la méthode qu'il me demande et j'ai un autre message d'erreur me disant qu'elle n'est pas compatible :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
Entity/UserManager.php
 
    public function loadUserByAccount(AccountInterface $account)
    {
        if (!$account instanceof $this->class) {
            throw new UnsupportedAccountException(sprintf('Instances of "%s" are not supported.', get_class($account)));
        }
 
        return $this->loadUserByUsername($account->getUsername());
    }

Erreur :

Fatal error: Declaration of FOS\UserBundle\Entity\UserManager::loadUserByAccount() must be compatible with that of Symfony\Component\Security\Core\User\UserProviderInterface::loadUserByAccount() in C:\wamp\www\MyProject\src\FOS\UserBundle\Entity\UserManager.php on line 13

[stealth35]

faut refaire la meme chose je vois pas ce que tu comprends pas dans "must be compatible"

pourquoi avoir fait : AccountInterface $account, dans l'interface y'a pas de type, donc fait pareil.

montre ta classe entière

[davidbouv]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
<?php
 
namespace FOS\UserBundle\Entity;
 
use Doctrine\ORM\EntityManager;
use FOS\UserBundle\Model\UserInterface;
use FOS\UserBundle\Model\UserManager as BaseUserManager;
use FOS\UserBundle\Util\CanonicalizerInterface;
use Symfony\Component\Security\Core\Encoder\EncoderFactoryInterface;
use Symfony\Component\Validator\Constraint;
 
class UserManager extends BaseUserManager
{
    protected $em;
    protected $class;
    protected $repository;
 
    /**
     * Constructor.
     *
     * @param EncoderFactoryInterface $encoderFactory
     * @param string                  $algorithm
     * @param CanonicalizerInterface  $usernameCanonicalizer
     * @param CanonicalizerInterface  $emailCanonicalizer
     * @param EntityManager           $em
     * @param string                  $class
     */
    public function __construct(EncoderFactoryInterface $encoderFactory, $algorithm, CanonicalizerInterface $usernameCanonicalizer, CanonicalizerInterface $emailCanonicalizer, EntityManager $em, $class)
    {
        parent::__construct($encoderFactory, $algorithm, $usernameCanonicalizer, $emailCanonicalizer);
 
        $this->em = $em;
        $this->repository = $em->getRepository($class);
 
        $metadata = $em->getClassMetadata($class);
        $this->class = $metadata->name;
    }
 
    /**
     * {@inheritDoc}
     */
    public function deleteUser(UserInterface $user)
    {
        $this->em->remove($user);
        $this->em->flush();
    }
 
    /**
     * {@inheritDoc}
     */
    public function getClass()
    {
        return $this->class;
    }
 
    /**
     * {@inheritDoc}
     */
    public function findUserBy(array $criteria)
    {
        return $this->repository->findOneBy($criteria);
    }
 
    /**
     * {@inheritDoc}
     */
    public function findUsers()
    {
        return $this->repository->findAll();
    }
 
    /**
     * {@inheritDoc}
     */
    public function updateUser(UserInterface $user)
    {
        $this->updateCanonicalFields($user);
        $this->updatePassword($user);
 
        $this->em->persist($user);
        $this->em->flush();
    }
 
    /**
     * {@inheritDoc}
     */
    public function validateUnique($value, Constraint $constraint)
    {
        $fields = array_map('trim', explode(',', $constraint->property));
        $users = $this->findConflictualUsers($value, $fields);
 
        // there is no conflictual user
        if (empty($users)) {
            return true;
        }
 
        // there is no conflictual user which is not the same as the value
        if ($this->anyIsUser($value, $users)) {
            return true;
        }
 
        return false;
    }
 
    /**
     * Indicates whether the given user and all compared objects correspond to the same record
     *
     * @param UserInterface $user
     * @param array $comparisons
     * @return boolean
     */
    protected function anyIsUser($user, array $comparisons)
    {
        foreach ($comparisons as $comparison) {
            if (!$user->isUser($comparison)) {
                return false;
            }
        }
 
        return true;
    }
 
    /**
     * Gets conflictual users for the given user and constraint
     *
     * @param UserInterface $value
     * @param array $fields
     * @return array
     */
    protected function findConflictualUsers($value, array $fields)
    {
        return $this->repository->findBy($this->getCriteria($value, $fields));
    }
 
    /**
     * Gets the criteria used to find conflictual entities
     *
     * @param UserInterface $value
     * @param array $constraint
     * @return array
     */
    protected function getCriteria($value, array $fields)
    {
        $classMetadata = $this->em->getClassMetadata($this->class);
 
        $criteria = array();
        foreach ($fields as $field) {
            if (!$classMetadata->hasField($field)) {
                throw new \InvalidArgumentException(sprintf('The "%s" class metadata does not have any "%s" field or association mapping.', $this->class, $field));
            }
 
            $criteria[$field] = $classMetadata->getFieldValue($value, $field);
        }
 
        return $criteria;
    }
 
    public function loadUserByAccount($account)
    {
        if (!$account instanceof $this->class) {
            throw new UnsupportedAccountException(sprintf('Instances of "%s" are not supported.', get_class($account)));
        }
 
        return $this->loadUserByUsername($account->getUsername());
    }
}