Jak do komponenty s výpisem produktů přidat formulář pro vložení do košíku

V tom formuláři vůbec nepotřebuješ políčko ID produktu – to ti totiž přijde z Multiplieru (když si ho tam dáš jako parametr té anonymní funkce). A předáš si ho v šabloně samozřejmě.

protected function createComponentShopForm()
   {
       return new Multiplier(function ($productID) {
           $form = new Form;
           $form->addHidden('count', 1);
           $form->addSubmit('send', 'Přidat do košíku');

			$form->onSuccess[] = function ($form, $values) use ($productID) { // use($productID) je potřeba kvůli anonymní funkci
				$this->model->addProductToCart($productID, 1 /* nebo $values->count */);
			};
           return $form;
       });
   }

pak v šabloně

{control product-$product->id} {* pomlčka je právě pro Multiplier *}

Editoval CZechBoY (24. 1. 2017 19:49)

Tam jak si psal ten předchozí

{control product $product}

Takže asi v šabloně té komponenty? Když v ní vytváříš ten form. :-)

Editoval CZechBoY (24. 1. 2017 19:57)

Pokud v šabloně komponenty vykreslím form pro přidání do košíku takto:

{control shopForm-$item->id}

všechno funguje jak má. Já ale potřebuju formulář vykreslit ručně:

<form  n:name="shopForm">
  <button class="addtocart">
   <i class="fa fa-shopping-cart"></i>
   <span>Do košíku</span>
   </button>
</form>

a v tu chvíli mi to řve:
Argument 1 passed to Nette\Bridges\FormsLatte\Runtime::renderFormBegin() must be an instance of Nette\Forms\Form, instance of Nette\Application\UI\Multiplier given,

Poraďte prosím, jak se s tím poprat.

Nebo si dej formulář do další samostatný komponenty.
Trošku jsem se v tom zamotal i já.
Pokud už vykresluješ komponentu pro konkrétní produkt a v ní vytvoříš formulář tak už taky víš o jaký produkt se jedná žejo.

Je teda potřeba změnit strukturu komponenty a vytváření taky

class ProductControl extends Control
{
	private $product;

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

    public function render()
    {

        $template = $this->template;
        $template->setFile(__DIR__ . '/Product.latte');

        // vložíme do šablony udaje o produktu
        $template->item = $this->product; // product je v $this->product a už se nepředává přes render parametr

        // a vykreslíme ji
        $template->render();
    }

	protected function createComponentShopForm()
    {
       $form = new Form;

       $form->addHidden('count', 1); // je tohle potřeba?
       $form->addHidden('itemId', 15222); // tohle můžu vynechat, ID produktu mám v $this->product->getId() nebo něco podobného

       $form->addSubmit('send', 'Přidat do košíku');

       return $form;
    }
}

interface IProductControlFactory
{
    /** @return ProductControl */
    function create($product); // tady je potřeba přidat parametr $product, který chci po Presenteru aby mi ho předal
}

Potom v BasePresenteru

	protected function createComponentProduct()
{
		return new Multiplier(function($productID) {
	    $control = $this->productFactory->create($this->products[$productID]); // počítá s tím, že všechny produkty máš v asociativním poli $this->products.
	        return $control;
		});
}

a nakonec v @layout.latte (nebo kde ty produkty vypisuješ)

{foreach $products as $product}

	{control product-$product->getId()} {* nezapomeň na přední IDečka a pomlčku pro Multiplier *}

{/foreach}

Editoval CZechBoY (24. 1. 2017 21:46)

Chápu správně, že se komponenta ProductControl se stará o vykreslení právě jednoho produktu? Nic víc? Takhle jsem to pochopil z kódu a komentářů.

Jestli ano, tak nepotřebuješ používat multiplier ve formuláři ShopForm a můžeš to upravit takto:

class ProductControl extends Control
{

    public function render($product)
    {
		$this->product = $product; // Bylo by lepší předávat produkt v konstruktoru, ale vím o struktuře příliš málo
        $template = $this->template;
        $template->setFile(__DIR__ . '/Product.latte');

        // vložíme do šablony udaje o produktu
        $template->item = $product;

        // a vykreslíme ji
        $template->render();
    }

   protected function createComponentShopForm()
   {
           $form = new Form;
           $form->addSubmit('send', 'Přidat do košíku');

			$form->onSuccess[] = function () {
				$idProduct = $this->product['id'];
				$count = 1;
			};

           return $form;
   }
}
interface IProductControlFactory
{
    /** @return ProductControl */
    function create();
}

