[klasa] Klasa walidująca dane (ze zmiennych) Opcje

[in5ane]

Hej, chce poddać ocenie swoją klasę walidującą dane. Powiedzcie, co jest dobrze, a co źle. Co do robić, co przerobić. Proszę o opinie (IMG:style_emoticons/default/smile.gif)

[PHP] pobierz, plaintext 
<?php
 
/**
 * Class data validation (can be used to form validation)
 * 
 * Class data validation (can be used to form validation).
 * Here is an example usage and available parameters.
 * Example of use: $formValidation->validate($pass, "required|matches[$pass_c]|min_length[6]");
 * Possible parameters to use:: required, numeric, matches[comparison], min_length[number], max_length[number], exact_length[number], valid_email
 * 
 * @version 1.0
 * @author  Jakub Kubera <jakubkubera1992@gmail.com>
 * @link    www.jakubkubera.pl
 * @license New BSD License
 * @access  public
 */
class ValidationData
{
 
  private $name;
  private $rules = array();
 
  /**
   * Assigning parameters to the class variables and run validation
   * 
   * @param string $name  Field name
   * @param string $rules Field validation rules
   * 
   * @return bool Returns whether validation was successful
   */
  public function validate($name, $rules)
  {
    $this->name = $name;
 
    $this->explodeRules($rules);
 
    return $this->run();
  }
 
  /**
   * Returns whether validation was successful
   * 
   * @return bool Returns whether validation was successful
   */
  private function run()
  {
    $errors = array();
 
    if (in_array('required', $this->rules))
      if ($this->checkRequired() === false)
        $errors[] = 'required';
 
    if (in_array('numeric', $this->rules))
      if ($this->checkNumeric() === false)
        $errors[] = 'numeric';
 
    if ($key = $this->pregArrayKey('/matches\[(.*)]/'))
    {
      preg_match('/\[(.*)]/', $this->rules[$key], $confirm);
      if ($this->checkMatches($confirm[1]) === false)
        $errors[] = $this->rules[$key];
    }
 
    if ($key = $this->pregArrayKey('/min_length\[(.*)]/'))
    {
      preg_match('/\[(.*)]/', $this->rules[$key], $value);
      if ($this->checkMinLength($value[1]) === false)
        $errors[] = $this->rules[$key];
    }
 
    if ($key = $this->pregArrayKey('/max_length\[(.*)]/'))
    {
      preg_match('/\[(.*)]/', $this->rules[$key], $value);
      if ($this->checkMaxLength($value[1]) === false)
        $errors[] = $this->rules[$key];
    }
 
    if ($key = $this->pregArrayKey('/exact_length\[(.*)]/'))
    {
      preg_match('/\[(.*)]/', $this->rules[$key], $value);
      if ($this->checkLength($value[1]) === false)
        $errors[] = $this->rules[$key];
    }
 
    if (in_array('valid_email', $this->rules))
      if ($this->checkEmail() === false)
        $errors[] = 'valid_email';
 
    return (empty($errors)) ? true : $errors;
  }
 
  /**
   * Separation of validation rules
   * 
   * @param $rules Field validation rules
   */
  private function explodeRules($rules)
  {
    $this->rules = explode('|', $rules);
  }
 
  /**
   * Finds that there is a pattern in the rules,
   * like in_array with using regular expressions
   * 
   * @param $pattern Search pattern in the table
   */
  private function pregArrayKey($pattern)
  {
    return key(preg_grep($pattern, $this->rules));
  }
 
  /**
   * Checks and returns whether the value is empty
   * 
   * @return bool Returns whether the value is empty
   */
  private function checkRequired()
  {
    return (!empty($this->name)) ? true : false;
  }
 
  /**
   * Checks and returns whether the value is numeric
   * 
   * @return bool Returns whether the value is numeric
   */
  private function checkNumeric()
  {
    return (is_numeric($this->name)) ? true : false;
  }
 
  /**
   * Checks and returns whether the specified phrases are the same
   * 
   * @return bool Returns whether the specified phrases are the same
   */
  private function checkMatches($confirm)
  {
    return ($this->name == $confirm) ? true : false;
  }
 
