Bonjour,

Je voudrais pouvoir uploader plusieurs images pour une entitée. Une réalisations afficherai plusieurs images. Je pense qu'il faut une relation many to one vers la table réalisation et une table media par exemple pour commencé. Aprés ...
J'ai réalisé avec la méthode crud des formulaires d'édition , ajout etc ...d'une entité nommée " réalisations " et j'ai utilisé les différentes méthodes que j'ai pu trouver pour uploader une image et cela fonctionne. Par contre impossible de comprendre comme faire du multi-upload avec les fichiers générer par le crud . Les bundles que j'ai pu trouver , je n'ai pas réussi à la faire fonctionner ; Soit je n'ai rien compris au niveau des collections .
Est ce que quelqu'un à déja utilisée une méthode qui fonctionne avec les méthode crud
Merci d'avance

mon entité Réalisations :

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
 
<?php
 
namespace portfolio\laurentBundle\Entity;
 
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\validator\Constraints as Assert;
/**
 * Realisations
 *
 * @ORM\Table()
 * @ORM\Entity(repositoryClass="portfolio\laurentBundle\Entity\RealisationsRepository")
 * @ORM\HasLifecycleCallbacks
 */
class Realisations
{
    /**
     * @var integer
     *
     * @ORM\Column(name="id", type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    private $id;
 
     // Gestion du champ file du formulaire //
 
    /**
     * @var \DateTime
     * 
     * @ORM\COlumn(name="updated_at",type="datetime", nullable=true) 
     */
    private $updateAt;
 
    /**
     * @ORM\PostLoad()
     */
    public function postLoad()
    {
        $this->updateAt = new \DateTime();
    }
 
     /**
     * @ORM\Column(type="string",length=255) 
     * @Assert\NotBlank
     */
    public $divers;
 
    /**
     * @ORM\Column(type="string",length=255, nullable=true) 
     */
    public $path;
 
    public $file;
 
    // route pour uploye l'image //
 
    public function getUploadRootDir()
    {
        return __dir__.'/../../../../web/uploads';
    }
 
    // chemin total du fichier //
    public function getAbsolutePath()
    {
        return null === $this->path ? null : $this->getUploadRootDir().'/'.$this->path;
    }
 
    public function getAssetPath()
    {
        return 'uploads/'.$this->path;
    }
 
    /**
     * @ORM\Prepersist()
     * @ORM\Preupdate() 
     */
    public function preUpload()
    {
        $this->tempFile = $this->getAbsolutePath();
        $this->oldFile = $this->getPath();
        $this->updateAt = new \DateTime();
 
        if (null !== $this->file) 
            $this->path = sha1(uniqid(mt_rand(),true)).'.'.$this->file->guessExtension();
    }
 
    /**
     * @ORM\PostPersist()
     * @ORM\PostUpdate() 
     */
    public function upload()
    {
        if (null !== $this->file) {
            $this->file->move($this->getUploadRootDir(),$this->path);
            unset($this->file);
 
            if ($this->oldFile != null) unlink($this->tempFile);
        }
    }
 
    /**
     * @ORM\PreRemove() 
     */
    public function preRemoveUpload()
    {
        $this->tempFile = $this->getAbsolutePath();
    }
 
    /**
     * @ORM\PostRemove() 
     */
    public function removeUpload()
    {
        if (file_exists($this->tempFile)) unlink($this->tempFile);
    }
 
    // fin champs file du formulaire //
 
    /**
     * @var string
     *
     * @ORM\Column(name="nom", type="string", length=255)
     */
 
    private $nom;
 
     /**
     * @ORM\ManyToOne(targetEntity="portfolio\laurentBundle\Entity\Categories", cascade={"persist","remove"})
     * @ORM\JoinColumn(nullable=false)
     */
 
        private $categorie;
 
    /**
     * @var string
     *
     * @ORM\Column(name="description", type="text")
     */
    private $description;
 
 
    /**
     * Get id
     *
     * @return integer 
     */
    public function getId()
    {
        return $this->id;
    }
    public function getPath()
    {
        return $this->path;
    }
 
    public function getDivers()
    {
        return $this->divers; 
    }
 
    /**
     * Set nom
     *
     * @param string $nom
     * @return Realisations
     */
 
 
    public function setNom($nom)
    {
        $this->nom = $nom;
 
        return $this;
    }
 
