Předání parametrů do továrny formuláře

kamil_v napsal(a):

app/forms je fajn místo, protože ne vždy dopředu víš, kde v aplikaci bude form použit, takže je fajn mít je v nezávislém „úložišti“.

Závislosti adhoc si vyžádáš z DI, jiné parametry (různá ID apod.) si předávám normálně setterem.

Co to znamená normálně setterem? :) jakože si udělám nějakou set metodu nebo v parametrech create funkce nebo přes __set() si budu nastavovat třídní atribut. nevím co tím myslíš?

Editoval ondrapech (30. 7. 2019 11:02)

jiri.pudil napsal(a):

imo je to lepší vyžadovat v konstruktoru a předávat v metodě create(). Třída OrderForm pak nejde vytvořit „špatně“, tj. bez produktu. Nette parametry v konstruktoru podle názvu napáruje s metodou create a zbytek automaticky dohledá v DI kontejneru:

class OrderForm extends Nette\Application\UI\Control
{
	private $product;
	private $userContext;

	public function __construct(
		Product $product, // parametr předaný v create()
		Nette\Security\User $userContext // služba z kontejneru
	)
	{
		$this->product = $product;
		$this->userContext = $userContext;
	}
}

interface OrderFormFactory
{
	public function create(Product $product): OrderForm;
}

class OrderPresenter extends Nette\Application\UI\Presenter
{
	protected function createComponentOrderForm(): OrderForm
	{
		return $this->orderFormFactory->create($this->product);
	}
}

Kluci, díky za rady. Ještě mám jeden dotaz. používáte tu oba interface. Je potřeba? k čemu je to dobré? a ten patří ve struktuře projektu tam pokud bych měl OrderFormFactory v App\Forms tak interface kam?

Ja som este zvyknuty ten interface komponenty (pokial obsahuje len create() metodu) pisat priamo do toho suboru s classou, takze to mam pohromade.
Pouziva to niekto podobne? Alebo je to uplna blbost a porusuje to PSR standard? Samozrejme pre interfacy s viacerymi metodami vytvaram zvlast subor.

Diky za nazory.

Pokud by ses chtěl tomu interface vyhnout (ve většině případů ho reálně nepotřebuješ), můžeš se inspirovat tím, jak jsou formuláře vytvářeny v sandboxu.

ondrapech napsal(a):
A jak potom takový formulář dostanu v presenteru?

Továrnu předáš do presenteru a zavoláš ji v createComponent metodě. Inspirovat se můžeš opět v sandboxu

Zdravím,

snažím se dostat do do konstruktoru formuláře pole obsahující parametry, nedaří se mi Nette donutit, aby správně spárovalo všechny vstupní proměnné.

Třídu mám definovanou takto:

class FormFactory extends Nette\Application\UI\Control
{
	/** @var App\Model\DatabaseManager */
	private $databaseManager;

	/** @var array */
	private $parameters;

	/** @var Nette\Security\User */
	private $user;

	/** @persistent */
	public $locale;

    /** @var Nette\Localization\ITranslator @inject */
	public $translator;

	public function __construct(User $user, DatabaseManager $databaseManager, array $parameters)
	{
		$this->databaseManager = $databaseManager;
		$this->user = $user;
		$this->parameters = $parameters;
	}

Ale pokud v presenteru zavolám

$form = $this->formFactory->createSelectUser(['eventId' => 101]);

Dostanu

Nette\DI\ServiceCreationException

Service of type App\Model\FormFactory: Parameter $parameters in FormFactory::__construct() has no class type or default value, so its value must be specified. search►

Mohu poprosit o radu? Díky!

@Vojtha Myslím, že jsi nepochopil princip factories. Jak píše nightfish, to, co dědí Nette\Application\UI\Control, je form a ne form factory.

Pokud nepoužiješ factory, může mít v presenteru klidně:

protected function createComponentForm(): Form
{
	return new Form($this->user, $this->databaseManager, ['eventId' => 101]);
}

To ale není moc pohodlné, protože musíš předávat ručně všechny závislosti ($user a $databaseManager) a navíc vytváříš skrytou závislost na Form (presenter ho používá, ale není to vidět v jeho konstruktoru).

Proto raději využijeme továrnu. Její zodpovědnost je vytvořit Form s tím, že služby, které jsou v DI kontejneru, vezme odtam a zbytek předá:

final class FormFactory
{

	public function __construct(
		private User $user,
		private DatabaseManager $databaseManager,
	) {}

	public function createSelectUser(array $parameters): Form
	{
		return new Form($this->user, $this->databaseManager, $parameters);
	}

}

Nette navíc nabízí automatické vygenerování továrny, pokud z ní místo class uděláš interface. Jen myslím, že se ta metoda pak musí jmenovat create:

interface FormFactory
{
	public function create(array $parameters): Form;
}

V presenteru to pak vypadá takto:

public function __construct(
	private FormFactory $formFactory,
) {}

protected function createComponentForm(): Form
{
	return $this->formFactory->create(['eventId' => 101]);
}

Jo a ten FormFactory je třeba zaregistrovat do DI:

services:
	- Tvuj\Namespace\FormFactory

Editoval dakur (27. 9. 2022 8:01)

@Vojtha Pokud potřebuješ jeden formulář vykreslit víckrát – pro každé eventId jeden – obal jej Multiplierem.

@dakur Ahoj, rád bych si upřesnil třídu Form v kódu který Jsi uvedl výše:

protected function createComponentForm(): Form
{
	return new Form($this->user, $this->databaseManager, ['eventId' => 101]);
}

předpokládám, že třída Form není Nette\Application\UI\Form, ale zjednodušený zápis třeba OrderForm který dědí z Nette\Application\UI\Control – tak jak před 3 lety v této diskuzi radil @jiripudil :

class OrderForm extends Nette\Application\UI\Control
{
	private $product;
	private $userContext;

	public function __construct(
		Product $product, // parametr předaný v create()
		Nette\Security\User $userContext // služba z kontejneru
	)
	{
		$this->product = $product;
		$this->userContext = $userContext;
	}
}

interface OrderFormFactory
{
	public function create(Product $product): OrderForm;
}

class OrderPresenter extends Nette\Application\UI\Presenter
{
	protected function createComponentOrderForm(): OrderForm
	{
		return $this->orderFormFactory->create($this->product);
	}
}

Předpokládám, že formulář který se vytvoří z vlastní třídy z Nette\Application\UI\Control bude někde vevnitř třídu Nette\Application\UI\Form obsahovat. A zde bych měl jeden dotaz:

Proč se Nette\Application\UI\Form obaluje do Nette\Application\UI\Control, něco se tím získá a co? Já jsem si udělal factory, která vytváří formulář přímo z Nette\Application\UI\Form a nejde na to oklikou přes Nette\Application\UI\Control a zdá se, že to takto celkem stačí.

Jakým způsobem se třída Nette\Application\UI\Form implementuje do obalující komponenty? Pomocí addComponent(), nebo createComponentForm()?

Takže já odhaduji, že kompletní kód by mohl vypadat asi takto:

class OrderForm extends Nette\Application\UI\Control
{
	public function __construct(
		private Product $product,
		private Nette\Security\User $user,
	)
	{}

	public function createComponentForm(): Nette\Application\UI\Form
	{
		$form = new Nette\Application\UI\Form;

		$form->addText(.....);

    	.......

		return $form;
	}
}

Případně, kdyby bylo možné dodat link na nějaký komplexní vysvětlující článek ke konceptu formuláře zabaleného do vlastní komponenty. Díky