Właśnie po raz pierwszy zaimplementowałem upload obrazka + Doctrine i mam pewne wątpliwości. Chodzi o nakład pracy w kodzie potrzebny do przeprowadzenia tej operacji. Zrobiłem to w oparciu o lifecycle callbacks i musiały powstać 3 pola i 11 metod w obiekcie. Fajnie, że nie trzeba nic robić w kontrolerze i rozumiem, że część tych metod to rzeczy w stylu getWebPath i jak mi się nie podoba to nie muszę koniecznie ich używać, ale mimo wszystko to wydaje mi się trochę dziwne. Strach pomyśleć co się stanie jak będę miał 6 plików przy obiekcie.

A na koniec jeszcze czytam w cookbook, że "The PreUpdate and PostUpdate callbacks are only triggered if there is a change in one of the entity's field that are persisted" więc jak zmienię tylko awatar w profilu usera to on mi się nie zapisze :/ Trochę to załamujące, czy to podejście z cookbook jest naprawdę optymalne?

Przykłady uploadu w dokumentacji formularzu Symfony są fatalne - gwałcą kilka podstawowych zasad "dobrego kodu", które sam framework mocno forsuje. Nigdy nie powinny się tam znaleźć w takiej formie.

1. Utwórz odpowiedni model:
1.1. Obiekt reprezentujący wgrywany plik:

[PHP] pobierz, plaintext 
namepsace ...\Form\Domain;
 
class Image {
  /** 
   * @Assert\NotBlank
   * @Assert\Image(minWidth=50, maxWidth=200, ..., groups={"UserAvatar"})
   * @Assert\Image(minWidth=500, maxWidth=5000, ..., groups={"UserProfile"})
   */
  private $file;
 
  /**
   * @Assert\Type("boolean")
   */ 
  private $delete = false;
 
  // gettery/settery i cokolwiek uznasz za stosowne
}
[PHP] pobierz, plaintext 

1.2. W obiekcie, który posiada ów obraz (powiedzmy, że rozważamy klasyczny przykład użytkownika i jego awataru) najczęściej chcemy przechować jedynie ścieżkę do pliku. Ewentualnie możemy mieć kompletnie osobną tabelę w bazie danych reprezentującą obraz oraz metadane jego dotyczące (wymiary, typ itp.) złączony z inną tabelą relacją jeden-do-jednego. W obu przypadkach mechanizm jest jednak taki sam, więc omówimy jedynie ten pierwszy:

[PHP] pobierz, plaintext 
namespace ...\Entity;
 
class User {
  private $id;
  private $username;
  private $password;
 
  private $avatarPath;
}
[PHP] pobierz, plaintext 

Obiekt domeny nie powinien mieć absolutnie nic wspólnego z uploadem plików!
1.3. Na koniec potrzebujemy osobny obiekt, który złączy to wszystko razem, tj. wgrywany plik oraz interesujący nas obiekt sam w sobie:

[PHP] pobierz, plaintext 
namespace ...\Form\Domain;
 
class ImageUpload {
  /** @Assert\Valid(deep=true) */
  private $object;
 
  /** @Assert\Valid(deep=true) */
  private $image;
 
  private $imagePath;
 
  public function __construct($object, Image $image, $imagePath) {
    ...
  }
}
[PHP] pobierz, plaintext 

$object to obiekt do którego będziemy wgrywać zdjęcie, $image to samo zdjęcie, a $imagePath to ścieżka do właściwości przechowującej ścieżkę do wgrywanego pliku (patrz: komponent PropertyAccess Symfony). Czyli w tym przypadku ścieżką taką będzie "object.avatarPath" (właściwie to pierwszy człon "object." można pominąć). Jeżeli nasz obiekt byłby bardziej złożony i tak możemy bez problemu określić ścieżkę do właściwości "...path", np.: "object.image.path", "object.profile.defaultImage" itp.
1.4. Zarówno obiekt Image jak i ImageUpload mogą być wykorzystywane z dowolnym innym obiektem (User, Profile, Photo, Album itp.)
2. Model jest już przygotowany, pozostało obsłużenie samego uploadu. Właściwie to samym uploadem zajmje się symfony, my musimy jedynie zadbać o to by z wgranego pliku ("image.image") ścieżka została przepisana do interesującej nas właściwości obiektu domeny (tutaj: "object.avatarPath"). To zadanie musi wykonać się po walidacji formularza i przed pobraniem z niego danych w celu dalszej obróbki: FormEvents::POST_BIND.
2.1. Tworzymy sobie usługę, którą rejestrujemy jako listenera dla w/w zdarzenia. Ta usługa, bez problemu może w swoim konstruktorze otrzymać ścieżkę do katalogu dla uploadu czy jakąś usługę typu FilesystemUtility, która wygeneruje unikalną nazwę dla pliku. Mając już takiego listnera możemy spokojnie przerzucić dane:

[PHP] pobierz, plaintext 
public function postBind(FormEvent $event) {
  $data = $event->getData();
 
  if (!$data instanceof ImageUpload) {
    return;
  }
 
  if ($data->getImage()->delete()) {
    // usuwamy plik i aktualizujemy nasz obiekt
    PropertyAccess::getPropertyAccessor()->setValue($data->getObject(), null);
 
    return;
  }
 
  // Tutaj wykonujemy zapis pliku w odpowiednym miejscu, a korzystając z ProeprtyAccess ustawiamy ścieżkę do pliku:
  PropertyAccess::getPropertyAccessor()->setValue($data->getObject(), $data->getImagePath());
}
[PHP] pobierz, plaintext 

3. Obsługa tego w jakimś kontrolerze:

[PHP] pobierz, plaintext 
$user = ...;
 
$data = new ImageUpload($user, new Image(), 'object.avatarPath');
$form = $this->createForm(new SomeFormType(), $data);
 
if (request post) {
  $form->bindRequest($request);
 
  if ($form->isValid()) {
    $formData = $form->getData()->getObject();
 
    // ...
  }
}
[PHP] pobierz, plaintext 

Plusy takiego rozwiązania:
1. Jest uniwersalne, można je wykorzystać z dowolnym obiektem.
2. Wszystko jest ładnie rozdzielone, mamy czysty kod.

Jeżeli chciałbyś dodać obsługę wielu plików, wystarczy że zmodyfikujesz powyższe w taki sposób by ImageUpload posiadał kolekcję obiektów Image oraz tablicę $imagePath.

O rany, Crozin, dzięki. Tamto rozwiązanie z cookbook działa i już miałem je pozostawić, ale wobec takiego wyłożenia tematu przez Ciebie zrobię to od razu na nowo.

Dedukuję, że "SomeFormType()"zawiera nie mapowane pola user,password itd., w którym miejscu mają zostać przekazane dane do atrybutów obiektu User?.

Witam.

Próbuję zrobić uploader wg tego co napisał Crozin, jednak po drodze napotkałem problem. Jestem początkujący w Symfony, stąd też mój problem.

Wydaje mi się, że zgubiłem się na tworzeniu listenera.

Serwis:

[XML] pobierz, plaintext 
<service id="my_user.imageupload" class="My\UserBundle\Form\Domain\ImageUpload">
    <tag name="kernel.event_listener" event="kernel.exception" method="onKernelException"/>
</service>
[XML] pobierz, plaintext 

Listener:

[PHP] pobierz, plaintext 
<?php
 
namespace My\UserBundle\EventListener;
 
class ImageUploadListener
{
 
    public function __construct()
    {
    }
 
    public function postBind(FormEvent $event) {
        $data = $event->getData();
 
        if (!$data instanceof ImageUpload) {
            return;
        }
 
        if ($data->getImage()->delete()) {
            // usuwamy plik i aktualizujemy nasz obiekt
            PropertyAccess::getPropertyAccessor()->setValue($data->getObject(), null);
 
            return;
        }
 
        // Tutaj wykonujemy zapis pliku w odpowiednym miejscu, a korzystając z ProeprtyAccess ustawiamy ścieżkę do pliku:
        PropertyAccess::getPropertyAccessor()->setValue($data->getObject(), $data->getImagePath());
    }
}
[PHP] pobierz, plaintext 

Kontroler:

[PHP] pobierz, plaintext 
$user = $this->container->get('security.context')->getToken()->getUser();
 
        $data = new ImageUpload($user, new Image(), 'object.avatar');
 
        $form = $this->createForm(new ProfileMainFormType(), $data);
 
        $form->handleRequest($request);
 
        if ($form->isValid()) {
 
            var_dump($form->getData()->getObject());
 
            echo 'ok form 1';
        }
[PHP] pobierz, plaintext 

Błąd jaki otrzymuje:


Czy może mnie ktoś nakierować co robię źle?

*********************************************
Edit:

Powoli wraz z dokumentacją Symfony pokonuje trudności napotkane po drodze. Jednak jednego problemu nie mogę pokonać.

Kiedy uploaduje plik, otrzymuje notice


//ProfileAvatarFormType

[PHP] pobierz, plaintext 
<?php
 
namespace My\UserBundle\Form\Type;
 
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\Form\FormEvents;
use Symfony\Component\Form\FormEvent;
use Symfony\Component\PropertyAccess\PropertyAccess;
use My\UserBundle\Form\Domain\ImageUpload;
 
 
class ProfileAvatarFormType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('avatar', 'file', array('mapped' => false))
            ->add('save', 'submit');
 
        $builder->addEventListener(FormEvents::POST_SUBMIT, function(FormEvent $event) {
 
            $data = $event->getData();
 
            if (!$data instanceof ImageUpload) {
                return;
            }
 
            if ($data->getImage()->getDelete()) {
                // usuwamy plik i aktualizujemy nasz obiekt
                PropertyAccess::getPropertyAccessor()->setValue($data->getObject(), null);
 
                return;
            }
 
             //Tutaj wykonujemy zapis pliku w odpowiednym miejscu, a korzystając z ProeprtyAccess ustawiamy ścieżkę do pliku:
            PropertyAccess::getPropertyAccessor()->setValue($data->getObject(), $data->getImagePath());
        });
    }
 
    public function getName()
    {
        return 'my_user_profileavatar';
    }
}
[PHP] pobierz, plaintext 

//Kontroler

[PHP] pobierz, plaintext 
public function indexAction(Request $request)
    {
        $user = $this->container->get('security.context')->getToken()->getUser();
 
        $data = new ImageUpload($user, new Image(), 'avatar');
 
        $form = $this->createForm(new ProfileAvatarFormType(), $data);
 
 
        $form->handleRequest($request);
 
        if ($form->isValid()) {
            $user = $this->container->get('security.context')->getToken()->getUser();
            $data = $form->getData();
            $userManager = $this->container->get('fos_user.user_manager');
            $user->setAvatar($data->getAvatar());
 
            $userManager->updateUser($user);
 
            echo 'ok form';
        }
 
 
        return array('formMain' => $form->createView());
    }
[PHP] pobierz, plaintext 

//ImageUpload

[PHP] pobierz, plaintext 
namespace My\UserBundle\Form\Domain;
 
use Symfony\Component\Validator\Constraints as Assert;
 
class ImageUpload {
    /** @Assert\Valid(deep=true) */
    private $object;
 
    /** @Assert\Valid(deep=true) */
    private $image;
 
    private $imagePath;
 
    public function __construct($object, Image $image, $imagePath) {
        $this->object = $object;
        $this->image = $image;
        $this->imagePath = $imagePath;
    }
 
    /**
     * @param mixed $image
     */
    public function setImage($image)
    {
        $this->image = $image;
    }
 
    /**
     * @return mixed
     */
    public function getImage()
    {
        return $this->image;
    }
 
    /**
     * @param mixed $imagePath
     */
    public function setImagePath($imagePath)
    {
        $this->imagePath = $imagePath;
    }
 
    /**
     * @return mixed
     */
    public function getImagePath()
    {
        return $this->imagePath;
    }
 
    /**
     * @param mixed $object
     */
    public function setObject($object)
    {
        $this->object = $object;
    }
 
    /**
     * @return mixed
     */
    public function getObject()
    {
        return $this->object;
    }
 
}
[PHP] pobierz, plaintext 

//Image

[PHP] pobierz, plaintext 
<?php
 
namespace My\UserBundle\Form\Domain;
 
use Symfony\Component\Validator\Constraints as Assert;
 
class Image {
    /**
     * @Assert\NotBlank
     * @Assert\Image(minWidth=50, groups={"UserAvatar"})
     * @Assert\Image(minWidth=500, maxWidth=5000, groups={"UserProfile"})
     */
    private $file;
 
    /**
     * @Assert\Type("boolean")
     */
    private $delete = false;
 
    /**
     * @param mixed $delete
     */
    public function setDelete($delete)
    {
        $this->delete = $delete;
    }
 
    /**
     * @return mixed
     */
    public function getDelete()
    {
        return $this->delete;
    }
 
    /**
     * @param mixed $file
     */
    public function setFile($file)
    {
        $this->file = $file;
    }
 
    /**
     * @return mixed
     */
    public function getFile()
    {
        return $this->file;
    }
 
}
[PHP] pobierz, plaintext 

