Příklad použítí Kdyby\DoctrineForms

Předně mysli na to že je to vývojová verze.

• Umí to mapovat entity na formuláře a naopak
• Mělo by to umět validovat entity
• Mělo by to umět buildit formuláře

Work in progress je generování js validací ze symfony validací.

Mělo by stačit do formuláře přidat traitu EntityForm a zavolat metodu bindEntity

Pokud najdeš chybu tak ji prosím reportuj na github issues, díky!

Viz testy Tomáši

Udělal bych si něco takového

namespace MyApp\UI;

class Form extends \Nette\Application\UI\Form
{
	use \Kdyby\DoctrineForms\EntityForm;
}

interface IBaseFormFactory
{
	/** @return \MyApp\UI\Form */
	function create($class = 'MyApp\UI\Form');
}

class Control extends \Nette\Application\UI\BaseControl
{
	use \Kdyby\Autowired\AutowireComponentFactories;
}

konfigurace:

services:
	formFactory:
		class: MyApp\UI\Form(%class%)
		create: "$this->createInstance(?)"(%class%)
		implement: MyApp\UI\IBaseFormFactory
		parameters: [class = "MyApp\UI\Form"]
		inject: yes

použití:

class SisterControl extends MyApp\UI\Control
{
    private $sister;

    public function setSister(App\Sister $sister)
    {
        $this->sister = $sister;
    }

    protected function createComponentForm(MyApp\UI\IBaseFormFactory $factory)
    {
        if (!$this->sister) {
            throw new \LogicException('Missing call ' . get_called_class()  . '::setSister($entity)');
        }

        $form = $factory->create();
        $form->bindEntity($this->sister);
        $form->add('name');

        $form->addSubmit('send', 'Uložit');
        $form->onSuccess[] = $this->processForm;

        return $form;
    }


    public function processForm($form)
    {
        $this->sisters->save($form->entity);
        $this->presenter->redirect('default');
    }

}

interface ISisterControlFactory
{
	/** @return SisterControl */
	function create();
}

Použití komponenty

protected function createComponentSister(ISisterControlFactory $factory)
{
	$control = $factory->create();
	$control->setSister(new App\Sister);

	return $control;
}

Nemáš vyžadovat presenter ale Application ze kterého si vytáhneš instanci aktivního presenteru.

Nehledě na to že presenter se ti sám zpřístupní po připojení do presenteru :)

@Filip Procházka: Nemyslím to nijak zle, ale Tebou uvedené konstrukce mi prostě přijdou hrozně složité (hlavně pak ta konstrukce v neonu…). Jako ukázka možností Nette DI a komponent je to super :), ale pro použití v praxi bych asi osobně volil něco trochu jednoduššího.

Plus to dědění Form… Proč to neřešit jednoduše cca takhle?

class SampleFormFactory
{

	public function createForm($entity = null)
	{
		$form = new Form;
		$form->addText('name', 'Name');

		if ($entity !== null) {
			$form->setDefaults((array) $entity); // tohle je jenom takové zjednoduššení…
		}

		return $form;
	}

}

class SampleControl extends Control
{

	private $sampleFormFactory;

	private $entity;


	public function __construct(SampleFormFactory $sampleFormFactory)
	{
		$this->sampleFormFactory = $sampleFormFactory;
	}

	public function setEntity($entity)
	{
		$this->entity = $entity;
	}

	public function render()
	{
		echo $this['form'];
	}

	protected function createComponentForm()
	{
		$form = $this->sampleFormFactory->createForm($this->entity);
		$form->onSuccess[] = function (Form $form) {
			$this->processForm($form);
		};
		return $form;
	}

	private function processForm(Form $form)
	{
		// form processing
	}

}

interface ISampleControlFactory
{

	/**
	 * @return SampleControl
	 */
	function create();

}

services:
	- SampleFormFactory
	- ISampleControlFactory

Nějaké fiktivní použití v presenteru:

class DefaultPresenter extends Presenter
{

	private $entity;

	private $sampleControlFactory;


	public function __construct(ISampleControlFactory $sampleControlFactory)
	{
		$this->sampleControlFactory = $sampleControlFactory;
	}

