Verificare Form

Nu trebuie sa folosesti un intreg framework ca sa obtii ceea ce doresti. Daca stii ce sa cauti, desigur. Asa arata procesatorul meu "universal" de formulare (poti folosi clasa pentru ca framework-ul dezvoltat de mine din care face parte libraria este gratuit, atata timp cat raman comentariile din codul sursa asa cum sunt):

<?php
/**
 * The form validation class
 *
 * @todo add support for multiple worker objects and cache their metadata upon initialization (using the Reflection API), so we don't have to go through all worker objects when validating fields
 * @todo remove the need of having a variable named $_evalResult in eval() rules
 *
 * @package FWCORE
 * @subpackage Libraries
 * @author Vali Dumitru <vali [dot] dumitru [at] webgearsoftware [dot] com>
 * @copyright Web Gear Software
 */

/**
 * The form validation class
 *
 * @todo add support for multiple worker objects and cache their metadata upon initialization (using the Reflection API), so we don't have to go through all worker objects when validating fields
 * @todo remove the need of having a variable named $_evalResult in eval() rules
 *
 * @package FWCORE
 * @subpackage Libraries
 * @author Vali Dumitru <vali [dot] dumitru [at] webgearsoftware [dot] com>
 * @copyright Web Gear Software
 */
class FormValidator
{
    /**
     * The request data passed in for validation
     *
     * @var array
     */
    protected $_data = null;

    /**
     * The filtering rules
     *
     * @var array
     */
    protected $_filters = null;

    /**
     * The errors resulted from the last validation
     *
     * @var array
     */
    protected $_errors = null;

    /**
     * The worker object to be used in evaluations (if any)
     *
     * @var object
     */
    protected $_worker = null;

    /**
     * The last validation status (so that we don't reprocess the form
     * during the same request through the call of the FormValidator::validate() method)<br />
     * This is only used internally, as some sort of caching mechanism
     *
     * @var bool
     */
    protected $_validated = null;

    /**
     * The public status of the last validation
     *
     * @var bool
     */
    protected $_status = null;

    /**
     * Represents the 'failed' state
     *
     * @var int
     */
    const STATUS_FAILED = -2;

    /**
     * Represents the 'no data' state
     *
     * @var int
     */
    const STATUS_NO_DATA = -1;

    /**
     * Represents the 'success' state
     *
     * @var int
     */
    const STATUS_SUCCESS = 1;

    /**
     * Alphanumerical filter
     *
     * @var string
     */
    const FILTER_ALNUM = '^[a-zA-Z0-9\-_]+$';

    /**
     * Letters-only filter
     *
     * @var string
     */
    const FILTER_LETTERS_ONLY = '^[a-zA-Z]+$';

    /**
     * Numbers-only filter
     *
     * @var string
     */
    const FILTER_NUMBERS_ONLY = '^[0-9]+$';

    /**
     * Sets the request data
     *
     * @see FormValidation::$_data
     *
     * @param array $data The data, formed as a single dimensional array
     *
     * @return FormValidation
     */
    public function setData($data = array())
    {
        $this->_data = (array) $data;

        return $this;
    }

    /**
     * Sets the filtering rules
     *
     * @see FormValidation::$_filters
     *
     * @param array $filters The filtering rules array
     *
     * @return FormValidation
     */
    public function setFilters($filters = array())
    {
        $this->_filters = (array) $filters;

        return $this;
    }

    /**
     * Sets the worker object
     *
     * @see FormValidation::$_worker
     *
     * @param array $worker The worker object to be used
     *
     * @return FormValidation
     */
    public function setWorker($worker = null)
    {
        if($worker !== null && is_object($worker) === false)
        {
            throw new Exception('Invalid worker object in FormValidator::setWorker().');
        }

        $this->_worker = $worker;

        return $this;
    }

    /**
     * Returns the errors resulted from the validation
     *
     * @see FormValidation::$_errors
     *
     * @return array An array of the resulting errors, grouped by names
     */
    public function getErrors()
    {
        if($this->_validated === false)
        {
            throw new Exception('Invalid call to FormValidator::getStatus() -- data not processed yet.');
        }

        return $this->_errors;
    }