    /**
     * Get nom
     *
     * @return string 
     */
    public function getNom()
    {
        return $this->nom;
    }
 
 
    /**
     * Set description
     *
     * @param string $description
     * @return Realisations
     */
    public function setDescription($description)
    {
        $this->description = $description;
 
        return $this;
    }
 
    /**
     * Get description
     *
     * @return string 
     */
    public function getDescription()
    {
        return $this->description;
    }
 
    /**
     * Set categorie
     *
     * @param \portfolio\laurentBundle\Entity\Categories $categorie
     * @return Realisations
     */
    public function setCategorie(\portfolio\laurentBundle\Entity\Categories $categorie)
    {
        $this->categorie = $categorie;
 
        return $this;
    }
 
    /**
     * Get categorie
     *
     * @return \portfolio\laurentBundle\Entity\Categories 
     */
    public function getCategorie()
    {
        return $this->categorie;
    }
}
mon formulaire RealisationsType :

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
 
<?php
 
namespace portfolio\laurentBundle\Form;
 
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolverInterface;
 
class RealisationsType extends AbstractType
{
    /**
     * @param FormBuilderInterface $builder
     * @param array $options
     */
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('nom','textarea', array('attr'=>array('class'=> 'form-control')))
            ->add('file','file' ,array(
                'required'=>false,
                'attr'=>array('class'=> 'file',
                    )))
            ->add('file2','file' ,array(
                'required'=>false,
                'attr'=>array('class'=> 'file',
                    ))) 
            ->add('file3','file' ,array(
                'required'=>false,
                'attr'=>array('class'=> 'file',
                    ))) 
            ->add('divers','textarea', array('attr'=>array('class'=> 'form-control')))
            ->add('description','textarea', array('attr'=>array('class'=> 'form-control ckeditor')))
            ->add('categorie','entity', array('label'=>'Catégorie',
                                    'class' => 'portfolio\laurentBundle\Entity\Categories',
                'attr'=>array('class'=> 'form-control')))
        ;
    }
 
    /**
     * @param OptionsResolverInterface $resolver
     */
    public function setDefaultOptions(OptionsResolverInterface $resolver)
    {
        $resolver->setDefaults(array(
            'data_class' => 'portfolio\laurentBundle\Entity\Realisations'
        ));
    }
 
    /**
     * @return string
     */
    public function getName()
    {
        return 'portfolio_laurentbundle_realisations';
    }
}
Ensuite mon controller générer par les crud :

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
 
<?php
 
namespace portfolio\laurentBundle\Controller;
 
use Symfony\Component\HttpFoundation\Request;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
 
use portfolio\laurentBundle\Entity\Realisations;
use portfolio\laurentBundle\Form\RealisationsType;
 
/**
 * Realisations controller.
 *
 */
class RealisationsController extends Controller
{
 
    /**
     * Lists all Realisations entities.
     *
     */
    public function indexAction()
    {
        $em = $this->getDoctrine()->getManager();
 
        $entities = $em->getRepository('laurentBundle:Realisations')->findAll();
 
        return $this->render('laurentBundle:Realisations:index.html.twig', array(
            'entities' => $entities,
        ));
    }
    /**
     * Creates a new Realisations entity.
     *
     */
    public function createAction(Request $request)
    {
        $entity = new Realisations();
        $form = $this->createCreateForm($entity);
        $form->handleRequest($request);
 
        if ($form->isValid()) {
            $em = $this->getDoctrine()->getManager();
            $em->persist($entity);
            $em->flush();
 
            return $this->redirect($this->generateUrl('adminRealisations_show', array('id' => $entity->getId())));
        }
 
        return $this->render('laurentBundle:Realisations:new.html.twig', array(
            'entity' => $entity,
            'form'   => $form->createView(),
        ));
    }
 
    /**
     * Creates a form to create a Realisations entity.
     *
     * @param Realisations $entity The entity
     *
     * @return \Symfony\Component\Form\Form The form
     */
    private function createCreateForm(Realisations $entity)
    {
        $form = $this->createForm(new RealisationsType(), $entity);
 
        $form->add('submit', 'submit',  array('label' => 'Créer', 'attr'=>array('class'=>'btn btn-default')));
 
        return $form;
    }
 