Kód od @CZechBoY je lepší, ale potřebujeme znát, jak načítáš produkty v presenteru.

@Martk je to takhle:

Komponenta ProductControl vykresluje jeden konkrétní produkt + přidává formulář s tlačítkem „přidat do košíku“.

Bez multiplieru jsem to zkoušel na začátku, ale všechny formuláře na stránce (na jedné stránce je vypsáno více produktů) měli stejné ID a obsahovali stejný produkt (první).

Produkty načítám v presenteru, který dědí od Base presenteru

V presenteru mám:

$this->template->products = $this->model->getProducts()

V modelu:

public function getProducts()
    {
        return $this->connection->table('product');
    }

v šabloně presenteru pak vypisuji produkty takto:

{foreach $products as $product}
     {control product $product}
{/foreach}

tím pro každý vypisovaný produkt na jedné stránce zavolám komponentu Product, který vykreslí jeden konkrétní produkt vč. formu pro vložení konkrétního produktu do košíku.

Editoval andros (24. 1. 2017 23:23)

Jak popisuje @Martk jsem zkoušel hned na začátku, problém byl, že form měl stejné ID a pro všechny produkty na stránce obsahoval stejné údaje (prvního produktu), proto jsem pátral dál a přišel na multiplier …

CZechBoY napsal(a):

@Martk Tenhle render workaround nebude fungovat pro formulář.
Odešle se formulář a zpracuje se jako signál, což je o několik kroků dřív v životním cyklu aplikace než renderování šablony, kde se ten product konečně uloží do $this->product.

@CZechBoY Máš pravdu neuvědomil jsem si to.

@andros Zapomněl jsem ještě dopsat, že jsi musel použít multiplier u produktů, protože ty se množí, ne formuláře.

protected function createComponentProduct()
    {
		return new Multiplier(function () {
        	return $this->productFactory->create();
		});
    }

a šablona:

{control product-$product['id'] $product}

Jak jsi shrnul v jednom předchozím příspěvku celou komponentu, tak mi z toho nebylo jasné toto:

Base presenter:

protected function createComponentProduct()
  {
    return new Multiplier(function($productID) {
        $control = $this->productFactory->create($this->products[$productID]); // počítá s tím, že všechny produkty máš v asociativním poli $this->products.
        return $control;
    });
  }

Base presenter produkty ještě nezná, ty se načítají až v nějakém dalším presenteru, který dědí od base presenter. Pokud to tedy chápu správně, musel bych tuto metodu uvádět v konkrétním presenteru, kde mám načtené produkty k zobrazení. Jenž pak bych tuto metodu musel uvádět ve všech presenterech, kde se vypisují produkty. Když je metoda v basepresenteru, stačí ji napsat jednou pro celou aplikaci.

Díky vašim radám mám celou komponentu takhle:

class ProductGridControl extends Control
{
    private $basketManager;
    private $httpRequest;
    private $product;

    public function __construct(BasketManager $basketManager, Nette\Http\Request $httpRequest)
    {
        parent::__construct();
        $this->httpRequest = $httpRequest;
        $this->basketManager = $basketManager;

    }

    public function render($product)
    {
        $this->product = $product;

        $template = $this->template;
        $template->setFile(__DIR__ . '/ProductGrid.latte');

        // vložíme do šablony nějaké parametry
        $template->item = $this->product;

        // a vykreslíme ji
        $template->render();
    }

    protected function createComponentShopForm()
    {
        return new Multiplier(function ($productId) {
            $form = new Form;
            $form->addHidden('count');
            $form->addHidden('name');
            $form->addHidden('price');
            $form->addSubmit('send', 'Přidat do košíku');

            $form->setDefaults([
                'quantity' => 1,
                'prod_id' => $this->product['id'],
                'name' => $this->product['name'],
                'price' => $this->product['d1']

            ]);

            $form->onSuccess[] = function ($form, $values) use ($productId) { // use($productID) je potřeba kvůli anonymní funkci
               $this->basketManager->insert([
                   'quantity' => 1,
                   'prod_id' => $productId,
                   'guest_id' => $this->httpRequest->getCookie('guest'),
                   'name' => $values->name,
                   'price' => $values->price
               ] );

                $this->presenter->flashMessage('Přidali jste zboží do košíku', 'success');
                $this->redirect('this');
            };

            return $form;
        });
    }



}

