Skip to content

Latest commit

 

History

History
1208 lines (903 loc) · 35.1 KB

README.md

File metadata and controls

1208 lines (903 loc) · 35.1 KB

Build Status Coverage Status

Dieses Projekt enthält die Klasse Validation, mit der Formularübergaben anhand von Regelmengen überprüft werden können.

Verwendung

include_once dirname(__FILE__) . '/../Assistants/vendor/Validation/Validation.php';

// ab hier wird ein neuer Regelsatz für $_POST['action'] definiert,
// wobei das Feld nur die Werte 'SetPassword' und 'SetAccountInfo' haben darf
// oder nicht existieren darf (sodass es zu 'noAction' wird)
$val = Validation::open($_POST)
  ->addSet('action',
           array('set_default'=>'noAction',
                 'satisfy_in_list'=>array('noAction', 'SetPassword', 'SetAccountInfo'),
                 'on_error'=>array('type'=>'error',
                                   'text'=>'unbekannte Aktion'))); 
                                   
$result = $val->validate(); // liefert die Ergebnismenge

if ($val->isValid()){
    // $_POST['action'] erfüllt die Regelmenge und kann genutzt werden
    echo $result['action'];
} else {
  // wenn die Eingabe nicht validiert werden konnte, können hier die
  // Fehlermeldungen behandelt werden
  $notifications = $val->getNotifications();
}

Selektoren

Sie können mit diesen Funktionen die Elemente der Eingabe auswählen, welche dann die definierten Regeln erfüllen sollen. Dabei gibt es Selektoren mit den Präfixen key_ und elem_. key_ => wählt die ELemente anhand des Schlüssels (aus einem Array) elem_ => wählt die ELemente anhand des Wertes (aus einem Array)

Übersicht
key key_list key_all key_regex
key_numeric key_integer key_min_numeric key_max_numeric
key_starts_with key_union key_intersection

key

// Das Feld $_POST['elem'] soll ein gültiger md5-Hash sein.
$val = Validation::open($_POST);
$val->addSet(['key' => 'elem'],
             ['valid_md5']);

Man kann ['key' => 'elem'] auch als 'elem' schreiben.

key_list

// Die Felder a, b, und c aus $_POST sollen ein gültiger md5-Hash sein.
$val = Validation::open($_POST);
$val->addSet(['key_list' => ['a', 'b', 'c']],
             ['valid_md5']);

key_all

// Alle Elemente des Arrays $_POST['externalId'] sollen einen regulären Ausdruck erfüllen.
// Dazu wird das Array mit perform_this_array durchlaufen und bei der Auswahl der Felder
// sind dann alle (key_all) erlaubt.
$val = Validation::open($_POST);
$val->addSet('externalId',
             ['perform_this_array'=>[[['key_all'],
                                      ['satisfy_regex'=>'%^([a-zA-Z0-9_]+)$%']]]]);

key_regex

// Es werden die Felder aus $_POST ausgewählt, welche den Ausdruck %^([a-zA-Z0-9_]+)$% erfüllen.
$val = Validation::open($_POST);
$val->addSet(['key_regex' => '%^([a-zA-Z0-9_]+)$%'],
             ['valid_md5']);

key_numeric

// Es werden die Felder aus $_POST ausgewählt, welche vom Typ Integer sind oder eine Ganzzahl
// darstellen (als String).
$val = Validation::open($_POST);
$val->addSet(['key_numeric'],
             ['valid_md5']);

key_integer

// Es werden die Felder aus $_POST ausgewählt, welche vom Typ Integer sind.
$val = Validation::open($_POST);
$val->addSet(['key_integer'],
             ['valid_md5']);

key_min_numeric

// Es werden die Felder aus $_POST ausgewählt, welche mindestens den Schlüsselwert 100 besitzen.
$val = Validation::open($_POST);
$val->addSet(['key_min_numeric' => 100],
             ['valid_md5']);

key_max_numeric

// Es werden die Felder aus $_POST ausgewählt, welche maximal den Schlüsselwert 100 besitzen.
$val = Validation::open($_POST);
$val->addSet(['key_max_numeric' => 100],
             ['valid_md5']);