W PropertyAccessor metoda setValue posiada 3 parametry, jednak Crozin podał tylko 2 (w poprzedniej wersji symfony były 2 parametry?)

[PHP] pobierz, plaintext 
public function setValue(&$objectOrArray, $propertyPath, $value)
[PHP] pobierz, plaintext 

Wracając do błędu, syfony pokazuje notice gdy przekazuje obiekt w parametrze $objectOrArray, tylko dlaczego?
Kolejna sprawa to jaki powinien być trzeci argument setValue()?

Metoda PropertyAccessor::setValue oczekuje zawsze trzech argumentów, Ty zaś podajesz jej tylko dwa.

Co do błęduPrawdopodobnie chodzi o ułomność samego PHP-ca. Robisz takie coś:

[PHP] pobierz, plaintext 
...->setValue($object->getData(), ...)
[PHP] pobierz, plaintext 

PHP nie potrafi ogarnąć, że chodzi o referencję do obiektu/tablicy zwróconą przez metodę getData(). Musiałbyś to zastąpić czymś takim:

[PHP] pobierz, plaintext 
$data = $object->getData();
...->setValue($data, ...)
[PHP] pobierz, plaintext 

Ok, tylko w tym momencie dostaje error: Ta wartość nie powinna być pusta.

Jeżeli mapped=>true



Z tego wynika, że powinienem mieć wymienione metody w pliku ImageUpload, ale wtedy za każdym użyciem z inną zmienną musiałbym tworzyć kolejne metody. Tak ma robić, czy coś mam źle?

Niezłe farmazony. Zapomnij o tych absolutnie zbędnych komplikacjach.

W encji ustaw właściwości dla pliku (niemapowany) oraz nazwy pliku (mapowany). W setterze pliku ustawiaj wygenerowaną nazwę pliku. Następnie po sprawdzeniu poprawności formularza przeprowadź upload do katalogu sprecyzowanego choćby w parametrach Sf2. Czytelne, proste, wygodne, nie naruszające dobrych zasad.

Pozdrowienia.

@pyro

Czyli praktycznie tak jak jest napisane w CookBook w Basic Setup?

Nie. Zgadzam się z @Crozin, że podane tam przykłady są nienajlepsze, chociaż sam wybrał drogę umycia wieżowca szczoteczką do zębów. Przeczytaj jeszcze raz co napisałem i porównaj z Cookbookiem.

Czyli w encji:

[PHP] pobierz, plaintext 
/**
     * @ORM\Column(type="string", length=255, nullable=true)
     */
    protected $avatar;
 
    /**
     * @Assert\File(maxSize="6000000")
     * @Assert\NotBlank
     * @Assert\Image(minWidth=50)
     * @Assert\Image(minWidth=50)
     */
    protected $file;
 
    /**
     * Sets file.
     *
     * @param UploadedFile $file
     */
    public function setFile(UploadedFile $file = null)
    {
        $this->file = $file;
        $ext = $this->file->guessExtension();
        $this->avatar = 'av-'.$this->getId().'.'.$ext;
    }
[PHP] pobierz, plaintext 

A w kontrolerze

[PHP] pobierz, plaintext 
if ($form->isValid()) {
            $data = $form->getData();
 
            $data->getFile()->move(
                $this->getUploadRootDir(),
                $user->getAvatar()
            );
 
            $userManager = $this->container->get('fos_user.user_manager');
 
            $userManager->updateUser($user);
        }
[PHP] pobierz, plaintext 

Dobrze zrozumiałem?

Coś w ten deseń, tak.

// EDIT



Te 3 wymuszenia można połączyć w jedno.



$file to cały czas $file

Ok. Dziękuję bardzo za pomoc

@Crea17: Umknął mi gdzieś ten wątek.

Powinieneś mieć następujące typy dla formularza:
1. ImageType (pracujący na ...\Domain\Image) z definicjami dla właściwości "file" (typ "file") oraz "delete" (typ "boolean").
2. ProfileAvatarFormType (pracyjący na ...\Domain\ImageUpload) z definicjami dla właściwości "object" (typ UserType) oraz "image" (typ ImageType).
3. PropertyAccess::setValue() oczekuje zawsze 3 argumentów, których Ty nie zawsze podajesz.

@pyro: Gdzie Ty widzisz komplikacje w utrzymywaniu kodu w formie niezależnej od reszty, którą da się wielokrotnie wykorzystywać.