[2.x] Problème OnetoMany, enregistrement null dans la base

Problème OnetoMany, enregistrement null dans la base

Bonjour,

Je suis débutant en symfony et donc j'ai décidé de commencer par symfony 2.0, je suis en train de créer une application d'essais pour voir comment le framework fonctionne et je rencontre une erreur dont je n'ai pas trouvé la solution sur les forums, je viens donc vous poser une petite question.

J'ai une entité Utilisateurs (avec FOSUserBundle) et une entité Appartements. Les appartements appartiennent aux utilisateurs qui peuvent en avoir un ou +.

Voici le code des entités :

Utilisateurs :

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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
<?php
namespace MyApp\UtilisateursBundle\Entity;
use FOS\UserBundle\Entity\User as BaseUser;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Validator\Constraints as Assert;
 
/**
 * @ORM\Entity
 */
class Utilisateurs extends BaseUser
{
    /**
    * @ORM\Id
    * @ORM\Column(type="integer")
    * @ORM\generatedValue(strategy="AUTO")
    */
    protected $id;
 
	/**
	* @ORM\Column(type= "string", length= "100")
	* @Assert\NotBlank()
	* @Assert\MinLength(3)
	* @Assert\MaxLength(100)
	*/
	private $nom;
 
	/**
	* @ORM\OnetoMany (targetEntity= "MyApp\UtilisateursBundle\Entity\Utilisateurs", mappedBy="utilisateurs")
	*/
	protected $appartements;
 
	public function __construct()
    {
        parent::__construct();
    }
 
    /**
     * Get id
     *
     * @return integer 
     */
    public function getId()
    {
        return $this->id;
    }
 
    /**
     * Set nom
     *
     * @param string $nom
     */
    public function setNom($nom)
    {
        $this->nom = $nom;
    }
 
    /**
     * Get nom
     *
     * @return string 
     */
    public function getNom()
    {
        return $this->nom;
    }
 
    /**
     * Add appartements
     *
     * @param MyApp\UtilisateursBundle\Entity\Utilisateurs $appartements
     */
    public function addUtilisateurs(\MyApp\UtilisateursBundle\Entity\Utilisateurs $appartements)
    {
        $this->appartements[] = $appartements;
    }
 
    /**
     * Get appartements
     *
     * @return Doctrine\Common\Collections\Collection 
     */
    public function getAppartements()
    {
        return $this->appartements;
    }
}

et Appartements

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
 
<?php
 
namespace MyApp\AppartementsBundle\Entity;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Validator\Constraints as Assert;
 
/**
* @ORM\Entity
*/
class Appartements {
	/**
	* @ORM\GeneratedValue
	* @ORM\Id
	* @ORM\Column(type= "integer")
	*/
	private $id;
 
        /**
	* @ORM\Column(type= "string", length= "100")
	* @Assert\NotBlank()
	* @Assert\MinLength(3)
	* @Assert\MaxLength(100)
	*/
	private $titre;
 
        /**
	* @ORM\ManytoOne (targetEntity= "MyApp\UtilisateursBundle\Entity\Utilisateurs", inversedBy="appartements")
	*/
	protected $utilisateurs;
 
        /**
     * Set Utilisateurs
     *
     * @param MyApp\UtilisateursBundle\Entity\Utilisateurs $utilisateurs
     */
    public function setUtilisateurs(\MyApp\UtilisateursBundle\Entity\Utilisateurs $utilisateurs)
    {
        $this->Utilisateurs = $utilisateurs;
    }
 
    /**
     * Get Utilisateurs
     *
     * @return MyApp\UtilisateursBundle\Entity\Utilisateurs 
     */
    public function getUtilisateurs()
    {
        return $this->Utilisateurs;
    }

J'ai ensuite un formulaire pour l'ajout d'appartement

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
namespace MyApp\AppartementsBundle\Form;
 
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilder;
 
class AppartementsForm extends AbstractType
{
    public function buildForm(FormBuilder $builder, array $options)
    {        
        $builder
            ->add('titre', 'text')
    }
}

Je ne vous ai pas tout mis pour plus de clarté mais le reste est ok

Puis j'ai mon controller pour l'action d'ajout :

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
 