    /**
     * Returns request data
     *
     * @see FormValidation::$_data
     *
     * @param mixed $name null or a string
     *
     * @return mixed If $name is a string, only the value for the request parameter with that name will be retrieved
     */
    public function getData($name = null)
    {
        if($name !== null && $name !== false && array_key_exists($name, $this->_data) === true)
        {
            return $this->_data[$name];
        }

        return $this->_data;
    }

    /**
     * Returns filtering rules
     *
     * @see FormValidation::$_filters
     *
     * @param mixed $name null or a string
     *
     * @return mixed If $name is a string, only the rules for that specific parameter will be returned
     */
    public function getFilters($name = null)
    {
        if($name !== null && $name !== false && array_key_exists($name, $this->_filters) === true)
        {
            return $this->_filters[$name];
        }

        return $this->_filters;
    }

    /**
     * Returns the worker object
     *
     * @see FormValidation::$_worker
     *
     * @return mixed If the worker has been set, an object, null otherwise
     */
    public function getWorker()
    {
        return $this->_worker;
    }

    /**
     * Returns the status of the last validation operation<br />
     * Throws LibrarySystemException
     *
     * @see FormValidation::$_status
     *
     * @return int The status of the last validation operation
     */
    public function getStatus()
    {
        if($this->_validated === false)
        {
            throw new Exception('Invalid call to FormValidator::getStatus() -- data not processed yet.');
        }

        return $this->_status;
    }

    /**
     * Retrieves the full list of field values, completed with the default value, if no other value was set
     *
     * @return array
     */
    public function getFieldValues()
    {
        $_arr = array();
        $_data = $this->getData();

        if(count($_data) > 0)
        {
            foreach($_data as $_k => $_v)
            {
                if(($_v === null || $_v === '' || $_v === false) && array_key_exists($_k, $this->_filters) === true && array_key_exists('default', $this->_filters[$_k]) === true)
                {
                    $_arr[$_k] = $this->_filters[$_k]['default'];
                }
                else
                {
                    $_arr[$_k] = $_v;
                }
            }
        }

        return $_arr;
    }

    /**
     * The constructor. Allows passing in all the parameters right at construction time<br />
     * Throws LibrarySystemException
     *
     * @see FormValidation::$_data
     * @see FormValidation::$_filters
     * @see FormValidation::$_worker
     *
     * @param array $data (optional) The data to process
     * @param array $filters (optional) The filters to apply
     * @param object $worker (optional) The object to use as the worker
     */
    public function __construct($data = array(), $filters = array(), $worker = null)
    {
        $this   ->setData($data)
                ->setFilters($filters)
                ->setWorker($worker);

        $this->_validated = false;
        $this->_errors = array();
        $this->_status = false;
    }