    /**
     * Displays a form to create a new Realisations entity.
     *
     */
    public function newAction()
    {
        $entity = new Realisations();
        $form   = $this->createCreateForm($entity);
 
        return $this->render('laurentBundle:Realisations:new.html.twig', array(
            'entity' => $entity,
            'form'   => $form->createView(),
        ));
    }
 
    /**
     * Finds and displays a Realisations entity.
     *
     */
    public function showAction($id)
    {
        $em = $this->getDoctrine()->getManager();
 
        $entity = $em->getRepository('laurentBundle:Realisations')->find($id);
 
        if (!$entity) {
            throw $this->createNotFoundException('Unable to find Realisations entity.');
        }
 
        $deleteForm = $this->createDeleteForm($id);
 
        return $this->render('laurentBundle:Realisations:show.html.twig', array(
            'entity'      => $entity,
            'delete_form' => $deleteForm->createView(),
        ));
    }
 
    /**
     * Displays a form to edit an existing Realisations entity.
     *
     */
    public function editAction($id)
    {
        $em = $this->getDoctrine()->getManager();
 
        $entity = $em->getRepository('laurentBundle:Realisations')->find($id);
 
        if (!$entity) {
            throw $this->createNotFoundException('Unable to find Realisations entity.');
        }
 
        $editForm = $this->createEditForm($entity);
        $deleteForm = $this->createDeleteForm($id);
 
        return $this->render('laurentBundle:Realisations:edit.html.twig', array(
            'entity'      => $entity,
            'edit_form'   => $editForm->createView(),
            'delete_form' => $deleteForm->createView(),
        ));
    }
 
    /**
    * Creates a form to edit a Realisations entity.
    *
    * @param Realisations $entity The entity
    *
    * @return \Symfony\Component\Form\Form The form
    */
    private function createEditForm(Realisations $entity)
    {
        $form = $this->createForm(new RealisationsType(), $entity);
 
        $form->add('submit', 'submit',  array('label' => 'Modifier', 'attr'=>array('class'=>'btn btn-default')));
 
        return $form;
    }
    /**
     * Edits an existing Realisations entity.
     *
     */
    public function updateAction(Request $request, $id)
    {
        $em = $this->getDoctrine()->getManager();
 
        $entity = $em->getRepository('laurentBundle:Realisations')->find($id);
 
        if (!$entity) {
            throw $this->createNotFoundException('Unable to find Realisations entity.');
        }
 
        $deleteForm = $this->createDeleteForm($id);
        $editForm = $this->createEditForm($entity);
        $editForm->handleRequest($request);
 
        if ($editForm->isValid()) {
            $em->flush();
 
            return $this->redirect($this->generateUrl('adminRealisations_edit', array('id' => $id)));
        }
 
        return $this->render('laurentBundle:Realisations:edit.html.twig', array(
            'entity'      => $entity,
            'edit_form'   => $editForm->createView(),
            'delete_form' => $deleteForm->createView(),
        ));
    }
    /**
     * Deletes a Realisations entity.
     *
     */
    public function deleteAction(Request $request, $id)
    {
        $form = $this->createDeleteForm($id);
        $form->handleRequest($request);
 
        if ($form->isValid()) {
            $em = $this->getDoctrine()->getManager();
            $entity = $em->getRepository('laurentBundle:Realisations')->find($id);
 
            if (!$entity) {
                throw $this->createNotFoundException('Unable to find Realisations entity.');
            }
 
            $em->remove($entity);
            $em->flush();
        }
 
        return $this->redirect($this->generateUrl('adminRealisations'));
    }
 
    /**
     * Creates a form to delete a Realisations entity by id.
     *
     * @param mixed $id The entity id
     *
     * @return \Symfony\Component\Form\Form The form
     */
    private function createDeleteForm($id)
    {
        return $this->createFormBuilder()
            ->setAction($this->generateUrl('adminRealisations_delete', array('id' => $id)))
            ->setMethod('DELETE')  //ATTRIBUER UNE CHAMPS LABEL ET UNE CLASS AU FORMULAIRE
            ->add('submit','submit', array('label' => 'Supprimer', 'attr'=>array('class'=>'btn btn-default')))
            ->getForm()
        ;
    }
}