      public function ajouterAction() {
 
		$appartements = new Appartements();
		$form = $this->container->get('form.factory')->create(new AppartementsForm(), $appartements);
 
		$request = $this->container->get('request');
 
		if ($request->getMethod() == 'POST')  {
			$form->bindRequest($request);
 
			if ($form->isValid()) {
				$user = $this->get('security.context')->getToken()->getUser();
				$appartements->setUtilisateurs($user);
			  	$em = $this->container->get('doctrine')->getEntityManager();
			  	$em->persist($appartements);
			  	$em->flush();
			  	$message='Votre appartement a été ajouté avec succès !';
				// redirection vers les autres options du formulaire et récupération de l'id
			}
		}
 
		return $this->container->get('templating')->renderResponse('MyAppAppartementsBundle:Membres:ajouter.html.twig', array( 'form' => $form->createView(), 'message' => '' ));
 
	}

J'ai un problème avec tout cela qui est le suivant :

lors de l'insertion en base de données, le champs Utilisateurs_id qui a été créé par doctrine lors de la création de la base reste null.
Si je change la ligne

Code:

1
2
3
 
$user = $this->get('security.context')->getToken()->getUser();
$appartements->setUtilisateurs($user);

en mettant l'id ->getId() pour ne donner que le numéro le système me dit qui lui faut une instance de MyApp\UtilisateursBundle\Entity\Utilisateurs ce qu'il a avec la version actuelle mais le champs reste null quoi qu'il arrive.
J'ai donc essayé en ajoutant le champs utilisateurs dans le formulaire, il me met alors une liste déroulante des différents utilisateurs et même en sélectionnant un utilisateur, le champs reste à null lors de l'enregistrement.

En gros, comment accroché mon appartement à un utilisateur...

Est-ce que vous avez une idée ou une piste ?

Merci d'avance,
Thibault

Salut,

Sauf erreur, il manque ceci dans la définition de ton entité Apprtement :
Code:

1 2 3 4 ... @ORM\JoinColumn(name="utilisateurs_id", referencedColumnName="id") ...
un petit "php/app console doctrine:schema:update --force", et ca devrait être bon !

Bonne soirée.

Salut,

Merci pour ta réponse, j'ai ajouté la ligne et forcé l'update mais cela ne change rien.

Cependant par rapport à ta remarque, j'ai lu dans la documentation doctrine que cette ligne était optionnelle. Dans le doute, elle est ajoutée ;-)

Mais l'enregistrement reste toujours à null

Bonne soirée,
Thibault

Ah oui !

J'avais oublié ;) Merci. Je regarde dès que possible pour ton problème ...

bonne soirée

Re,

Y a peut être une solution. Elle est pas génial, mais ca peut marcher !

Si au lieu de faire
Code:

1 2 $user = $this->get('security.context')->getToken()->getUser();
tu fais
Code:

1 2 3 $user_id = $this->get('security.context')->getToken()->getUser()->getId(); $appartements->setUtilisateurs($user_id);
et puis tu changes le param de ton setter :
Code:

1 2 public function setUtilisateurs($utilisateurs_id)
Dis moi ce que ca donne ...

Re,

Merci pour ton aide en tout cas :oops:

Test effectué, j'ai changer le @param ainsi que la fonction en elle même, l'id est bien transmis lorsque je fais un test sur la valeur de $user_id. Mais l'enregistrement reste null, j'ai fais un test avec phpMyAdmin, la base me propose une liste déroulante des Id utilisateurs et l'enregistrement se passe bien.

Très étrange, surtout que lorsque je demande d'afficher une instance de user, j'ai bien mon object utilisateur qui est chargé avec l'utilisateur en cours...

je bloque un peu...

A très vite,
Thibault

Bonjour,

dans ce code tu utilise une majuscule dans le setter, mais pas dans l'attribut.
Essaie de tout mettre en minuscule
Code:

1 2 3 4 5 6 7 protected $utilisateurs; public function setUtilisateurs(\MyApp\UtilisateursBundle\Entity\Utilisateurs $utilisateurs) { $this->utilisateurs = $utilisateurs; }
remarque: pourquoi mettre utilisateurs au pluriel s'il n'y en a qu'un par appartement?

et aussi dans Utilisateur tu dois instancier l'attribut Appartements
Code:

1 2 3 4 5 6 7 8 protected $appartements; public function __construct() { parent::__construct(); $this->appartements=new \Doctrine\Common\Collection\ArrayCollection();//je suis pas sûr du namespace , à vérifier }

Bonsoir,

Merci arnooo999 pour ta réponse, je ne sais pas laquelle des deux actions à eu raison de l'erreur mais l'enregistrement n'est plus null.

Bonne soirée,
Thibault

onetomany enregistrement null

Bonjour,
Cela fait maintenant 2 jour que je bloque sur l enregistrement avec une relation de type onetomany.

Alors le but est que j ai une facture qui a plusieurs elements de facture
Donc quand je creer une facture j ai un formulaire imbriquer multiple qui apparait.
Tout marche sauf que mon id de facture dans la bdd est null.
Voici mes entites

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
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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
<?php
namespace Autofacture\FactureBundle\Entity;
 
use Doctrine\ORM\Mapping as ORM;
use Doctrine\Common\Collections\ArrayCollection;
 
/**
 * @ORM\Entity(repositoryClass="Autofacture\FactureBundle\Entity\FactureRepository")
 * @ORM\Table(name="Facture")
 */
class Facture{
	/**
	* @ORM\Id
	* @ORM\Column(type="integer")
	* @ORM\GeneratedValue(strategy="AUTO")
	*/
	protected $id;
 
	/**
	* @var \datetime $date
	* @ORM\Column(type="datetime")
	*/
	protected $date;
 
	/**
	* @ORM\Column(type="integer")
	*/
	protected $etat;
 
	/**
	* @ORM\OneToMany(targetEntity="Autofacture\FactureBundle\Entity\ElementFacture", mappedBy="facture", cascade={"persist"})
	*/
	protected $elements_facture; // Ici elements_facture prend un « s », car un article a plusieurs elements de facture !
 
	/**
    * @ORM\ManyToOne(targetEntity="Autofacture\ClientBundle\Entity\Client", inversedBy="factures")
    * @ORM\JoinColumn(name="client", referencedColumnName="id")
    */
	protected $client;
 
	/**
    * @ORM\ManyToOne(targetEntity="Autofacture\UtilisateurBundle\Entity\Utilisateur", inversedBy="factures")
    * @ORM\JoinColumn(name="utilisateur", referencedColumnName="id")
    */
	protected $utilisateur;
    /**
     * Constructor
     */
    public function __construct()
    {
        $this->elements_facture = new \Doctrine\Common\Collections\ArrayCollection();
    }
 
    /**
     * Get id
     *
     * @return integer 
     */
    public function getId()
    {
        return $this->id;
    }
 
    /**
     * Set date
     *
     * @param \DateTime $date
     * @return Facture
     */
    public function setDate($date)
    {
        $this->date = $date;
 
        return $this;
    }
 
    /**
     * Get date
     *
     * @return \DateTime 
     */
    public function getDate()
    {
        return $this->date;
    }
 
    /**
     * Set etat
     *
     * @param integer $etat
     * @return Facture
     */
    public function setEtat($etat)
    {
        $this->etat = $etat;
 
        return $this;
    }
 
    /**
     * Get etat
     *
     * @return integer 
     */
    public function getEtat()
    {
        return $this->etat;
    }
 
    /**
     * Add elements_facture
     *
     * @param \Autofacture\FactureBundle\Entity\ElementFacture $elementsFacture
     * @return Facture
     */
    public function addElementsFacture(\Autofacture\FactureBundle\Entity\ElementFacture $elementsFacture)
    {
        $this->elements_facture[] = $elementsFacture;
 
        return $this;
    }
 
    /**
     * Remove elements_facture
     *
     * @param \Autofacture\FactureBundle\Entity\ElementFacture $elementsFacture
     */
    public function removeElementsFacture(\Autofacture\FactureBundle\Entity\ElementFacture $elementsFacture)
    {
        $this->elements_facture->removeElement($elementsFacture);
    }
 
    /**
     * Get elements_facture
     *
     * @return \Doctrine\Common\Collections\Collection 
     */
    public function getElementsFacture()
    {
        return $this->elements_facture;
    }
 
	public function setElementsFacture(ArrayCollection $elements_facture)
	{
		foreach ($elements_facture as $tag) {
			$tag->setFacture($this);
		}
 
		$this->elements_facture = $elements_facture;
	}
 
    /**
     * Set client
     *
     * @param \Autofacture\ClientBundle\Entity\Client $client
     * @return Facture
     */
    public function setClient(\Autofacture\ClientBundle\Entity\Client $client = null)
    {
        $this->client = $client;
 
        return $this;
    }
 
    /**
     * Get client
     *
     * @return \Autofacture\ClientBundle\Entity\Client 
     */
    public function getClient()
    {
        return $this->client;
    }
 
    /**
     * Set utilisateur
     *
     * @param \Autofacture\UtilisateurBundle\Entity\Utilisateur $utilisateur
     * @return Facture
     */
    public function setUtilisateur(\Autofacture\UtilisateurBundle\Entity\Utilisateur $utilisateur = null)
    {
        $this->utilisateur = $utilisateur;
 
        return $this;
    }
 
    /**
     * Get utilisateur
     *
     * @return \Autofacture\UtilisateurBundle\Entity\Utilisateur 
     */
    public function getUtilisateur()
    {
        return $this->utilisateur;
    }
}

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
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
<?php
namespace Autofacture\FactureBundle\Entity;
 
use Doctrine\ORM\Mapping as ORM;
 
/**
 * @ORM\Entity
 * @ORM\Table(name="Element_facture")
 */
class ElementFacture{
	/**
	* @ORM\Id
	* @ORM\Column(type="integer")
	* @ORM\GeneratedValue(strategy="AUTO")
	*/
	protected $id;
 
	/**
	* @ORM\Column(type="integer")
	*/
	protected $prix;
 
	/**
	* @ORM\Column(type="string", length=255)
	*/
	protected $description;
 
	/**
   * @ORM\ManyToOne(targetEntity="Autofacture\FactureBundle\Entity\Facture",inversedBy="elements_facture")
   * @ORM\JoinColumn(name="facture", referencedColumnName="id")
   */
	protected $facture;	
 
    /**
     * Get id
     *
     * @return integer 
     */
    public function getId()
    {
        return $this->id;
    }
 
    /**
     * Set prix
     *
     * @param integer $prix
     * @return ElementFacture
     */
    public function setPrix($prix)
    {
        $this->prix = $prix;
 
        return $this;
    }
 
    /**
     * Get prix
     *
     * @return integer 
     */
    public function getPrix()
    {
        return $this->prix;
    }
 
    /**
     * Set description
     *
     * @param string $description
     * @return ElementFacture
     */
    public function setDescription($description)
    {
        $this->description = $description;
 
        return $this;
    }
 
    /**
     * Get description
     *
     * @return string 
     */
    public function getDescription()
    {
        return $this->description;
    }
 
    /**
     * Set facture
     *
     * @param \Autofacture\FactureBundle\Entity\Facture $facture
     * @return ElementFacture
     */
    public function setFacture(\Autofacture\FactureBundle\Entity\Facture $facture)
    {
        $this->facture = $facture;
    }
 
    /**
     * Get facture
     *
     * @return \Autofacture\FactureBundle\Entity\Facture 
     */
    public function getFacture()
    {
        return $this->facture;
    }
}

Ensuite voici mes formulaires

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
<?php
 
namespace Autofacture\FactureBundle\Form;
 
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolverInterface;
 
use Autofacture\ClientBundle\Entity\Client;
use Autofacture\UtilisateurBundle\Form\UtilisateurType;
 
class FactureType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('date')
            ->add('etat')
            ->add('client', 'entity', array(
				'class'    => 'AutofactureClientBundle:Client',
				'property' => 'nom',
				'multiple' => false))
			->add('elements_facture', 'collection', array('type'         => new ElementFactureType(),
                                              'allow_add'    => true,
                                              'allow_delete' => true,
											  'by_reference' => false,))
 
        ;
    }
 