key_starts_with

// Es werden die Felder aus $_POST ausgewählt, deren Schlüssel mit abc beginnt.
$val = Validation::open($_POST);
$val->addSet(['key_starts_with' => 'abc'],
             ['valid_md5']);

key_union

// Es werden die Felder aus $_POST ausgewählt, deren Schlüssel mit aaa oder bbb beginnen.
$val = Validation::open($_POST);
$val->addSet(['key_union' => ['key_starts_with' => 'aaa',
                              'key_starts_with' => 'bbb']],
             ['valid_md5']);

key_intersection

// Es werden die Felder aus $_POST ausgewählt, welche mindestens den Schlüsselwert 100 besitzen und mit '2' beginnen.
$val = Validation::open($_POST);
$val->addSet(['key_intersection' => ['key_min_numeric' => '100',
                                     'key_starts_with' => '2']],
             ['valid_md5']);

Regeln

Übersicht
satisfy_exists satisfy_not_exists satisfy_required satisfy_isset
satisfy_not_isset satisfy_not_empty satisfy_empty satisfy_equals_field
satisfy_not_equals_field satisfy_regex satisfy_equalTo satisfy_min_numeric
satisfy_max_numeric satisfy_exact_numeric satisfy_min_len satisfy_max_len
satisfy_exact_len satisfy_in_list satisfy_not_in_list satisfy_value
satisfy_file_exists satisfy_file_isset satisfy_file_error satisfy_file_no_error
satisfy_file_extension satisfy_file_mime satisfy_file_size satisfy_file_name
satisfy_file_name_strict to_float to_string to_lower
to_upper to_integer to_boolean to_md5
to_sha1 to_base64 to_string_from_base64 to_object_from_json
to_array_from_json to_json to_timestamp on_error
on_no_error on_success logic_or perform_this_foreach
perform_foreach perform_this_array perform_array perform_switch_case
sanitize_url sanitize set_default set_copy
set_value set_field_value set_error valid_email
valid_url valid_url_query valid_regex valid_hash
valid_md5 valid_sha1 valid_identifier valid_user_name
valid_userName valid_timestamp valid_alpha valid_alpha_space
valid_integer valid_alpha_numeric valid_alpha_space_numeric valid_json
to_structure is_float is_boolean is_integer
is_string is_array

satisfy_exists

siehe satisfy_isset

satisfy_not_exists

siehe satisfy_not_isset

satisfy_required

siehe satisfy_isset

satisfy_isset

// das Feld $_POST['action'] muss gesetzt sein
$val = Validation::open($_POST);
$val->addSet('action',
             array('satisfy_isset'));

satisfy_not_isset

// das Feld $_POST['action'] darf nicht gesetzt sein
$val = Validation::open($_POST);
$val->addSet('action',
             array('satisfy_not_isset'));

satisfy_not_empty

// das Feld $_POST['action'] darf nicht leer sein
$val = Validation::open($_POST);
$val->addSet('action',
             array('satisfy_not_empty'));

siehe php:empty

satisfy_empty

// das Feld $_POST['action'] muss leer sein
$val = Validation::open($_POST);
$val->addSet('action',
             array('satisfy_empty'));

siehe php:empty

satisfy_equals_field

Aufbau
satisfy_equals_field=>param
Parameter Typ Beschreibung
param string der Bezeichner des Feldes, welches gleich sein soll 
// das Feld $_POST['newPasswordRepeat'] soll den selben Inhalt
// wie das Feld $_POST['newPassword'] haben
$val = Validation::open($_POST);
$val->addSet('newPasswordRepeat',
             array('satisfy_equals_field'=>'newPassword'));

satisfy_not_equals_field

Aufbau
satisfy_not_equals_field=>param
Parameter Typ Beschreibung
param string der Bezeichner des Feldes, welches nicht gleich sein soll 
// das Feld $_POST['deleteSheetWarning'] darf nicht den selben
// Inhalt wie das Feld $_POST['deleteSheet'] haben
$val = Validation::open($_POST);
$val->addSet('deleteSheetWarning',
             array('satisfy_not_equals_field'=>'deleteSheet'));

