Effacer une image dans l'édition d'un profil

Version imprimable

Bonjour tout le monde,

un petit soucis de compréhension sur l'édition d'une image.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public function editAction(Request $request, User $user)
    {
        //...
 
        if ($editForm->isSubmitted() && $editForm->isValid()) {
 
            // ici mon problème
            // je récupère mon entité user depuis notre génial Manager Doctrine.
            // je veux donc récupérer mon utilisateur avant toutes modifications, mais quand je fais mon getId (sur l'utilsateur qui doit être mis à jour)
            // je n'obtiens pas les données qui sont encore en db. mais les données de l'utilisateur de la request.
            // et bien entendu, je ne comprends pas pourquoi.
            $em = $this->getDoctrine()->getManager();
            $oldUser = $em->getRepository('BaseBundle:User')->find($user->getId());
            $oldFile = $oldUser->getPicture();
            unlink($this->getParameter('user_picture_directory').$oldFile);
 
           //...
        }

Merci d'avance.

Jisig.

tu en est sûr ?

Code:

1
2
3
 
          $oldUser = $em->getRepository('BaseBundle:User')->find($user->getId());
var_dump($oldUser); exit;

Merci pour ton aide (encore),

Oui, j'ai testé le dump et j'obtiens les même résultats qu'avec l'utilisateur de ma request

Bon ça viendrait de cette ligne qui se situe un peu plus haut

Code:

$editForm->handleRequest($request);

mais si je ne dis pas de bêtises il est juste censé checker ma requête et soumettre mon formulaire si c'est tout est ok.

Quand je regarde la fonction handleRequest de Symfony (dans le code juste ci-dessous), je ne vois rien qui pourrait changer les données reçues par l'entity manager.

Code:

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
public function handleRequest(FormInterface $form, $request = null)
    {
        if (!$request instanceof Request) {
            throw new UnexpectedTypeException($request, 'Symfony\Component\HttpFoundation\Request');
        }
 
        $name = $form->getName();
        $method = $form->getConfig()->getMethod();
 
        if ($method !== $request->getMethod()) {
            return;
        }
 
        // For request methods that must not have a request body we fetch data
        // from the query string. Otherwise we look for data in the request body.
        if ('GET' === $method || 'HEAD' === $method || 'TRACE' === $method) {
            if ('' === $name) {
                $data = $request->query->all();
            } else {
                // Don't submit GET requests if the form's name does not exist
                // in the request
                if (!$request->query->has($name)) {
                    return;
                }
 
                $data = $request->query->get($name);
            }
        } else {
            // Mark the form with an error if the uploaded size was too large
            // This is done here and not in FormValidator because $_POST is
            // empty when that error occurs. Hence the form is never submitted.
            if ($this->serverParams->hasPostMaxSizeBeenExceeded()) {
                // Submit the form, but don't clear the default values
                $form->submit(null, false);
 
                $form->addError(new FormError(
                    call_user_func($form->getConfig()->getOption('upload_max_size_message')),
                    null,
                    array('{{ max }}' => $this->serverParams->getNormalizedIniPostMaxSize())
                ));
 
                return;
            }
 
            if ('' === $name) {
                $params = $request->request->all();
                $files = $request->files->all();
            } elseif ($request->request->has($name) || $request->files->has($name)) {
                $default = $form->getConfig()->getCompound() ? array() : null;
                $params = $request->request->get($name, $default);
                $files = $request->files->get($name, $default);
            } else {
                // Don't submit the form if it is not present in the request
                return;
            }
 
            if (is_array($params) && is_array($files)) {
                $data = array_replace_recursive($params, $files);
            } else {
                $data = $params ?: $files;
            }
        }
 
        // Don't auto-submit the form unless at least one field is present.
        if ('' === $name && count(array_intersect_key($data, $form->all())) <= 0) {
            return;
        }

Du coup je ne vois pas pourquoi ça change mon résultat.

Merci

Jisig.

22/05/2017, 15h26
Nico_F

Salut,

Au vu des symptômes : il y a fort à parier que ton formulaire soit mappé sur ton entité User.
C'est ça qui provoque la modification de ton objet User : les forms Symfony utilisent les getters/setters de la classe précisée dans le data_class et modifient l'objet.

Dans le cas d'une entité lors d'une édition, l'entité est déjà managée et déjà chargée puisque tu la passes à ton formulaire. Donc ton repository n'a pas besoin de faire une vraie requête vers la BDD puisqu'il possède déjà l'objet persisté en mémoire.

C'est un inconvénient lorsqu'on mappe ses formulaires aux entités : il est compliqué de retrouver l'objet dans l'état dans lequel il était avant les modifications apportées par le formulaire.

La solution la plus propre est de ne pas mapper ses entités au formulaire, et de gérer les changements soit même après validation (on perd un peu le coté magique ou on a rien à faire de la combinaison SymfonyForm/DoctrineEntity) en ne mettant pas de data_class du tout (le résultat du form sera un tableau) ou bien en mappant son formulaire sur une classe FormModel spécifique. L'objet User ne sera pas modifié et tu pourras requête dessus et l'avoir dans son état d'origine.

Ou alors tu veux garder ce formulaire et la manière dont il fonctionne : et dans ce cas il va falloir que tu fasses des pirouettes pour récupérer l'objet User dans son état original. Et quand je dis des pirouettes ça veut dire taper directement le UnitOfWork qui possède une méthode getOriginalEntityData. Ce n'est cependant pas une manière élégante de gérer le problème.

Bon courage !
22/05/2017, 22h40
jisig

Thank you.

Merci pour ta réponse claire et complète.

je vais faire la solution manuelle dans ce cas :)

Résolu :)