    public function setDefaultOptions(OptionsResolverInterface $resolver)
    {
        $resolver->setDefaults(array(
            'data_class' => 'Autofacture\FactureBundle\Entity\Facture'
        ));
    }
 
    public function getName()
    {
        return 'autofacture_facturebundle_facturetype';
    }
}

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
<?php
 
namespace Autofacture\FactureBundle\Form;
 
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolverInterface;
 
class ElementFactureType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('prix')
            ->add('description')
        ;
    }
 
    public function setDefaultOptions(OptionsResolverInterface $resolver)
    {
        $resolver->setDefaults(array(
            'data_class' => 'Autofacture\FactureBundle\Entity\ElementFacture'
        ));
    }
 
    public function getName()
    {
        return 'autofacture_facturebundle_elementfacturetype';
    }
}

et voici mon controlleur de Facture

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
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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
<?php
 
namespace Autofacture\FactureBundle\Controller;
 
use Symfony\Component\HttpFoundation\Request;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\Component\HttpFoundation\Response;
 
use Autofacture\FactureBundle\Entity\Facture;
use Autofacture\FactureBundle\Form\FactureType;
 
 
/**
 * Facture controller.
 *
 */
class FactureController extends Controller
{
    /**
     * Lists all Facture entities.
     *
     */
    public function indexAction()
    {
        $em = $this->getDoctrine()->getManager();
 
        $entities = $em->getRepository('AutofactureFactureBundle:Facture')->findAll();
 
        return $this->render('AutofactureFactureBundle:Facture:index.html.twig', array(
            'entities' => $entities,
        ));
    }
 