satisfy_regex

Aufbau
satisfy_regex => param
Parameter Typ Beschreibung
param string regulärer Ausdruck 
// das Feld $_POST['key'] muss den regulären Ausdruck
// %^([a-zA-Z0-9_]+)$% erfüllen
$val = Validation::open($_POST);
$val->addSet('key',
             array('satisfy_regex'=>'%^([a-zA-Z0-9_]+)$%'));

siehe php:PCRE

satisfy_equalTo

siehe satisfy_value

satisfy_min_numeric

Aufbau
satisfy_min_numeric => param
Parameter Typ Beschreibung
param string/integer/float Minimalwert 
// das Feld $_POST['field'] soll >= 0 sein
$val = Validation::open($_POST);
$val->addSet('field',
             array('satisfy_min_numeric'=>0));

satisfy_max_numeric

Aufbau
satisfy_max_numeric => param
Parameter Typ Beschreibung
param string/integer/float Maximalwert 
// das Feld $_POST['field'] soll <= 100 sein
$val = Validation::open($_POST);
$val->addSet('field',
             array('satisfy_max_numeric'=>100));

satisfy_exact_numeric

Aufbau
satisfy_exact_numeric => param
Parameter Typ Beschreibung
param string/integer/float Vergleichswert 
// das Feld $_POST['field'] soll genau 50 sein
$val = Validation::open($_POST);
$val->addSet('field',
             array('satisfy_exact_numeric'=>50));

satisfy_min_len

Aufbau
satisfy_min_len => param
Parameter Typ Beschreibung
param string/integer/float Mindestlänge 
// die Länge des Feldes $_POST['newPassword']
// soll >= 6 sein
$val = Validation::open($_POST);
$val->addSet('newPassword',
             array('satisfy_min_len'=>6));

satisfy_max_len

Aufbau
satisfy_max_len => param
Parameter Typ Beschreibung
param string/integer/float Maximallänge 
// die Länge des Feldes $_POST['newPassword']
// soll <= 255 sein
$val = Validation::open($_POST);
$val->addSet('newPassword',
             array('satisfy_max_len'=>255));

satisfy_exact_len

Aufbau
satisfy_exact_len => param
Parameter Typ Beschreibung
param string/integer/float Vergleichswert 
// die Länge des Feldes $_POST['newPassword']
// soll genau 8 sein
$val = Validation::open($_POST);
$val->addSet('newPassword',
             array('satisfy_exact_len'=>8));

satisfy_in_list

Aufbau
satisfy_in_list => param
Parameter Typ Beschreibung
param array(val0,val1, ... ) Liste der Vergleichswerte
val mixed Vergleichswerte 
// das Feld $_POST['action'] soll einen der
// Werte 'SetPassword' oder 'SetAccountInfo' enthalten
// und wenn es nicht gesetzt ist 'noAction'
$val = Validation::open($_POST);
$val->addSet('action',
             array('satisfy_in_list'=>array('noAction', 'SetPassword', 'SetAccountInfo')));

satisfy_not_in_list

Aufbau
satisfy_not_in_list => param
Parameter Typ Beschreibung
param array(val0,val1, ... ) Liste der Vergleichswerte
val mixed Vergleichswerte 
// das Feld $_POST['action'] darf nicht die Werte
// 'SetPassword' oder 'SetAccountInfo' haben
$val = Validation::open($_POST);
$val->addSet('action',
             array('satisfy_not_in_list'=>array('SetPassword', 'SetAccountInfo')));

satisfy_value

Aufbau
satisfy_value => param
Parameter Typ Beschreibung
param mixed Vergleichswert 
// das Feld $_POST['action'] muss den
// Wert -1 haben
$val = Validation::open($_POST);
$val->addSet('action',
             array('satisfy_value'=>'-1'));

satisfy_file_exists

// die hochgeladene Datei in $_FILES['MarkingFile']
// soll existieren
$val = Validation::open($_FILES);
$val->addSet('MarkingFile',
             ['satisfy_file_exists']);

siehe php:file_exists

satisfy_file_isset

