Validace v modelu – dualni validace

bazo napsal(a):

ako validacne pravidlo mozes pouzit lubovolny callback, napr

<?php
$form->addText(...)->addRule(Model::validate,'');
?>

Rozumím tomu, že mohu volat svou validační funkci, obávám se, že tím ale přijdu o validaci formuláře pomocí javascriptu nebo mi něco uniká?

Rád bych využil všech výhod, které validace ormuláře nabízí, tzn. javascript, validace po postu dat, ale rád bych tuto validaci „nějak“ tahal z modelu. Případně máte někdo nějaký jiný způsob řešení?

Ondřej Mirtes napsal(a):

Ad javascript – ano, obáváš se správně.

A řešíte to tedy nějak?

Ty samotné validační metody jsou myslím v TextBase, aktuálně je to prostě příliš svázané s formuláři.

Neřeším to nijak, v modelu nevaliduji.

Protože bych rád měl nadefinovanou sadu validačních pravidel pro jeden model na jednom místě a tato pravidla bych potom rád používal v různých presenterech/formulářích, bez nutnosti je znovu definovat, tak nakonec to budu řešit asi takhle:

Protože se mi líbí stromová struktura pravidel v Nette s možností nastavit pravidlo jako podmínku, vyjdu z ní. Abych mohl párovat pravidla s parametry v modelu a s parametry ve formulářích, potřebuji aby každá instance pravidla s sebou nesla název parametru, jehož hodnotu validuje. Zároveň potřebuji předem nadefinovat sadu pravidel, kterou mohu rozdistribuovat po formulářích a pod., to znamená, že data do validátorů mohou být předána až v době validace. Také chci zachovat validaci ve formulářích pomocí javascriptu. A nakonec chci aby jednotlivá pravidla byla co nejjednodušší, tzn. předá se jim pouze název a hodnota, kterou mají validovat.

Vytvořil jsem si tedy stromovou strukturu pravidel. Jedno pravidlo s sebou nese pouze svůj název, který mi potom poslouží k párování s parametry, tzn.:

<?php
abstract class Rule
{
	private $name = null;

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

	abstract public function validate($value);

	public function getName()
	{
		return $this->name;
	}
}

// podedim z predka a vytvorim pravidlo zjistujici, zda-li promenna obsahuje hodnotu xxx
class XxxRule extends Rule
{
	public function validate($value)
	{
		return ($value == 'xxx');
	}
}
?>

Protože pravidlo jako takové nenese informaci o tom, zda-li se jedná o validaci nebo podmínku, vytvořím si pro něj obálku. Obálka bude také zjišťovat aktuální hodnotu validované proměnné:

<?php
class RuleType
{
	const VALIDATOR = 1;
	const CONDITION = 2;

	private $rules = null;
	private $rule = null;
	private $type = null;

	// do obalky predam pravidlo a jeho typ
	public function __construct(Rule $rule, $type = self::VALIDATOR) {
		$this->rules = new Rules();
		$this->rule = $rule;
		$this->type = $type;
	}

	// validuji hodnotu parametru predaneho objektu
	public function validate($object) {
		// nazev validovaneho parametru ziskam z nazvu pravidla
		$name = $this->rule->getName();

		switch ($this->type) {
			case self::VALIDATOR:
				if ($this->rule->validate(isset($object->$name) ? $object->$name : null)) {
					return $this->rules->validate();
				}
				return false;
			break;
			case self::CONDITION:
				if ($this->rule->validate(isset($object->$name) ? $object->$name : null)) {
					return $this->rules->validate();
				}
				return true;
			break;
		}
	}

	// vrati vnorena pravidla pro pripad podminky
	public function getRules() {
		return $this->rules;
	}

	// vrati pravidlo, pro pripad ze chci vratit strukturu pravidel
	public function getRule() {
		return $this->rule;
	}
}
?>

Pravidla uložím do kolekce pravidel, abych z nich mohl vytvořit strukturu.

<?php
class Rules implements IteratorAggregate
{
	private $rules = array();

	public function __construct() {
	}

	// prida pravidlo do kolekce
	public function addRule(Rule $rule) {
		$this->rules[] = new RuleType($rule);
		return $this;
	}

	// prida podminku
	public function addCondition(Rule $rule) {
		$ruleType = new RuleType($rule, RuleType::CONDITION);
		$this->rules[] = $ruleType;

		return $ruleType->getRules();
	}

	// zavola pravidla v kolekci a preda jim objekt, jehoz parametry budou validovany
	public function validate($object) {
		foreach ($this->rules as $rule) {
			if (!$rule->validate($object)) {
				return false;
			}
		}

		return true;
	}

	public function getIterator() {
		return new ArrayIterator($this->rules);
	}
}
?>

A nakonec pravidla pouziju nekde v modelu:

<?php
class Model
{
	public $var = 'xxx';

	public function __construct() {
	}

	// vytvorim si strom pravidel
	private static function getRules() {
		$rules = new Rules();
		$rules->addRule(new XxxRule('var'))->addCondition(new XxxRule('var'))->addRule(new XxxRule('vare'));

		return $rules;
	}

	// tahle funkce bude treba neco ukladat do databaze
	public function save() {
		// pouziju vytvorena pravidla
		var_dump(self::getRules()->validate($this));
	}

	// vytisknu strom pravidel, toto vyuziju pri aplikaci pravidel na Form
	public function printRules(IteratorAggregate $rules = null) {
		if ($rules == null) {
			$rules = self::getRules();
		}

		foreach ($rules as $ruleType) {
			$rule = $ruleType->getRule();
			echo "<br />\n" . get_class($rule) . "::" . $rule->getName();
			$this->printRules($ruleType->getRules());
		}
	}

}

$model = new Model();
$model->save();
$model->printRules();
?>

Krásné by bylo, kdybych vytvořený strom mohl vzít a snadno ho použít i jinde mimo model, například ve formuláři, štěstí mi bohužel nepřeje, tak budu muset namapovat pravidla na pravidla formuláře. To udělám tak, že podědím třídu AppForm a přidám metodu addRules(Rules $rules) pomocí které naliju pravidla do formuláře.

To která pravidla mám ke kterým prvkům přiřadit zjistím tak, že porovnám název třídy, který určí název pravidla a name v instanci pravidla mi určí název parametru, tzn.:

<?php
	$rule = new EmailRule('login_name');
	get_class($rule) == 'EmailRule'; // vim, ze chci pridat Form::EMAIL
	$rule->getName() == 'login_name'; // vim, ze jej chci pridat parametru login_name
?>

Tuto operaci můžu provést až po vytvoření formuláře, tzn. přidání všech jeho polí (možná to půjde přidat do přetížené metody FormContainer::validate(), takže můžu přidat pravidla před přidáním prvků, to ale ještě budu muset promyslet).