	public function voirFacturesAction($id)
    {
        $em = $this->getDoctrine()->getManager();
 
        $entity = $em->getRepository('AutofactureFactureBundle:Facture')->getAvecClient($id);
 
        if (!$entity) {
            throw $this->createNotFoundException('Unable to find facture entity.');
        }
 
 
        return $this->render('AutofactureFactureBundle:Facture:mes_factures.html.twig', array(
            'entity'      => $entity));
 
    }
 
	public function voirUneFactureAction($id)
    {
        $em = $this->getDoctrine()->getManager();
 
        $entity = $em->getRepository('AutofactureFactureBundle:Facture')->getUneFacture($id);
 
        if (!$entity) {
            throw $this->createNotFoundException('Unable to find facture entity.');
        }		
 
        return $this->render('AutofactureFactureBundle:Facture:une_facture.html.twig', array(
            'entity'      => $entity));
 
    }
 
	public function genererPDFAction($id)
	{
		$em = $this->getDoctrine()->getManager();
 
        $entity = $em->getRepository('AutofactureFactureBundle:Facture')->getUneFacture($id);
 
		$html = $this->renderView('AutofactureFactureBundle:facture:pdf.html.twig', array(
            'entity'      => $entity));	
 
        return new Response(
            $this->get('knp_snappy.pdf')->getOutputFromHtml($html),
            200,
            array(
                'Content-Type'          => 'application/pdf',
                'Content-Disposition'   => 'attachment; filename="facture.pdf"'
            )
         );
	}
 
 
 
 
    /**
     * Creates a new Facture entity.
     *
     */
    public function createAction(Request $request)
    {
        $entity  = new Facture();
        $form = $this->createForm(new FactureType(), $entity);
        $form->bind($request);
 
		$user = $this->getUser();
		if (null === $user) {
		// Ici, l'utilisateur est anonyme ou l'URL n'est pas derrière un pare-feu
		} else {
			$entity->setUtilisateur($user);
			if ($form->isValid()) {
				$em = $this->getDoctrine()->getManager();
				$em->persist($entity);
				$em->flush();
 
				return $this->redirect($this->generateUrl('facture_show', array('id' => $entity->getId())));
			}
			return $this->render('AutofactureFactureBundle:Facture:new.html.twig', array(
				'entity' => $entity,
				'form'   => $form->createView(),
			));
		}
    }
 