    /**
     * Attempts validation of the form
     *
     * @return int The status of the validation process
     */
    public function validate()
    {
        //--------------------------------------------------------------------------
        // If the request has been previously validated on this request,
        // just return the status of the last operation
        //--------------------------------------------------------------------------
        if($this->_validated === true)
        {
            return $this->getErrors();
        }

        $_data = $this->getData();
        $_filters = $this->getFilters();

        $_all_fields = array_keys($_filters);
        $_passed_fields = array();

        $_data_count = count($_data);
        $_filters_count = count($_filters);

        $this->_validated = true;

        //--------------------------------------------------------------------------
        // No rules, no game
        //--------------------------------------------------------------------------
        if($_filters_count == 0)
        {
            $this->_status = self::STATUS_SUCCESS;

            return $this->getStatus();
        }

        //--------------------------------------------------------------------------
        // No data present, while filters are
        //--------------------------------------------------------------------------
        if($_data_count == 0 && $_filters_count > 0)
        {
            $this->_status = self::STATUS_NO_DATA;

            return $this->getStatus();
        }

        //--------------------------------------------------------------------------
        // ...iterate over the filters
        //--------------------------------------------------------------------------
        foreach($_filters as $_name => $_filter)
        {
            $_tmp_errors = array();
            $continue = true;

            if(array_key_exists($_name, $_data) === true)
            {
                //--------------------------------------------------------------------------
                // ...and begin to apply them
                //--------------------------------------------------------------------------
                $_data_type = gettype($_data[$_name]);

                //--------------------------------------------------------------------------
                // Required field
                //--------------------------------------------------------------------------
                if(array_key_exists('required', $_filter) === true)
                {
                    if($_filter['required']['value'] === true)
                    {
                        if($_data[$_name] == '')
                        {
                            $_tmp_errors[] = $_filter['required']['message'];

                            $continue = false;
                        }
                    }
                }

                //--------------------------------------------------------------------------
                // Length restrictions
                // These 2 rules only apply to strings
                //--------------------------------------------------------------------------
                if($continue === true)
                {
                    if($_data_type == 'string')
                    {
                        if(array_key_exists('length', $_filter) === true)
                        {
                            if(array_key_exists('min', $_filter['length']) === true)
                            {
                                if(strlen($_data[$_name]) < $_filter['length']['min']['value'])
                                {
                                    $_tmp_errors[] = $_filter['length']['min']['message'];

                                    $continue = false;
                                }
                            }

                            if($continue === true)
                            {
                                if(array_key_exists('max', $_filter['length']) === true)
                                {
                                    if(strlen($_data[$_name]) > $_filter['length']['max']['value'])
                                    {
                                        $_tmp_errors[] = $_filter['length']['max']['message'];

                                        $continue = false;
                                    }
                                }
                            }
                        }
                    }
                }

                //--------------------------------------------------------------------------
                // Value restrictions
                // min and max only apply to integers
                //--------------------------------------------------------------------------
                if($continue === true)
                {
                    if(array_key_exists('value', $_filter) === true)
                    {
                        if(in_array($_data_type, array('double', 'float', 'int', 'integer', 'real')) === true)
                        {
                            if(array_key_exists('min', $_filter['value']) === true)
                            {
                                if($_data[$_name] < $_filter['value']['min']['value'])
                                {
                                    $_tmp_errors[] = $_filter['value']['min']['message'];

                                    $continue = false;
                                }
                            }

                            if($continue === true)
                            {
                                if(array_key_exists('max', $_filter['value']) === true)
                                {
                                    if($_data[$_name] > $_filter['value']['max']['value'])
                                    {
                                        $_tmp_errors[] = $_filter['value']['max']['message'];

                                        $continue = false;
                                    }
                                }
                            }
                        }

                        //--------------------------------------------------------------------------
                        // This rule applies both to integer and string values
                        //--------------------------------------------------------------------------
                        if($continue === true)
                        {
                            if(array_key_exists('fixed', $_filter['value']) === true)
                            {
                                if($_data[$_name] != $_filter['value']['fixed']['value'])
                                {
                                    $_tmp_errors[] = $_filter['value']['fixed']['message'];

                                    $continue = false;
                                }
                            }
                        }
                    }
                }

                //--------------------------------------------------------------------------
                // Are there any REGEX rules that need to be matched?
                //--------------------------------------------------------------------------
                if($continue === true)
                {
                    if(array_key_exists('regex', $_filter) === true)
                    {
                        $_rules = $_filter['regex']['rules'];
                        $_messages = $_filter['regex']['messages'];

                        if(count($_rules) > 0)
                        {
                            foreach($_rules as $_ridx => $_rule)
                            {
                                $_last_slash_pos = strrpos($_rule, '/');

                                if($_last_slash_pos === false)
                                {
                                    $_last_slash_pos = strrpos($_rule, '#');
                                }

                                if($_last_slash_pos === false)
                                {
                                    $_rule = '/' . $_rule . '/';
                                }

                                if(preg_match($_rule, $_data[$_name]) == 0)
                                {
                                    $_tmp_errors[] = $_messages[$_ridx];

                                    $continue = false;
                                }
                            }
                        }
                    }
                }

                //--------------------------------------------------------------------------
                // Any expressions to evaluate to help the result being positive?
                //--------------------------------------------------------------------------
                if($continue === true)
                {
                    if(array_key_exists('eval', $_filter) === true)
                    {
                        $_instructions = $_filter['eval']['instructions'];
                        $_messages = $_filter['eval']['messages'];

                        if(count($_instructions) > 0)
                        {
                            foreach($_instructions as $_iidx => $_instruction)
                            {
                                ob_start();
                                $_worker = $this->getWorker();
                                eval($_instruction);
                                ob_end_clean();

                                if($_evalResult == false)
                                {
                                    $_tmp_errors[] = $_messages[$_iidx];

                                    $continue = false;
                                }
                            }
                        }
                    }
                }

                if($continue === true) $_passed_fields[] = $_name;
            }
            else
            {
                //--------------------------------------------------------------------------
                // Filter rule encountered, but no data present
                //--------------------------------------------------------------------------
                throw new Exception('Missing request parameter ' . $_name . '.');
            }

            //--------------------------------------------------------------------------
            // If we had errors, then we have to store those
            //--------------------------------------------------------------------------
            if(count($_tmp_errors) > 0)
            {
                $this->_errors[$_name] = $_tmp_errors[0];
                $this->_status = self::STATUS_FAILED;
            }
        }

        $_passed = false;

        foreach($_all_fields as $_value)
        {
            if(in_array($_value, $_passed_fields) === false)
            {
                $this->_status = self::STATUS_FAILED;
                break;
            }
            else
            {
                if($_passed === false) $_passed = 0;

                $_passed++;
            }
        }

        if($_passed == count($_all_fields))
        {
            $this->_status = self::STATUS_SUCCESS;
        }

        return $this->getStatus();
    }
}