	public function startup()
	{
		parent::startup();
		$this->entity = $entity = new stdClass;
		$entity->name = 'This is my name';
	}

	protected function createComponentSampleControl()
	{
		$control = $this->sampleControlFactory->create();
		$control->setEntity($this->entity);

		return $control;
	}

}

Výsledek dost podobný, kód jednoduší, přímočařejší.

Editoval Tharos (25. 3. 2014 23:04)

@akadlec: Za předpokladu, že bych v tom presenteru použil AutowireComponentFactories, tak samozřejmě ano. :) Pozor na to, že tenhle auto-wiring není vestavěnou fičurou Nette, ale je z Kdyby. A já jsem tu ukázku chtěl mít co nejútlejší…

To je ale pořád vedlejší. Hlavní pointou mého zamyšlení je, zda přece jenom není namísto poděděného formuláře s automaticky vygenerovanou továrnou a trochu hacky definicí v neonu výhodnější formulář nedědit a tu továrnu si třeba napsat ručně.

Editoval Tharos (26. 3. 2014 10:00)

@akadlec: Stejně bych ale v tomhle případě to dědění nahradil kompozicí. :)

Mít třídu reprezentující konkrétní formulář dává velký smysl. Kvůli type hintům, navazování událostí… Prostě je to nějaká konkrétní třída s jasným API. Taková třída ale nemusí dědit z Form. Já bych za tímhle účelem klidně použil celou tu svou SampleControl.

Ta Tvá metoda createForm mi přijde trochu zvláštní. :) Je veřejná, a tak by mě zajímalo, co vrací a jak se vůbec používá?

@Tharos Tleskám! Že by samostatné (na úrovni logiky aplikace: formulář na články, formulář na…) formuláře neměly dědit od Form tvrdím už nějakou dobu :).

@akadlec Právě protože se manuální renderování formu tak často hodí, je dědění od UI\Control nejlepší, protože ta už má k dispozici metodu render(), ve které lze snadno přistoupit k šabloně. Nemá smysl logiku ohledně šablony přenášet do jakéhokoliv potomka UI\Form.

@jenicek Přiznám se, že nedokážu kvalifikovaně odpovědět. Buď je formulář zpracován Controlem, nebo se třeba na Control zavěsí jiná (zpracovatelská :) ) služba. Ve formuláři V presenteru spíš ne, tam se snažím mít jen flash messages, redirecty apod., které zavěsím do custom událostí toho Controlu (onArticleSaved apod.).

Editoval vojtech.dobes (26. 3. 2014 11:48)

@vojtech.dobes: Ok, hmm custom události pěkné.

Tzn nějak takto?

private function processForm(Form $form)
{
	try {
		 // … ukládání
		$this->onArticleSaved($entity);
	} catch(MyApp\Exception $e){
		$this->onArticleError($entity);
	}
}

Nebo přez Kdyby\Events?

Editoval jenicek (26. 3. 2014 11:31)

@jenicek Rozdělil bych potencionální „úspěšné uložení článku“ na reakci Controlu a reakci modelu. Reakcí modelu může být třeba invalidace nějaké cache nebo odeslání emailu nebo něco podobného. Na to se výborně hodí globální eventový systém, jakým jsou Kdyby\Events, které by v tomto konkrétním případě měly reagovat na nějakou modelovou událost (ne událost Controlu).

Reakce Controlu by měla být čistě věcí UI (koneckonců viz namespace této třídy :) – UI\Control). Tudíž její onArticleSaved by mělo vést k těm flash messages, redirectům apod., na které obvykle Kdyby\Events nejsou nijak potřeba, presenter má instanci Controlu v továrničce k dispozici, a může se do jejích eventů zavěsit přímým voláním.

Pocitate v teto diskusi s traitou v Kdyby\DoctrineForms? Tam formular vyzaduje jiny pristup nez obvykle.

Pokud ano, ktery ze vsech zminenych kodu jste vyzkouseli a je fcni? Diky.