    /**
     * Displays a form to create a new Facture entity.
     *
     */
    public function newAction()
    {
        $em = $this->getDoctrine()->getManager();
		$entity = new Facture();
		$utilisateur = $em->getRepository('AutofactureUtilisateurBundle:Utilisateur')->find(1);
		$entity->setUtilisateur($utilisateur);
 
        $form   = $this->createForm(new FactureType(), $entity);
 
        return $this->render('AutofactureFactureBundle:Facture:new.html.twig', array(
            'entity' => $entity,
            'form'   => $form->createView(),
        ));
    }
 
    /**
     * Finds and displays a Facture entity.
     *
     */
    public function showAction($id)
    {
        $em = $this->getDoctrine()->getManager();
 
        $entity = $em->getRepository('AutofactureFactureBundle:Facture')->find($id);
 
        if (!$entity) {
            throw $this->createNotFoundException('Unable to find Facture entity.');
        }
 
        $deleteForm = $this->createDeleteForm($id);
 
        return $this->render('AutofactureFactureBundle:Facture:show.html.twig', array(
            'entity'      => $entity,
            'delete_form' => $deleteForm->createView(),        ));
    }
 
    /**
     * Displays a form to edit an existing Facture entity.
     *
     */
    public function editAction($id)
    {
        $em = $this->getDoctrine()->getManager();
 
        $entity = $em->getRepository('AutofactureFactureBundle:Facture')->find($id);
 
        if (!$entity) {
            throw $this->createNotFoundException('Unable to find Facture entity.');
        }
 
        $editForm = $this->createForm(new FactureType(), $entity);
        $deleteForm = $this->createDeleteForm($id);
 
        return $this->render('AutofactureFactureBundle:Facture:edit.html.twig', array(
            'entity'      => $entity,
            'edit_form'   => $editForm->createView(),
            'delete_form' => $deleteForm->createView(),
        ));
    }
 