Iar asta este un tip de fisier de configurare (evident, poti folosi orice combinatii doresti dintre toate filtrele astea):

<?php

$forms_config = array(
	'input_name_you_want_to_validate' => array(
		'default' => 'Enter your name here',
		'currentValue' => '', // this is usually here for later customizations, just use it if you need
		'required' => array(
			'value' => true, // or false
			'message' => 'Sorry, you cannot pass until you enter your name.'
		),
		// value-related restrictions
		'value' => array(
			'min' => array(
				'value' => 3,
				'message' => 'The number must be greater than 3.'
			),
			'max' => array(
				'value' => 5,
				'message' => 'The number must be lower than 5.'
			),
			'equal' => array(
				'value' => 4,
				'message' => 'The number must be exactly 4.'
			)
		),
		'length' => array(
			'min' => array(
				'value' => 1,
				'message' => 'The string must contain at least one character.'
			),
			'max' => array(
				'value' => 20,
				'message' => 'The string cannot contain more than 20 characters.'
			),
			'equal' => array(
				'value' => 15,
				'message' => 'The string must be exactly 15 characters long.'
			)
		),
		'regex' => array(
			'rules' => array(
				'^[a-zA-Z\-]+$',
				// ... keep adding if you need
			),
			'messages' => array(
				'first regex invalid message',
				// ... messages for other rules
			)
		),
		'eval' => array(
            'instructions' => array(
                '$_evalResult = (1 == 2 || 4 == 5);',
                '$_evalResult = ($_workerObject->some_property + $_workerObject->another_property == 7);'
                // $_workerObject can be an object passed to the validate() method in the FormValidator class
            ),
            'messages' => array(
                'first eval error message (if either of 1==2 or 4==5 conditions are false)',
                'second eval error message (you get the idea)'
            )
        )
	)
);

return $forms_config

Si un exemplu de lucru:

<?php

require_once 'FormValidator.php'; // clasa de mai sus

$rules = require 'forms_config.php'; // regulile de configurare

// Acest obiect il vom folosi ca "ajutor" pentru validare. Evident, poate sa fie orice tip de obiect, si sa contina o multime de metode...
$workerObject = new stdClass();
$workerObject->some_property = 2;
$workerObject->another_property = 9;

$validator = new FormValidator($_POST, $rules, $workerObject); // initiem validatorul; daca nu vreti sa folositi obiect ajutator, nu mai puneti deloc ultimul parametru
if($validator->validate() == FormValidator::STATUS_SUCCESS) {// validam formularul
    // formularul este valid, mesaj succes
} else {
    // erori & stuff
}

Iti recomand sa te uiti si prin codul sursa al clasei, pentru ca este bine comentat, si poate iti faci chiar tu propriul validator, daca nu gasesti nimic pe plac :-)

error.ro forum: Verificare Form - error.ro forum

#1 root

#2 Night

#3 root

#4 Razvan20CM

#5 root

#6 styll

#7 root

#8 Xenon

1 User(s) are reading this topic
0 members, 1 guests, 0 anonymous users

Skin and Language

Execution Stats

error.ro forum: Verificare Form - error.ro forum

Verificare Form

1 User(s) are reading this topic 0 members, 1 guests, 0 anonymous users

Skin and Language

Execution Stats

1 User(s) are reading this topic
0 members, 1 guests, 0 anonymous users