Kontrola danych wejsciowych Opcje

[kicaj]

Jak optymalnie i bardziej uniwersalnie sprawdzac dane w kontrolerach (data input)?
Pisanie kontrolerow na zasadzie:

[PHP] pobierz, plaintext 
<?php
class NameController extends Controllers
{
	function indexAction( $aParams )
	{
		 if( isset( $aParams['id'] ) 
		 {
			  if( is_numeric( $aParams['id'] ) // ...
		 }
		 else
		 {
			   echo 'nie podano id!';
 
//...i tak w kazdej metodzie, sprawdzane rozne warunki z danych wejsciowych
?>
[PHP] pobierz, plaintext 

Sprawdzanie tego w kazdym kontrolerze i w jego kazdej metodzie mija sie z celem, jak to rozwiazac inaczej?

[splatch]

Kontrola danych wejściowych w miarę możliwości powinna być poza ciałem akcji. Jakkolwiek nie zależy zapominać że to konkretna akcja determinuje nam warunki walidacji.
Warunki typu czy to liczba, czy to jest wymagane i tak dalej można wyodrębnić do klas, które załatwią nam walidację. Jak zwykle w takim przypadku zaczynamy od interfejsu:

[PHP] pobierz, plaintext 
<?php
interface Validation {
	/**
	  * @param $ctx Kontekst z informacjami na temat walidacji
	  **/
	public function validate(ValidationContext $ctx);
}
?>
[PHP] pobierz, plaintext 

Dobrze, teraz jak może wyglądać definicja kontekstu walidacji:

[PHP] pobierz, plaintext 
<?php
interface ValidationContext {
 
	// tu mamy ważny błąd
	public function addError($key, ValidationMessage $msg);
 
	// a tu powiedzmy, ostrzeżenie
	public function addNotice($key, ValidationMessage $msg);
 
	public function addValidator(Validator $v);
 
	// czy wszystko "ok"
	public function isPassed();
 
	// mapa wiadomości gdzie kluczem jest nazwa pola a wartością kolekcja wiadomości
	public function getMessages();
 
		// tutaj dane z requestu
	public function getArgument($key);
}
?>
[PHP] pobierz, plaintext 

Dobra, dorzućmy do tego jeszcze wiadomość:

[PHP] pobierz, plaintext 
<?php
interface ValidationMessage {
 
	// tutaj wiadomość, oczekujemy tylko tego - jak ona jest ustawiana
	// to już kwestia wtórna
	public function getMessage();
}
?>
[PHP] pobierz, plaintext 

Może wydawać się dziwne to, że robię interfejs do takiego banału, aczkolwiek mam jeden cel:

[PHP] pobierz, plaintext 
<?php
abstract class AbstracMessage {
 
	// nie można się dobrać do wiadomości nawet z potomków
	private $message;
 
	public function __construct($message, array $args = array()) {
		$this->message = $this->transform($this->getMessageString($message), $args);
	}
 
	protected abstract function getMessageString($message);
 
	private function transform($string, array $args) {
		 // tu może być coś innego
		 return strtr($string, array_keys($args), array_values($args));
	}
 
	// to nam wymusza odwołanie do konstruktora
	public final function getMessage() {
		return $this->message;
	}
}
 
// ta wiadomość po prostu zwraca tekst, który był
class RawMessage extends AbstractMessage {
	protected function getMessageString($message) {
		return $message;
	}
}
 
// a ta wiadomość tłumaczy ładnie komunikaty
class I18nMessage extends AbstractMessage {
 
	private $resource;
 
	public function __construct(I18nValidationContext $ctx, $message, array $args = array()) {
		$this->resource = $ctx->getI18Resource();
		parent::__construct($message, $args);
	}
 
	protected function getMessageString($message) {
		return $this->resource->getString($message);
	}
}
 
// to powtórka z rozrywki - mamy interfejs i dorabiamy implementacje
interface MessageResource {
	public function getString($key);
	public function getStringArray($key);
}
 
// implementacja do zrobienia
interface I18nValidationContext extends ValidationContext {
	public function getResource();
}
 
?>
[PHP] pobierz, plaintext 

Dobra, wiadomości wiadomościami, ale przecież nie jest to najistotniejsze, najbardziej przecież nas interesuje powiązanie tego wszystkiego - czyli jak akcja "się waliduje". Zasadniczo znowu byłbym za interfejsem:

[PHP] pobierz, plaintext 
<?php
interface Action {
	public function execute();
}
 
interface SecureAction {
	public function getCredentials();
}
 
interface ValidationRequiredAction {
	public function validate(ValidationContext $ctx);
}
?>
[PHP] pobierz, plaintext 

Mając takie definicje front controller, który ma podniesiony ValidationContext może rozróżnić co zrobić - czyli najpierw sprawdza czy akcja wymaga autoryzacji - jeśli tak sprawdza uprawnienia, następnie weryfikuje czy dane, które przychodzą są ok.

Teraz rzecz zasadnicza - czyli co z konfiguracją. Jak widać same walidatory to pestka - ale jak zrobić to ładnie. No więc - może przykładowa implementacja:

[PHP] pobierz, plaintext 
<?php
 
class DefaultValidationContext implements ValidationContext {
 
	private $errors = 0;
 
	// tu mamy ważny błąd
	public function addError($key, ValidationMessage $msg) {
		$this->addMessage(new StackEntry('error', $key, $msg));
		++$this->errors;
	}
 
	// a tu powiedzmy, ostrzeżenie
	public function addNotice($key, ValidationMessage $msg) {
		$this->addMessage(new StackEntry('notice', $key, $msg));
	}
 
	protected final function addMessage(StackEntry $msg) {
		if (!isset($this->message[$msg->getKey()])) {
			$this->message[$msg->getKey()] = array();
		}
		$reference = &$this->message[$msg->getKey()];
		// teraz w widoku/akcji mamy do dyspozycji info o "powadze" błędu
		// oraz powiązaną z nim wiadomość
		$reference[sizeof($reference)]['severity'] = $msg->getSeverity();
		$reference[sizeof($reference)]['msg'] = $msg->getValidationMessage();
	}
 
	// czy wszystko "ok"
	public function isPassed() {
		$i = 0;
		$validatorsCount = sizeof($this->validators);
		do {
			// jeśli coś się tu stanie to zwiększy nam się rozmiar tablicy $errors
			$this->validators[$i]->validate($this);
		} while ($this->errors == 0 && ++$i < $validatorsCount);
 
		// przeszliśmy wszystkie walidatory i nie ma błędów
		return ++$i == $validatorsCount && $this->erros == 0;
	}
 
	// mapa wiadomości gdzie kluczem jest nazwa pola a wartością kolekcja wiadomości
	public function getMessages() {
		return $this->message;
	}
 
	public function addValidator(Validator $v) {
		$this->validators[] = $v;
	}
 
}
 
 
?>
[PHP] pobierz, plaintext 

No i na końcu akcja

[PHP] pobierz, plaintext 
<?php
class MyAction implements SecureAction, ValidationRequiredAction {
 
	// dorzucamy co trzeba do kontekstu - resztę załatwia za nas FrontController
	public function validate(ValidationContext $ctx) {
		$ctx->addValidator(new NotEmptyValidator('user_id'));
		$ctx->addValidator(new NumberFormatValidator('user_id'));
	}
 
}
?>
[PHP] pobierz, plaintext 

Aa i jeszcze walidatory:

[PHP] pobierz, plaintext 
<?php
class NotEmptyValidator implements Validator {
 
	private $field;
 
	public function __construct($field) {
		$this->field = $field;
	}
 
	public function validate(ValidationContext $ctx) {
		if (empty($ctx->getArgument($field)) {
			$ctx->addError(new RawMessage('Wartość {0} jest pusta', array($field)));
		}
	}
}
?>
[PHP] pobierz, plaintext 

Kilka uwag odnośnie kodu, który jest wyżej .. przede wszystkim walidatory dodają wiadomości - równie dobrze mogą bronić się wyjątkami, aczkolwiek mamy wówczas problem ze sformułowaniem komunikatu dla użytkownika. Można zatem rozważyć dwie opcje - wydelegować formatowanie wiadomości z AbstractMessage do ValidationContext - wówczas zmieniły by się nam sygnatury metod addError, addNotice. Druga opcja to przesunąć formatowanie wiadomości do akcji.
Dlaczego dodałem coś takiego jak notice w walidacji? Są to informacje, które nie wywalają całego procesu, a które można wyświetlić przy ponownym wyświetlaniu błędu - powiedzmy ktoś nie podał wartości w wymaganym polu a w innym gdzie był powinien trafić float dostaliśmy int - dodajemy notice o konwersji.

Aaa i jeszcze walka z tworzeniem walidatorów:

[PHP] pobierz, plaintext 
<?php
class XmlValidationForm implements Action {
 
	public final function validate(ValidationContext $ctx) {
		$path = $this->getContextPath();
		$binder new XmlValidatorBinder($path, $ctx);
	}
 
	public function getContextPath() {
		return get_class($this) .'-validation.xml';
	}
 
}
 
class MyAction extends XmlValidationForm implements SecureAction, ValidationRequiredAction {
 
	// tu już nic nie musimy dodawać - na podstawie nazwy klasy zostanie wczytana
	// konfiguracja walidatorów
 
}
?>
[PHP] pobierz, plaintext 

No i kolejna ciekawa wariacja nad którą można pomyśleć:

[PHP] pobierz, plaintext 
<?php
$orValidator = new OrValidationCondition($validator1, $validator2);
$ctx->addValidator($orValidator);
?>
[PHP] pobierz, plaintext 

Kod który przedstawiłem nie jest ani kompletny ani nadzwyczajnie spójny. Może stanowić podstawę do rozpoczęcia prac, aczkolwiek pozostaje jeszcze kilka problemów, które wymagają niezłej gimnastyki. (IMG:http://forum.php.pl/style_emoticons/default/smile.gif)