    /**
     * Edits an existing Facture entity.
     *
     */
    public function updateAction(Request $request, $id)
    {
        $em = $this->getDoctrine()->getManager();
 
        $entity = $em->getRepository('AutofactureFactureBundle:Facture')->find($id);
 
        if (!$entity) {
            throw $this->createNotFoundException('Unable to find Facture entity.');
        }
 
        $deleteForm = $this->createDeleteForm($id);
        $editForm = $this->createForm(new FactureType(), $entity);
        $editForm->bind($request);
 
        if ($editForm->isValid()) {
            $em->persist($entity);
            $em->flush();
 
            return $this->redirect($this->generateUrl('facture_edit', array('id' => $id)));
        }
 
        return $this->render('AutofactureFactureBundle:Facture:edit.html.twig', array(
            'entity'      => $entity,
            'edit_form'   => $editForm->createView(),
            'delete_form' => $deleteForm->createView(),
        ));
    }
 
    /**
     * Deletes a Facture entity.
     *
     */
    public function deleteAction(Request $request, $id)
    {
        $form = $this->createDeleteForm($id);
        $form->bind($request);
 
        if ($form->isValid()) {
            $em = $this->getDoctrine()->getManager();
            $entity = $em->getRepository('AutofactureFactureBundle:Facture')->find($id);
 
            if (!$entity) {
                throw $this->createNotFoundException('Unable to find Facture entity.');
            }
 
            $em->remove($entity);
            $em->flush();
        }
 
        return $this->redirect($this->generateUrl('facture'));
    }
 
    /**
     * Creates a form to delete a Facture entity by id.
     *
     * @param mixed $id The entity id
     *
     * @return Symfony\Component\Form\Form The form
     */
    private function createDeleteForm($id)
    {
        return $this->createFormBuilder(array('id' => $id))
            ->add('id', 'hidden')
            ->getForm()
        ;
    }
}

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
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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
<?php
 
namespace Autofacture\FactureBundle\Controller;
 
use Symfony\Component\HttpFoundation\Request;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
 