// die notwendigen Felder der hochgeladenen Datei
// sollen in $_FILES['MarkingFile'] gesetzt sein
$val = Validation::open($_FILES);
$val->addSet('MarkingFile',
             ['satisfy_file_isset']);

satisfy_file_error





satisfy_file_no_error






satisfy_file_extension






Aufbau






satisfy_file_extension => param oder satisfy_file_extension => array(param,param,...)










Parameter
Typ
Beschreibung






param
string
Dateiendung






// die hochgeladene Datei in $_FILES['MarkingFile'] soll
// die Dateiendung .zip besitzen
$val = Validation::open($_FILES);
$val->addSet('MarkingFile',
             ['satisfy_file_extension'=>'zip']);




satisfy_file_mime






Aufbau






satisfy_file_mime => param  oder satisfy_file_mime => array(param,param,...)










Parameter
Typ
Beschreibung






param
string
Strukturtyp






// die hochgeladene Datei in $_FILES['MarkingFile'] soll
// den Strukturtyp application/zip haben
$val = Validation::open($_FILES);
$val->addSet('MarkingFile',
             ['satisfy_file_mime'=>'application/zip']);


siehe mime-Typen




satisfy_file_size


// nicht implementiert




satisfy_file_name






Aufbau






satisfy_file_name => param oder satisfy_file_name => array(param,param,...)










Parameter
Typ
Beschreibung






param
string
Dateiname






// die hochgeladene Datei in $_FILES['MarkingFile'] soll
// den Dateiname upload.zip haben
$val = Validation::open($_FILES);
$val->addSet('MarkingFile',
             ['satisfy_file_name'=>'upload.zip']);




satisfy_file_name_strict


// die hochgeladene Datei in $_FILES['MarkingFile'] darf
// im Dateinamen nur die Zeichen a-z,A-z,0-9 und .-_ enthalten
$val = Validation::open($_FILES);
$val->addSet('MarkingFile',
             ['satisfy_file_name_strict']);




to_float


// wandelt $_POST['field'] in eine Gleitkommazahl um
$val = Validation::open($_POST);
$val->addSet('field',
             ['to_float']);




to_string


// wandelt $_POST['field'] in einen String um
$val = Validation::open($_POST);
$val->addSet('field',
             ['to_string']);




to_lower


// wandelt $_POST['externalTypeName'] in
// Kleinbuchstaben um
$val = Validation::open($_POST);
$val->addSet('externalTypeName',
             ['to_lower']);




to_upper


// wandelt $_POST['externalTypeName'] in
// Großbuchstaben um
$val = Validation::open($_POST);
$val->addSet('externalTypeName',
             ['to_upper']);




to_integer


$val = Validation::open($_POST);
$val->addSet('externalType',
             ['to_integer',
              'satisfy_in_list' => [1,2]]);




to_boolean


$val = Validation::open($_POST);
$val->addSet('field',
             ['to_boolean']);




to_md5