  /**
   * Checks and returns whether the value of a specified minimum length
   * 
   * @return bool Returns whether the value of a specified minimum length
   */
  private function checkMinLength($value)
  {
    return (strlen($this->name) > $value) ? true : false;
  }
 
  /**
   * Checks and returns whether the value of a specified maximum length
   * 
   * @return bool Returns whether the value of a specified maximum length
   */
  private function checkMaxLength($value)
  {
    return (strlen($this->name) < $value) ? true : false;
  }
 
  /**
   * Checks and returns whether the value of a specified length
   * 
   * @return bool Returns whether the value of a specified length
   */
  private function checkLength($value)
  {
    return (strlen($this->name) == $value) ? true : false;
  }
 
  /**
   * Checks and returns whether the given value is a valid email address
   * 
   * @return bool Returns whether the given value is a valid email address
   */
  private function checkEmail()
  {
    return (preg_match('/^([a-zA-Z0-9])+([a-zA-Z0-9\._-])*@([a-zA-Z0-9_-])+([a-zA-Z0-9\._-]+)+$/', $this->name)) ? true : false;
  }
 
}
[PHP] pobierz, plaintext 

Przykład użycia:

[PHP] pobierz, plaintext 
<?php
$formValidation = new ValidationData;
 
$age = '123';
var_dump($formValidation->validate($age, "required|numeric|max_length[4]"));
 
$name = 'Kuba';
var_dump($formValidation->validate($name, "required|min_length[5]"));
 
$pass = 'test';
$pass_c = 'test';
var_dump($formValidation->validate($pass, "required|matches[$pass_c]|exact_length[4]"));
 
$email = 'test1test.pl';
if ($formValidation->validate($email, "required|valid_email") === true)
  echo 'Adres e-mail '.$email.' poprawnie zostal zwalidowany';
else {
  echo 'Blad, adres e-mail '.$email.' nie zostal poprawnie zwalidowany, ponizej bledy w tablicy $errors:<br />';
  var_dump($formValidation->validate($email, "required|valid_email"));
}
[PHP] pobierz, plaintext 

Ten post edytował in5ane 29.10.2013, 17:07:57

[gitbejbe]

obiektówką zajmuje sie od niedawna, a ta klasa to pierwsze co napisałem w oop. Lecę teraz na codeigniterze i nie daje sobie ręki uciąć bo tylko rzuciłem okiem na ich skrypt walidacji i wydaje mi się, że schemat jest podobny - po za tym, że zasady określa się w jednym stringu rodzielonym znakiem | oraz pomijając pozostałe funkcje pomocnicze. Walidatory uruchamia wtedy skrypt a nie ja osobiście odwołując się do danego walidatora (na początku własnie tego typu napisałem skrypt, ale później przerobiłem go na to bo ktoś tutaj napisał, ze tak będzie lepiej).Tej klasie dużo brakuje i jestem tego świadom ale działać działa i spełnia swoją role bez zarzutu i można ją łatwo rozszerzać, a wkleiłem ją tylko po to aby autor tematu mógł sobie ją porównać

Będę wdzięczny jeśli powiesz mi co jest głównie nie tak i jak powinien wyglądać prawdziwy schemat takiego skryptu. Z chęcią przyjmę każdą rade : )

[pyro]

obiektówką zajmuje sie od niedawna, a ta klasa to pierwsze co napisałem w oop. Lecę teraz na codeigniterze i nie daje sobie ręki uciąć bo tylko rzuciłem okiem na ich skrypt walidacji i wydaje mi się, że schemat jest podobny - po za tym, że zasady określa się w jednym stringu rodzielonym znakiem | oraz pomijając pozostałe funkcje pomocnicze. Walidatory uruchamia wtedy skrypt a nie ja osobiście odwołując się do danego walidatora (na początku własnie tego typu napisałem skrypt, ale później przerobiłem go na to bo ktoś tutaj napisał, ze tak będzie lepiej).Tej klasie dużo brakuje i jestem tego świadom ale działać działa i spełnia swoją role bez zarzutu i można ją łatwo rozszerzać, a wkleiłem ją tylko po to aby autor tematu mógł sobie ją porównać

Będę wdzięczny jeśli powiesz mi co jest głównie nie tak i jak powinien wyglądać prawdziwy schemat takiego skryptu. Z chęcią przyjmę każdą rade : )

