[2.x] Methode crud et le multi upload

Methode crud et le multi upload

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:

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:

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:

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()
        ;
    }
}

Personnes ne sait faire du multipload sur symfony 2.6 ?
J'ai besoin de liens vers des solutions qui fonctionnent ou des conseils pour savoirs si je dois m orienter vers un bundle ( lequel), les collections ( comment) ou juste un ajout de code pour que cela fonctionne .
merci d avance

Personnellement je fais du faux multi upload d'image avec symfony. Grosso modo le plugin Jquery permet de sélectionner plusieurs fichiers, et quand je valide, il envoie les fichier un part un. Du coup au niveau de la logique ça s'apparente à un upload simple.

Côté front j'utilise ce plugin js : https://github.com/blueimp/jQuery-File-Upload

Côté back j'ai une entité média qui est déclarée comme uploadable (via le bundle gedmo : https://github.com/Atlantic18/DoctrineExtensions ). Tu as toute la documentation là : https://github.com/Atlantic18/Doctri.../uploadable.md

Bonjur.
je suis moi aussi à la recherche d'une solution multiupload pour SF 2.6.
je pense peut être utiliser un bundle tout fait.si quelqu'un en aurai un à me conseiller?

Merci

Bonjour,

Pour l'upload: y'a un bundle quui s'appelle https://github.com/dustin10/VichUploaderBundle
qui permet de simplifier l'upload des fichiers avec des annotations cotés entité.

per contre pour le multi upload tu dois créer un formulaire en temps que type qui permet d'uploader un seule fichier (Media)
après tu fait appelle à ce type en temps que collection dans ton formulaire de "Realisation"

ça peut ressembler à ça (medias est le nom de l'attribut coté Realisation):
Code:

1 2 3 4 5 6 7 ->add('medias', 'collection', [ 'type' => 'my_media_type',//Tu dois déclarer ton type en temps service sf2 tagué ou bien directement tu l'instancie ici genre new MediaType() 'allow_add' => true, 'allow_delete' => true, 'by_reference' => false, 'cascade_validation' => true ]);
Pour voir comment imbriquer des formulaires dans symfony2 sur ce lien

Après y'a du boulo aussi coté enregistrement, et des cas particuliers à gérer en edition

mais déjà faut mettre en place ton form avant

Sinon pour te simplifier la vie regarde aussi

ce bundle

https://github.com/punkave/symfony2-file-uploader-bundle

hope this help

Citation:
Envoyé par phpiste
Bonjour,

Pour l'upload: y'a un bundle quui s'appelle https://github.com/dustin10/VichUploaderBundle
qui permet de simplifier l'upload des fichiers avec des annotations cotés entité.

per contre pour le multi upload tu dois créer un formulaire en temps que type qui permet d'uploader un seule fichier (Media)
après tu fait appelle à ce type en temps que collection dans ton formulaire de "Realisation"

ça peut ressembler à ça (medias est le nom de l'attribut coté Realisation):
Code:

1 2 3 4 5 6 7 ->add('medias', 'collection', [ 'type' => 'my_media_type',//Tu dois déclarer ton type en temps service sf2 tagué ou bien directement tu l'instancie ici genre new MediaType() 'allow_add' => true, 'allow_delete' => true, 'by_reference' => false, 'cascade_validation' => true ]);
Pour voir comment imbriquer des formulaires dans symfony2 sur ce lien

Après y'a du boulo aussi coté enregistrement, et des cas particuliers à gérer en edition

mais déjà faut mettre en place ton form avant

Sinon pour te simplifier la vie regarde aussi

ce bundle

https://github.com/punkave/symfony2-file-uploader-bundle

hope this help
µMerci pour l'aide, je vais regarder tout ça.
pour l'enregistrement, je vais partir sur du serialize, je voi pas commet faire autrement !