// kodiert $_POST['field'] mittels md5
$val->addSet('field',
             ['to_md5');


siehe php:md5




to_sha1


// kodiert $_POST['field'] mittels sha1
$val->addSet('field',
             ['to_sha1');


siehe php:sha1




to_base64


// kodiert $_POST['field'] mittels base64
$val->addSet('field',
             ['to_base64');


siehe php:base64_encode




to_string_from_base64


// wandelt das base64 kodierte Feld $_POST['field']
// in einen String um
$val->addSet('field',
             ['to_string_from_base64');


siehe php:base64_decode




to_object_from_json






to_array_from_json






to_json


// $_POST['elem'] soll im json-Format serialisiert werden
$val = Validation::open($_POST);
$val->addSet('elem',
             array('to_json'));


siehe php:json_encode




to_timestamp


// $_POST['startDate'] soll in einen unix-Zeitstempel umgewandelt werden
$val = Validation::open($_POST);
$val->addSet('startDate',
             array('satisfy_exists',
                   'to_timestamp'));




on_error






Aufbau






on_error => array(type,text,abortSet)










Parameter
Typ
Beschreibung
Vorgabewert






type (optional)
string
Bezeichner für den Meldungstyp (Bsp.: warning, error oder message)
message




text (optional)
string
Meldungstext





abortSet (optional)
bool
true = im Fehlerfall die Validierung beenden, false = sonst
true






// das Feld $_POST['action'] soll existieren, ansonsten
// soll eine Fehlermeldung generiert werden
$val = Validation::open($_POST);
$val->addSet('action',
             array('satisfy_exists',
                   'on_error'=>array('type'=>'error',
                                     'text'=>'unbekannte Aktion')));




on_no_error


siehe on_success




on_success






Aufbau






on_error => array(type,text,abortSet)










Parameter
Typ
Beschreibung
Vorgabewert






type (optional)
string
Bezeichner für den Meldungstyp (Bsp.: warning, error oder message)
message




text (optional)
string
Meldungstext





abortSet (optional)
bool
true = im Fehlerfall die Validierung beenden, false = sonst
false






// wenn das Feld $_POST['action'] existiert, soll eine
// Erfolgsmeldung erzeugt werden (kein Abbruch)
$val = Validation::open($_POST);
$val->addSet('action',
             array('satisfy_exists',
                   'on_success'=>array('text'=>'Aktion existiert')));




logic_or


// das Feld $_POST['key'] darf entweder ein gültiger identifier
// oder der leere String sein
$val = Validation::open($_POST);
$val->addSet('key',
             array('logic_or'=>[['satisfy_value'=>''],
                                ['valid_identifier']]));




perform_this_foreach


// alle Schlüssel des Arrays $_POST['approvalCondition'] sollen gültige
// identifier sein und alle darin enthaltenen Elemente zwischen
// 0 und 100 liegen
$val = Validation::open($_POST);
$val->addSet('approvalCondition',
             array('set_default'=>array(),
                   'perform_this_foreach'=>[['key',
                                             ['valid_identifier']],
                                            ['elem',
                                             ['to_integer',
                                              'satisfy_min_numeric'=>0,
                                              'satisfy_max_numeric'=>100]]]));




perform_foreach






perform_this_array


// die Elemente des Arrays $_POST['proposal'] sollen
// gültige identifier sein
$val = Validation::open($_POST);
$val->addSet('proposal',
             ['perform_this_array'=>[[['key_all'],
                                      ['valid_identifier']]]]);




perform_array






perform_switch_case


// es sollen die Felder $_POST['elem']['proposal'] und
// $_POST['elem']['marking'] geprüft werden
$val = Validation::open($_POST);
$val->addSet('elem',
             ['perform_switch_case'=>[['proposal',
                                       [...]],
                                      ['marking',
                                       [...]]]]);




sanitize_url


// die URL in $_POST['url'] wird mit filter_var($elem, FILTER_SANITIZE_URL) behandelt
$val = Validation::open($_POST);
$val->addSet('url',
             array('sanitize_url'));


siehe php:empty




sanitize


// alle Elemente in $_GET werden bereinigt, mit htmlspecialchars(trim($elem), ENT_QUOTES, 'UTF-8') 
$val = Validation::open($_GET, array('preRules'=>array('sanitize')));




set_default


// wenn der Wert $_POST['action'] nicht gesetzt ist
// soll er 'noAction' sein
$val = Validation::open($_POST);
$val->addSet('action',
             array('set_default'=>'noAction'));




set_copy


// erstellt das Feld $_POST['newField'] und kopiert
// dort $_POST['oldField'] hinein
$val = Validation::open($_POST);
$val->addSet('oldField',
             array('set_copy'=>'newField'));




set_value


// setzt den Wert des Feldes $_POST['field']
// auf 1234
$val = Validation::open($_POST);
$val->addSet('field',
             array('set_value'=>'1234'));




set_field_value


// setzt den Wert des Feldes $_POST['field']
// auf $_POST['otherField']
$val = Validation::open($_POST);
$val->addSet('field',
             array('set_field_value'=>'otherField'));




set_error


// es wird das Feld $_POST['field'] ausgewählt und anschließend die 
// Validierung abgebrochen (kann auch auf false gesetzt werden).
// Dabei ignorieren manche Befehle diesen Fehlerwert und werden trotzdem ausgeführt
// (Bsp.: Fehlermeldungen).

$val = Validation::open($_POST);
$val->addSet('field',
             array('set_error'=>true));




valid_email


// das Feld $_POST['email'] soll eine gültige EMail-Adresse enthalten
$val = Validation::open($_POST);
$val->addSet('email',
                   ['valid_email']);




valid_url


// das Feld $_POST['back'] soll eine gültige URL enthalten
$val = Validation::open($_POST);
$val->addSet('back',
                   ['valid_url']);


siehe php:empty




valid_url_query


// das Feld $_POST['back'] soll eine gültige, relative URL enthalten
$val = Validation::open($_POST);
$val->addSet('back',
                   ['valid_url_query']);




valid_regex


// das Feld $_POST['regex'] soll einen gültigen regulären Ausdruck enthalten
$val = Validation::open($_POST);
$val->addSet('regex',
                   ['valid_regex']);


siehe php:empty
Es wird der Filter FILTER_VALIDATE_REGEXP verwendet.




valid_hash


// das Feld $_POST['hash'] soll einen gültigen Hashwert enthalten
$val = Validation::open($_POST);
$val->addSet('hash',
                   ['valid_hash']);




valid_md5


// das Feld $_POST['hash'] soll einen gültigen md5-Hashwert enthalten
$val = Validation::open($_POST);
$val->addSet('hash',
                   ['valid_md5']);




valid_sha1


// das Feld $_POST['hash'] soll einen gültigen sha1-Hashwert enthalten
$val = Validation::open($_POST);
$val->addSet('hash',
                   ['valid_sha1']);




valid_identifier


// das Feld $_POST['sortId'] darf nur 0-9 und _ enthalten
$val = Validation::open($_POST);
$val->addSet('sortId',
             array('valid_identifier'));




valid_user_name


siehe valid_userName




valid_userName






valid_timestamp


siehe valid_integer




valid_alpha


// das Feld $_POST['elem'] darf nur a-z, A-Z und Leerzeichen enthalten
$val = Validation::open($_POST);
$val->addSet('elem',
             array('valid_alpha'));




valid_alpha_space


// das Feld $_POST['elem'] darf nur a-z und A-Z enthalten
$val = Validation::open($_POST);
$val->addSet('elem',
             array('valid_alpha_space'));




valid_integer


// das Feld $_POST['elem'] darf nur 0-9 enthalten
$val = Validation::open($_POST);
$val->addSet('elem',
             array('valid_integer'));




valid_alpha_numeric


// das Feld $_POST['elem'] darf nur 0-9, a-z und A-Z enthalten
$val = Validation::open($_POST);
$val->addSet('elem',
             array('valid_alpha_numeric'));




valid_alpha_space_numeric


// das Feld $_POST['elem'] darf nur 0-9, a-z, A-Z und Leerzeichen enthalten
$val = Validation::open($_POST);
$val->addSet('elem',
             array('valid_alpha_space_numeric'));




valid_json


// das Feld $_POST['elem'] muss gültiges json enthalten
$val = Validation::open($_POST);
$val->addSet('elem',
             array('valid_json'));




to_structure






is_float


// das Feld $_POST['elem'] soll vom Typ float sein oder sich darin umwandeln lassen
$val = Validation::open($_POST);
$val->addSet('elem',
             array('is_float'));




is_boolean


// das Feld $_POST['elem'] soll einen gültigen Wahrheitswert darstellen
$val = Validation::open($_POST);
$val->addSet('elem',
             array('is_boolean'));




is_integer


// das Feld $_POST['elem'] soll einen gültigen Zahlwert darstellen oder darin umgewandelt werden können
$val = Validation::open($_POST);
$val->addSet('elem',
             array('is_integer'));




is_string


// das Feld $_POST['elem'] soll einen gültigen String darstellen
$val = Validation::open($_POST);
$val->addSet('elem',
             array('is_string'));




is_array


// das Feld $_POST['rights'] muss ein Array sein
$val = Validation::open($_POST);
$val->addSet('rights',
             array('is_array'));