One to Many enregistrement null

**mickael5000** · 06/02/2014, 10h05

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 :

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
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 :

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
<?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 :

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
<?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 :

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
<?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 :

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
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 :

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
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 :

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
{% 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

**antoine2210** · 06/02/2014, 17h12

Bonjour,
Première chose qui me tape à l'oeil, dans ton entité ElementFacture :

Code :

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

1
2
3
4
5
/**
   * @ORM\ManyToOne(targetEntity="Autofacture\FactureBundle\Entity\Facture",inversedBy="elements_facture")
   * @ORM\JoinColumn(name="facture", referencedColumnName="id", nullable=false)
   */
	protected $facture;

Il faut que tu ajoutes nullable=false, si tu veux rester cohérent. je me trompe ?

One to Many enregistrement null

Symfony PHP

Discussions similaires

Partager

Partager