use Autofacture\FactureBundle\Entity\ElementFacture;
use Autofacture\FactureBundle\Form\ElementFactureType;
 
/**
 * ElementFacture controller.
 *
 */
class ElementFactureController extends Controller
{
    /**
     * Lists all ElementFacture entities.
     *
     */
    public function indexAction()
    {
        $em = $this->getDoctrine()->getManager();
 
        $entities = $em->getRepository('AutofactureFactureBundle:ElementFacture')->findAll();
 
        return $this->render('AutofactureFactureBundle:ElementFacture:index.html.twig', array(
            'entities' => $entities,
        ));
    }
 
    /**
     * Creates a new ElementFacture entity.
     *
     */
    public function createAction(Request $request)
    {
        $entity  = new ElementFacture();
        $form = $this->createForm(new ElementFactureType(), $entity);
        $form->bind($request);
 
        if ($form->isValid()) {
            $em = $this->getDoctrine()->getManager();
            $em->persist($entity);
            $em->flush();
 
            return $this->redirect($this->generateUrl('element_facture_show', array('id' => $entity->getId())));
        }
 
        return $this->render('AutofactureFactureBundle:ElementFacture:new.html.twig', array(
            'entity' => $entity,
            'form'   => $form->createView(),
        ));
    }
 
    /**
     * Displays a form to create a new ElementFacture entity.
     *
     */
    public function newAction()
    {
        $entity = new ElementFacture();
        $form   = $this->createForm(new ElementFactureType(), $entity);
 
        return $this->render('AutofactureFactureBundle:ElementFacture:new.html.twig', array(
            'entity' => $entity,
            'form'   => $form->createView(),
        ));
    }
 
    /**
     * Finds and displays a ElementFacture entity.
     *
     */
    public function showAction($id)
    {
        $em = $this->getDoctrine()->getManager();
 
        $entity = $em->getRepository('AutofactureFactureBundle:ElementFacture')->find($id);
 
        if (!$entity) {
            throw $this->createNotFoundException('Unable to find ElementFacture entity.');
        }
 
        $deleteForm = $this->createDeleteForm($id);
 
        return $this->render('AutofactureFactureBundle:ElementFacture:show.html.twig', array(
            'entity'      => $entity,
            'delete_form' => $deleteForm->createView(),        ));
    }
 
    /**
     * Displays a form to edit an existing ElementFacture entity.
     *
     */
    public function editAction($id)
    {
        $em = $this->getDoctrine()->getManager();
 
        $entity = $em->getRepository('AutofactureFactureBundle:ElementFacture')->find($id);
 
        if (!$entity) {
            throw $this->createNotFoundException('Unable to find ElementFacture entity.');
        }
 
        $editForm = $this->createForm(new ElementFactureType(), $entity);
        $deleteForm = $this->createDeleteForm($id);
 
        return $this->render('AutofactureFactureBundle:ElementFacture:edit.html.twig', array(
            'entity'      => $entity,
            'edit_form'   => $editForm->createView(),
            'delete_form' => $deleteForm->createView(),
        ));
    }
 
    /**
     * Edits an existing ElementFacture entity.
     *
     */
    public function updateAction(Request $request, $id)
    {
        $em = $this->getDoctrine()->getManager();
 
        $entity = $em->getRepository('AutofactureFactureBundle:ElementFacture')->find($id);
 
        if (!$entity) {
            throw $this->createNotFoundException('Unable to find ElementFacture entity.');
        }
 
        $deleteForm = $this->createDeleteForm($id);
        $editForm = $this->createForm(new ElementFactureType(), $entity);
        $editForm->bind($request);
 
        if ($editForm->isValid()) {
            $em->persist($entity);
            $em->flush();
 
            return $this->redirect($this->generateUrl('element_facture_edit', array('id' => $id)));
        }
 
        return $this->render('AutofactureFactureBundle:ElementFacture:edit.html.twig', array(
            'entity'      => $entity,
            'edit_form'   => $editForm->createView(),
            'delete_form' => $deleteForm->createView(),
        ));
    }
 