vojtech.dobes: Ještě se v tom plácám, tzn. Form komponenty nedědit na hodně stejné akce formulářovích komponent využít traity?

@Filip Procházka: Super, díky za reakci. :)

protože v 99% aplikací si chci do formuláře přidat vlastní typy inputů a ikdybych je přidával jako extension method tak stejně si chci nad formulář napsat annotaci že tam ta metoda je

Vlastní typ inputů považuji za legitimní důvod k podědění formuláře. Zároveň to považuji za jeden z mála legitimních důvodů. :)

V případě, že bych vlastní typy inputů hojně potřeboval a nestačily mi extension metody, asi bych také sáhl po dědičnosti. Konfiguraci vstupů bych ale už ponechal na oddělené factory. Tady se Ti musím omluvit, protože jsem přehlédl, že Ty to tak vlastně děláš… :) Přehlédl jsem, kde máš to add a addSubmit.

Metoda createForm ve formuláři tak, jak ji sem psal @akadlec, mi ale přijde trochu nešťastná.

Takže suma sumárum se myslím shodujeme. :)

TL;DR:

• BaseForm je fajn věc, ve většině aplikací je potřeba, nikdo zatím nevymyslel nic lepšího (extension metody nestačí)
• udělat si na BaseForm generovanou továrničku je taky fajn věc, pokud má nějaké závislosti
• BaseForm pokud možno dále nedědit ale upřednostňovat obalení komponentou

Jo, takhle to zní rozumně. :)

@akadlec: A ty processory formulářů budeš nastavovat, kde v presenteru nebo v té komponentě?

Editoval jenicek (28. 3. 2014 17:54)

akadlec: Takhle nějak?

Zajímá mě zda ty processy definovat přímo v presenteru nebo až v komponentě či jinde?

function createComponentEditForm(){
	$form = $this->exampleEditFormFactory->create();
	$form->onSuccess[] = $this->proccess();
	return $control;
}

a custom event v Presenteru?

function createComponentItemControl(){
	$control = $this->exampleItemControl->create();
	$control->onSave[] = $this->processSave();
	$control->onError[] = $this->processError();
	return $control;
}

Pokud bych chtěl mohl bych vše řešit na urovni presenteru, ale zatím nevím o nejlepší technice, v komponěntě by bylo dobré řešit flash zprávičky a na úrovni presenteru přímo techniku jak co provést? Komponenta by pak nemusela obsahovat servisu, ale samozřejmě ji pomocí DIC mít může. tak nevím.

Editoval jenicek (31. 3. 2014 13:27)

@akadlec: Práávě, Getr je jednodušší a co mít nějaký onBeforeProccess a onAfterProcces a ty mít navěšené na v těch callbackách v komponentě a tudíž je moci navěšovat z venku na komponentu bez toho že bych přistupoval přimo k formu, nebo jiné vnitřní lumpárně.

V komponentě?

protected function createComponentEditForm(){
    $form = $this->exampleEditFormFactory->create();
    $form["save"]->onSave[] = function($button) {
		$this->proccessSave($button->getForm());
 	};
    return $control;
}

function getEditForm()
{
	// no nevim zda je potřeba?
	return $this["editForm"];
}

function proccessSave($form){
	// $this->startProccess($form);
	try {
			$this->beforeProccess($form);
			// process
			$this->afterProccess($form);
	} catch(MyApp\Exception $e){
		$this->errorProccess($form);
	}
	// $this->endProccess($form);

}

V presenteru:

	protected function createComponentEditContol()
	{
		$control = $this->editControlFactory->create();
		$control->beforeProccess[] = $this->myBeforeProcess;
		...
		return $control;
	}

Vlastně o tom psal vojtech.dobes.

Editoval jenicek (31. 3. 2014 17:47)

A minimalisté

$this['editFormControl-form']

:)

Ještě bych navázal na bindEntity()

Při připojení entity v továrničce na formulář nastane chyba: Component '' is not attached to ‚Nette\Application\UI\Presenter‘., když se Kdyby\DoctrineForms\EntityForm pokusí zavolat getServiceLocator(). Viz:

protected function createComponentForm(IEntityFormFactory $factory)
{
	$form = $factory->create();
	$form->addText('name', 'Název');
	$form->addMultiSelect('authors', 'Autoři')
		->setOption(IComponentMapper::ITEMS_TITLE, 'name');
	$form->bindEntity($this->project);
	return $form;
}

Lze nějak vytvořit komponentu form až po připojení k presenteru?

Zatím to obcházím takto:

protected function attached($presenter)
{
	parent::attached($presenter);
	$this['form']->bindEntity($this->project);
}

Díky

Editoval Tomáš Votruba (1. 4. 2014 12:35)

Filipe, můžu se zeptat, jak funguje toMany? Z testů jsem to nepochopil.

Tento kód se mi nikde neprojevil:

$form->toMany('values', function ($parameter) {
	$parameter->addText('value');
});

Chtěl bych mít formulář pro úpravu parametru a zároveň u něj možnost přidávat jeho hodnoty (např. parametr velikost trika, hodnoty XL, L…).

Díky.

Ahoj, snažím se rozchodit DoctrineForms a trochu narážím na problém s připojením entity ke komponentě. Zkoušel jsem dvěma způsoby:

1. bind v metodě init – zde mi to správně přiřadí defaultní hodnoty do formuláře z entity, ale při uložení je v getValues i getEntity výchozí stav.
2. zkoušel jsem se inspirovat zde a binduji v metodě attached. Entitu mi to k formuláři připojí, ale nevyplní mi to defaultní hodnoty do formuláře.

• Komponenty vytvářím trochu nestandarndně (možná to bude tím). Třída MyFormControl dědí od \Nette\Application\UI\Control pak zde mám nějaké metody pro obecnou práci formulářů v metodě createComponent vytvářím formulář a volám metodu init potomka, která jen doplní formulářové prvky.

Nebyla by prosím rada? Díky.

class UserForm extends MyFormControl{

   /** @var  \App\Uzivatel  */
    private $us;

    public function __construct($parent, $name, $user) {
        $this->us = $user;
        parent::__construct($parent, $name);
    }


    public function init(EntityForm $form) {
        $form->addText("jmeno", "Jméno");
        $form->addText("prijmeni", "Příjmení");
        $form->addText("email", "E-mail");
        $form->addSubmit("register", "Uložit");
       // $form->bindEntity($this->us);
    }

	protected function attached($obj)
	{
		parent::attached($obj);
		if (!$obj instanceof \Nette\Application\UI\Presenter) {return;}
		$form = $this['form']->bindEntity($this->us);
 	}

}

V presenteru to vypadá takto:

public function createComponentUserform($name) {
     new \UserForm($this, $name,$this->user);

}

A případně ta MyFormControl:

abstract class MyFormControl extends \Nette\Application\UI\Control{

    use Kdyby\DoctrineForms\EntityForm;

     protected function createComponentForm($name) {
        $form = new EntityForm($this,$name);
        $this->init($form);
        $form->onSuccess[] = $this->succes;
        $form->onValidate[] = $this->validate;
        return $form;
     }

    public function __construct($parent,$name) {
      parent::__construct($parent, $name);
    }

// .... další metody....
    public abstract function succes(EntityForm $form);
    public abstract function validate(EntityForm $form);
    public abstract function init(EntityForm $form);

}

Já binduju entitu na konci createComponentForm() a aby to nenadávalo kvůli chybějícím závislostem, používám namísto new EntityForm() generovanou továrničku se zapnutými injecty:

interface IEntityFormFactory
{
	/** @return EntityForm */
	function create();
}

- {implement: IEntityFormFactory, inject: on}

@chap Ještě jsem neměl čas vystopovat, kde to přesně vzniká, ale zdá se, že se ta entita binduje až potom, co se naplní data z requestu do formuláře, takže se odeslaná vždycky přepíšou tou entitou. Takhle mám zajištěné, že se entita binduje ještě před připojením formuláře do komponenty (protože to se dělá až po zavolání createComponent* metody), a tudíž před naplněním formuláře daty.

zakomentováním místa kde se vyjimka vyhazuje ;)