Formuláře a jejich process služby

Dlouho mé formuláře vypadaly nějak takto:

class SettingForm extends \Sharezone\Application\UI\TemplateForm
{

	/**
	 * @var SettingFormProcess $settingFormProcess
	 */
	private $settingFormProcess;

	/**
	 * @param SettingFormProcess $settingFormProcess
	 */
	public function injectSettingFormProcess(SettingFormProcess $settingFormProcess)
	{
		$this->settingFormProcess = $settingFormProcess;
	}

	/**
	 * @param array $defaults
	 */
	public function __construct(array $defaults)
	{
		parent::__construct();

		$this->configure();
		$this->setDefaults($defaults);
		$this->onSuccess[] = $this->formSubmitted;
	}

	/**
	 * @param SettingForm $form
	 */
	public function formSubmitted(SettingForm $form)
	{
		try {
			$this->settingFormProcess->send($form->getValues());
			$this->presenter->flashMessage('Your profile has been updated.', 'success');
			$this->presenter->redirect('Stream:');
		} catch (\Nette\InvalidArgumentException $ex) {
			$form->addError($ex->getMessage());
		}
	}

	private function configure()
	{

		$this->addText('nick', 'Username:');

		//..
	}
}

v configu:

factories:
settingForm:
    create: \Sharezone\Components\Settings\SettingForm(%defaults%)
    implement: \Sharezone\Components\Settings\ISettingFormFactory
    parameters: [array defaults]

Po tom co se začalo diskutovat o tom, zda bude podpora inject* metod pro verzi 2.1 zachována, uvědomil jsem si, že to není možná úplně dobrý způsob.

Vše by bylo krásně vyřešeno, kdybych závislost předal v konstruktoru, ale přiznejme si, že předávat services závislosti formu přes kontruktor je trochu hloupé :)

Vzhledem k tomu, že ve své app používám kdyby/events napadlo mě jiné řešení.

Vytvořil jsem si FormListener, který se mi bude starat o události:

use Kdyby\Events\Subscriber;
use Nette\DI\Container;
use Nette\InvalidStateException;
use Nette\Object;
use Nette\Application\UI\Form;

class FormListener extends Object implements Subscriber
{

	/** @var \Nette\DI\Container */
	private $context;

	/**
	 * @param Container $container
	 */
	public function __construct(Container $container)
	{
		$this->context = $container;
	}

	/**
	 * @param Form $form
	 * @param      $class
	 * @throws \Nette\InvalidStateException
	 */
	public function onSuccessSend(Form $form, $class)
	{
		$service = $this->context->getByType($class);

		if($service instanceof IFormProcess) {
			$service->process($form);
		}else{
			throw new InvalidStateException($class . ' must be instance of Sharezone\Application\IFormProcess');
		}
	}

	/**
	 * Returns an array of events this subscriber wants to listen to.
	 *
	 * @return array
	 */
	function getSubscribedEvents()
	{
		return array(
			'Sharezone\Application\UI\Form::onSuccessSend',
			'Sharezone\Application\UI\TemplateForm::onSuccessSend',
		);
	}

přidáno do configu:

FormListener:
    class: \Sharezone\Application\FormListener
    tags: [kdyby.subscriber]

Když nově vytvořený Listener aplikuji na jakýkoliv form, může to vypadat nějak takto:

class AddCommentForm extends \Sharezone\Application\UI\TemplateForm
{

	/**
	 * @param $id
	 */
	public function __construct($id)
	{
		parent::__construct();
		$this->setId((int)$id);
		$this->configure();
		$this->attachProcessService();
	}

	private function configure()
	{
		$this->getElementPrototype()->id = 'addCommentForm';

		$this->addTextArea('content', 'Comment')
			->addRule(self::MAX_LENGTH, null, 500)
			->addRule(self::FILLED)
			->setAttribute('placeholder', 'Please enter your comment');

		$this->addSubmit('send', 'Submit');
	}

}

kde metoda attachProcessService je jen syntax sugar pro:

public function attachProcessService()
	{
		$self = $this; //php 5.3
		$this->onSuccess[] = function (Form $form) use ($self) {
			$self->onSuccessSend($form, get_called_class() . 'Process');
		};
	}

a konečně třída starající se o zpracování formu:

class AddCommentFormProcess extends Object implements IFormProcess
{

	/**
	 * @var \Sharezone\Model\Comments\CommentManager $commentManager
	 */
	private $commentManager;

	/**
	 * @param \Sharezone\Model\Comments\CommentManager $commentManager
	 */
	public function __construct(\Sharezone\Model\Comments\CommentManager $commentManager)
	{
		$this->commentManager = $commentManager;
	}

	/**
	 * @param Form $form
	 * @return mixed|void
	 */
	public function process(Form $form)
	{
		try {
			$this->commentManager->create($form->getValues());
			$form->presenter->flashMessage('Comment was successfully added.', 'success');
		} catch (\Nette\InvalidArgumentException $ex) {
			$form->addError($ex->getMessage());
		};
	}
}

Závislosti můžu krásně předávat konstruktorem tak, jak by se to mělo.

Nesmím zapomenout, že třídy Sharezone\Application\UI\Form a Sharezone\Application\UI\TemplateForm musí implementovat public property $onSuccessSend, tak aby fungovalo kdyby/events

Vím, že to není dokonalý způsob, ale je to takový jednoduchý způsob pro líné programátory :)

Jako největší nevýhodu výše popsaného postupu bych asi bral to, že v FormListeneru vytvářím závilost na Containeru.

Zajímá mě váš názor na tento postup.

A pokud máte vlastní best practies pro obsluhu formulářů tak, aby logika nebyla umístěna v presenteru, prosím podělte se o ni. Rád se něco přiučím!:-)

//Edit: Docela se mi zalíbil postup, který zmiňuje David zde: https://forum.nette.org/…nebo-tovarna ale trochu mi vadí, že nevyužiji factories a jejich implement parametru. Má někdo s tímto postupem zkušenosti?

Editoval sifik (17. 5. 2013 13:50)