    /**
     * Deletes a ElementFacture entity.
     *
     */
    public function deleteAction(Request $request, $id)
    {
        $form = $this->createDeleteForm($id);
        $form->bind($request);
 
        if ($form->isValid()) {
            $em = $this->getDoctrine()->getManager();
            $entity = $em->getRepository('AutofactureFactureBundle:ElementFacture')->find($id);
 
            if (!$entity) {
                throw $this->createNotFoundException('Unable to find ElementFacture entity.');
            }
 
            $em->remove($entity);
            $em->flush();
        }
 
        return $this->redirect($this->generateUrl('element_facture'));
    }
 
    /**
     * Creates a form to delete a ElementFacture entity by id.
     *
     * @param mixed $id The entity id
     *
     * @return Symfony\Component\Form\Form The form
     */
    private function createDeleteForm($id)
    {
        return $this->createFormBuilder(array('id' => $id))
            ->add('id', 'hidden')
            ->getForm()
        ;
    }
}

Et pour finir mon TWIG

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
68
69
70
71
72
73
74
75
76
77
78
79
{% extends '::base.html.twig' %}
 
{% block body -%}
    <h1>Facture creation</h1>
 
    <form action="{{ path('facture_create') }}" method="post" {{ form_enctype(form) }}>
        {{ form_widget(form) }}
        <p>
            <button type="submit">Create</button>
        </p>
    </form>
 
<script src="http://code.jquery.com/jquery-1.8.2.min.js"></script>
 
<script type="text/javascript">
$(document).ready(function() {
  // On récupère la balise <div> en question qui contient l'attribut « data-prototype » qui nous intéresse.
  var $container = $('div#autofacture_facturebundle_facturetype_elements_facture');
 
  // On ajoute un lien pour ajouter une nouvelle catégorie
  var $lienAjout = $('<a href="#" id="ajout_elements" class="btn">Ajouter un element</a>');
  $container.append($lienAjout);
 
  // On ajoute un nouveau champ à chaque clic sur le lien d'ajout.
  $lienAjout.click(function(e) {
    ajouterElement($container);
    e.preventDefault(); // évite qu'un # apparaisse dans l'URL
    return false;
  });
 
  // On définit un compteur unique pour nommer les champs qu'on va ajouter dynamiquement
  var index = $container.find(':input').length;
 
  // On ajoute un premier champ directement s'il n'en existe pas déjà un (cas d'un nouvel article par exemple).
  if (index == 0) {
    ajouterElement($container);
  } else {
    // Pour chaque catégorie déjà existante, on ajoute un lien de suppression
    $container.children('div').each(function() {
      ajouterLienSuppression($(this));
    });
  }
 
  // La fonction qui ajoute un formulaire Categorie
  function ajouterElement($container) {
    // Dans le contenu de l'attribut « data-prototype », on remplace :
    // - le texte "__name__label__" qu'il contient par le label du champ
    // - le texte "__name__" qu'il contient par le numéro du champ
    var $prototype = $($container.attr('data-prototype').replace(/__name__label__/g, 'Element n°' + (index+1))
                                                        .replace(/__name__/g, index));
 
    // On ajoute au prototype un lien pour pouvoir supprimer la catégorie
    ajouterLienSuppression($prototype);
 
    // On ajoute le prototype modifié à la fin de la balise <div>
    $container.append($prototype);
 
    // Enfin, on incrémente le compteur pour que le prochain ajout se fasse avec un autre numéro
    index++;
  }
 
  // La fonction qui ajoute un lien de suppression d'une catégorie
  function ajouterLienSuppression($prototype) {
    // Création du lien
    $lienSuppression = $('<a href="#" class="btn btn-danger">Supprimer</a>');
 
    // Ajout du lien
    $prototype.append($lienSuppression);
 
    // Ajout du listener sur le clic du lien
    $lienSuppression.click(function(e) {
      $prototype.remove();
      e.preventDefault(); // évite qu'un # apparaisse dans l'URL
      return false;
    });
  }
});
</script>
{% endblock %}

Si vous avez une piste, je suis preneur ^^ Merci
Cordialement
Mickael