OOP to zabawa w klocki. Muszą być one łatwo nakładane, zdejmowane, wymieniane. Klasy powinny być tworzone tak, aby nie trzeba było ingerować w ich kod dodając kolejne funkcjonalności, tylko bawić się klockami.

Zarówno w Twojej jak i @insane'a klasach nie ma możliwości manipulowania walidatorami. Są one wstawione na sztywno i koniec... nic nie zmienisz bez ingerencji w istniejący już kod. Jedyną możliwością byłoby rozszerzanie klasy za każdym razem jak chcesz dodać kolejny walidator. Ale jak wtedy będziesz nazywał dzieci klasy?

- Validator -> ValidatorWithNip -> ValidatorWithNipAndIdentityCardNumber -> validatorWithNipAndIdentityCardNumberAndImageSize... itd? Zupełnie bez sensu. Poza tym jak będziesz chciał z tego schematu tylko kolejne walidatory Nip i ImageSize bez IdentityCardNumber, to co zrobisz? Nic.

Przykładowa implementacja mająca sens:

Powinien zostać stworzony jakiś menadżer walidatora:

[PHP] pobierz, plaintext 
class Validator {
 
	private $fields;
	// inne pola...
 
	public function addField($name) {
		// ...dodawanie pól
	}
 
	public function removeField($name) {
		// ... usuwanie
	}
 
	public function setFields(array $fields) {
		// ...
	}
 
	public function addConstraint($field, ConstraintInterface $constraint) {
		// Dodawanie przymusu implementującego interfejs ConstraintInterface dla jakiegoś pola
	}
 
	public function removeConstraint() {
		// Zdejmowanie przymusu
	}
 
	public function setConstraints($field, array $constraints) {
		// tu należy pamiętać żeby sprawdzać czy każdy constraint implementuje ConstraintInterface (innymi słowy używasz $this->setConstraint, który robi to za Ciebie)
	}
 
	public function setValue($field, $value) {
		// przypisywanie wartości polu
	}
 
	public function setValues(array $values) {
		// ... lub polom z tablicy
	}
 
	public function validate() {
		// ...
	}
 
	// ... inne metody, np. setter dla wiadomości dla wyjątków i takie tam
 
}
[PHP] pobierz, plaintext 

Teraz należy stworzyć interfejs dla przymusów:

[PHP] pobierz, plaintext 
interface ConstraintInterface {
 
	public function __construct();
	public function setValue($value);
	public function getValue();
	public function validate();
	// inne wedle życzenia...
 
}
[PHP] pobierz, plaintext 

Możemy teraz tworzyć dowolne przymusy implementując stworzony interfejs:

[PHP] pobierz, plaintext 
class Nip implements ConstraintInterface {
	// ...
}
 
class Length implements ConstraintInterface {
	// ...
}
 
// ... itd
[PHP] pobierz, plaintext 

I teraz możemy dowolnie manipulować przymusami dla dowolnych pól:

[PHP] pobierz, plaintext 
$validator = new Validator();
 
$validator->setFields(array(
		'name',
		'nip',
		'email'
	));
 
$validator->setConstraints('name', array(
	new NotEmpty(array(
		'message' => 'Imię nie może być puste'
	)),
	new Length(array(
		'min' => 3,
		'max' => 10,
		'minMessage' => 'Imię musi mieć minimum {{ min }} znaków',
		'maxMessage' => 'Imię musi mieć maximum {{ max }} znaków'
	))
));
 
$validator->setConstraints('nip', array(
	new NotEmpty(array(
		'message' => 'Nip nie może być pusty'
	)),
	new Nip(array(
		'message' => 'Nieprawidłowy NIP'
	))
));
 
$validator->setConstraints('email', array(
	new NotEmpty(array(
		'message' => 'E-mail nie może być pusty'
	)),
	new Email(array(
		'checkMX' => true,
		'message' => 'Nieprawidłowy adres e-mail'
	))
));
[PHP] pobierz, plaintext 

Wszystko pisane z palca, więc mogą być literówki, ale chodzi o zasadę działania. Budowa klockowa (IMG:style_emoticons/default/wink.gif)

Ten post edytował pyro 5.11.2013, 22:07:28