interface IProductGridControlFactory
{
    /** @return ProductGridControl */
    function create();
}

Asi to není ideální, ale je to funkční a to díky vašim radám :)

Ano, všechny komponenty vytvářím v base presenteru. Někde jsem to četl, že je to dobré proto, abych mohl komponentu používat kdekoliv a nemusel jsem ji vytvářet na více místech.

produkty načítám z databáze pomocí modelu v metodě renderDefaut(). Vlastně všechny data které posílám do šablony načítám pomocí modelu v metodách renderDefault. Opět jsem to vyčetl v nějakém návodu – je to takhle v návodu na tvorbu první aplikace.

CZechBoY napsal(a):

Počkej počkej počkej. Ty vytváříš komponentu jinde než kde načítáš produkty? Proč?
btw. produkty si v action metodě ulož do $this->products.

No pokud ty data využíváš ještě v komponentách tak je dobrý si ty data uložit do třídní proměnné už v action metodě. Potom v render metodě si je z třídní proměnné uložíš do šablony $this->template.

Co se týče komponent v BasePresenteru: komponenty tam dělej pokud je používáš v @layout.latte (a do něj přímo includovaných šablon), nikde jinde to opravdu nemá smysl a je lepší udělat nějakou traitu.

příklad traity (nezkoušel jsem funkčnost)

trait TProductInfoComponent
{
	/**
	  * @var IProductInfoFactory
	  * @inject
	  */
	public $productInfoFactory;

	protected function createComponentProductInfo()
	{
		return $this->productInfoFactory->create();
	}
}

class AbcPresenter extends BasePresenter
{
	use TProductInfoComponent; // a už mám productInfo komponentu
}

Editoval CZechBoY (24. 1. 2017 23:49)

Nemyslel jsi tim, ukládat produkt to this->product ?

Takže by to mělo být takto ?

public function render($product)
    {


        $template = $this->template;
        $template->setFile(__DIR__ . '/ProductGrid.latte');

        // vložíme do šablony nějaké parametry
        $template->item = $product;

        // a vykreslíme ji
        $template->render();
    }

andros napsal(a):

Co myslíš tím , že nepotřebuji ten product ukládat ?

CZechBoY napsal(a):

Jo, to je taky varianta.
Jen doplním, že nepotřebuješ ten product ukládat

1. je ti po renderování už k ničemu
2. nikde jinde než v renderu ho nepoužíváš

Je lepší vždycky vyžadovat interface (pokud je dostupný), tzn. místo Nette\Http\Request použij Nette\Http\IRequest.
Tady máš trošku více info o tom jak správně vyžadovat závislosti http://nette.matej21.cz/cs/di.

V @layout.latte mám hlavičku a patičku webu, do něj načítám pomocí {incude content} všechny ostatní šablony webu. Každou šablonu mám mám v bloku {block content} {/block}.

CZechBoY napsal(a):

No pokud ty data využíváš ještě v komponentách tak je dobrý si ty data uložit do třídní proměnné už v action metodě. Potom v render metodě si je z třídní proměnné uložíš do šablony $this->template.

Co se týče komponent v BasePresenteru: komponenty tam dělej pokud je používáš v @layout.latte (a do něj přímo includovaných šablon), nikde jinde to opravdu nemá smysl a je lepší udělat nějakou traitu.

příklad traity (nezkoušel jsem funkčnost)

trait TProductInfoComponent
{
	/**
	  * @var IProductInfoFactory
	  * @inject
	  */
	public $productInfoFactory;

	protected function createComponentProductInfo()
	{
		return $this->productInfoFactory->create();
	}
}

class AbcPresenter extends BasePresenter
{
	use TProductInfoComponent; // a už mám productInfo komponentu
}

Tak potom nepoužíváš tu komponentu na každé stránce a neměla by se vytvářet v BasePresenteru…
Já mám v BasePresenteru komponenty akorát na CSS a JS. V některých webech třeba ještě menu a přihlašovací form.

Tu traitu dej někam do app složky, ideálně do vlastního souboru (každá třída by měla být ve svém vlastním souboru). Možná ta traita nepojede, nezkoušel jsem. Taky jsem možná blbě napsal název té tovární třídy tak to si kdyžtak uprav.

Napsat vytváření komponenty ve 2 presenterech ještě není taková hrůza :-).