Utiliser un plugin existant pour insérer de nouveaux tests de validation :

- taille d'une chaîne de caractère
- is numérique ?
- téléphone français
- date (fonction du format voulu)
- email dispo en base SPIP ?
- validation email plus "stricte" que celle de SPIP
- SIREN/SIRET
- URL

A peaufiner, améliorer, c'est le but ! :)

.gitattributes

@@ -3,6 +3,15 @@ inc/verifier.php -text
 lang/verifier_fr.php -text
 /plugin.xml -text
 test/verifier.html -text
+verifier/date.php -text
 verifier/email.php -text
+verifier/email_disponible.php -text
+verifier/email_strict.php -text
 verifier/entier.php -text
+verifier/numerique.php -text
 verifier/regex.php -text
+verifier/siren.php -text
+verifier/siret.php -text
+verifier/taille.php -text
+verifier/telephone_fr.php -text
+verifier/url.php -text

lang/verifier_fr.php

@@ -4,12 +4,22 @@
 if (!defined("_ECRIRE_INC_VERSION")) return;
 
 $GLOBALS[$GLOBALS['idx_lang']] = array(
+'erreur_date' => "Le format de la date n'est pas accepté.",
 'erreur_email' => 'L\'adresse de courriel n\'a pas un format valide.',
+'erreur_email_nondispo'=>"L'adresse de courriel est déjà enregistré.",
 'erreur_entier' => 'La valeur doit être un entier.',
 'erreur_entier_entre' => 'La valeur doit être comprise entre @min@ et @max@.',
 'erreur_entier_max' => 'La valeur doit être inférieure à @max@.',
 'erreur_entier_min' => 'La valeur doit être suppérieure à @min@.',
-'erreur_regex' => 'Le format de la chaîne n\'est pas valide.'
+'erreur_numerique' => 'Le format du nombre n\'est pas valide.',
+'erreur_regex' => 'Le format de la chaîne n\'est pas valide.',
+'erreur_siren' => 'Le numéro de SIREN n\'est pas valide.',
+'erreur_siret' => 'Le numéro de SIRET n\'est pas valide.',
+'erreur_taille_entre' => 'La valeur doit comprendre entre @min@ et @max@ caractères.',
+'erreur_taille_max' => 'La valeur doit comprendre au maximum @max@ caractères.',
+'erreur_taille_min' => 'La valeur doit comprendre au minimum @min@ caractères.',
+'erreur_telephone' => "Le numéro n'est pas valide.",
+'erreur_url' => "L'adresse n\'est pas valide."
 );
 
 ?>

test/verifier.html

@@ -22,7 +22,7 @@ var_dump(verifier($un_autre_mot, 'regex', array('modele'=>$modele)));
 </pre>
 
 <h2>Vérifions des entiers :</h2>
-</pre>
+<pre>
 <?php
 
 $un_entier = 568;
@@ -40,19 +40,110 @@ var_dump(verifier($un_autre_entier, 'entier', array('min'=>-100, 'max'=>-50)));
 ?>
 </pre>
 
-<h2>Vérifions des emails :</h2>
+<h2>V&eacute;rifions une taille d'une cha&icirc;ne :</h2>
+<pre>
+<?php
+
+$une_chaine = "123456";
+$un_autre_chaine = "abc";
+
+echo "$une_chaine de 1 à 3 caractères ?";
+var_dump(verifier($une_chaine, 'taille', array('min'=>1, 'max'=>3)));
+echo "$une_chaine 5 caractères max ?";
+var_dump(verifier($une_chaine, 'taille', array('max'=>5)));
+echo "$une_chaine 4 caractères mini ?";
+var_dump(verifier($une_chaine, 'taille', array('min'=>4)));
+echo "$un_autre_chaine de 1 à 3 caractères ?";
+var_dump(verifier($un_autre_chaine, 'taille', array('min'=>1, 'max'=>3)));
+echo "$un_autre_chaine 5 caractères max ?";
+var_dump(verifier($un_autre_chaine, 'taille', array('max'=>5)));
+echo "$un_autre_chaine 4 caractères mini ?";
+var_dump(verifier($un_autre_chaine, 'taille', array('min'=>4)));
+
+?>
 </pre>
+
+
+<h2>Vérifions des emails :</h2>
+<pre>
 <?php
 
 $email = "test@test.fr";
-$email2 = "test";
+$email2 = "test@b";
+$email3 = "test";
 
-echo "$email ?";
+echo "Valide SPIP : $email ?";
 var_dump(verifier($email, 'email'));
-echo "$email2 ?";
+echo "Valide SPIP : $email2 ?";
 var_dump(verifier($email2, 'email'));
+echo "Valide SPIP : $email3 ?";
+var_dump(verifier($email3, 'email'));
+
+echo "Valide Strict : $email ?";
+var_dump(verifier($email, 'email_strict'));
+echo "Valide Strict : $email2 ?";
+var_dump(verifier($email2, 'email_strict'));
+echo "Valide Strict : $email3 ?";
+var_dump(verifier($email3, 'email_strict'));
+
 
 ?>
 </pre>
+
+<h2>Vérifions des téléphones :</h2>
+<pre>
+<?php
+
+$telephone = "01.01/01-02 03";
+$telephone2 = "090909";
+$telephone3 = "10 01 01 01 01";
+
+echo "Téléphone : $telephone ?";
+var_dump(verifier($telephone, 'telephone_fr'));
+echo "Téléphone : $telephone2 ?";
+var_dump(verifier($telephone2, 'telephone_fr'));
+echo "Téléphone : $telephone3 ?";
+var_dump(verifier($telephone3, 'telephone_fr'));
+
+
+?>
+</pre>
+
+
+<h2>Vérifions des SIREN/SIRET :</h2>
+<pre>
+<?php
+
+$siren_valide = "321227852";
+$siren_non_valide = "321227822";
+$siret_valide = "32122785200019";
+$siret_non_valide = "32122785200033";
+
+echo "SIREN : $siren_valide ?";
+var_dump(verifier($siren_valide, 'siren'));
+echo "SIREN : $siren_non_valide ?";
+var_dump(verifier($siren_non_valide, 'siren'));
+
+echo "SIRET : $siret_valide ?";
+var_dump(verifier($siret_valide, 'siret'));
+echo "SIRET : $siret_non_valide ?";
+var_dump(verifier($siret_non_valide, 'siret'));
+?>
+</pre>
+
+<h2>Vérifions des DATES :</h2>
+<pre>
+<?php
+$date_valide = "30/01/2009";
+$date_non_valide = "321227822";
+
+echo "Date JJ/MM/AAAA : $date_valide ?";
+var_dump(verifier($date_valide, 'date'));
+echo "Date JJ/MM/AAAA : $date_non_valide ?";
+var_dump(verifier($date_non_valide, 'date'));
+?>
+</pre>
+
+
 </body>
 </html>

verifier/date.php

+<?php
+
+// Sécurité
+if (!defined("_ECRIRE_INC_VERSION")) return;
+
+/**
+ * Une date au format JJ/MM/AAAA
+ * TODO : introduire via les options le FORMAT de la date, pour accepter différentes écritures
+ * On pourrait faire mieux, genre vérifier les jours en fonction du mois
+ * Mais c'est pas très important, on reste simple
+ */
+
+function verifier_date_dist($valeur, $options=array()){
+	$erreur = _T('verifier:erreur_date');
+	$ok = '';
+	
+	// On vérifie la validité du format
+	if(!preg_match('#^[0-9]{2}/[0-9]{2}/[0-9]{4}$#',$valeur)) return $erreur;
+	// On vérifie vite fait que les dates existent, genre le 32 pour un jour NON, (mais on pourrait aller plus loin et vérifier en fonction du mois)
+	list($jour,$mois,$annee) = explode('/',$valeur);
+	if(($jour > 31)|| ($jour < 1) || ($mois > 12) || ($mois < 1) || ($annee < 1800)) return $erreur; // 1800, je crois qu'avant les gens ne sont plus vivants °_°
+	
+	return $ok;
+}

verifier/email_disponible.php

+<?php
+
+// Sécurité
+if (!defined("_ECRIRE_INC_VERSION")) return;
+
+/**
+ * Vérifier que le courriel utilisé n'est pas
+ * déjà présent en base SPIP_AUTEURS
+ */
+function verifier_email_disponible_dist($valeur, $options=array()){
+	include_spip('base/abstract_sql');
+	$erreur = _T('verifier:erreur_email_nondispo');
+	$ok = '';
+
+	$emailDejaUtilise = sql_getfetsel("id_auteur", "spip_auteurs", "email='".$valeur."'");
+	if($emailDejaUtilise) return $erreur;
+	
+	return $ok;
+}

verifier/email_strict.php

+<?php
+
+// Sécurité
+if (!defined("_ECRIRE_INC_VERSION")) return;
+
+/**
+ * Changement de la RegExp d'origine
+ * Non respect des RFC beaucoup trop souples à mon sens
+ * On INTERDIT les mails dont les domaines ne sont pas "valides"
+ * On INTERDIT les adresses qui comportent autre chose que des tirets / tirets bas / point
+ * (même si les autres caractères sont autorisés, tant pis, ils sont trop rares)
+ */
+function verifier_email_strict_dist($valeur, $options=array()){
+	$erreur = _T('verifier:erreur_email');
+	$ok = '';
+
+	// Si c'est un spammeur autant arreter tout de suite
+	if (preg_match(",[\n\r].*(MIME|multipart|Content-),i", $valeur)) {
+		spip_log("Tentative d'injection de mail : $valeur");
+		return $erreur;
+	}
+	foreach (explode(',', $valeur) as $v) {
+		// nettoyer certains formats
+		// "Marie Toto <Marie@toto.com>"
+		$adresse = trim(preg_replace(",^[^<>\"]*<([^<>\"]+)>$,i", "\\1", $v));
+		// NOUVELLE REGEXP NE RESPECTANT PLUS RFC 822 MAIS MOINS TOLERANTE
+		if (!preg_match('/^([A-Za-z0-9]){1}([A-Za-z0-9]|-|_|\.)*@[A-Za-z0-9]([A-Za-z0-9]|-|\.){1,}\.[A-Za-z]{2,4}$/', $adresse))
+			return $erreur;
+	}
+	return $ok;
+}

verifier/numerique.php

+<?php
+
+// Sécurité
+if (!defined("_ECRIRE_INC_VERSION")) return;
+
+/**
+ * Un nombre est composé de chiffres
+ */
+
+function verifier_numerique_dist($valeur, $options=array()){
+	$erreur = _T('verifier:erreur_numerique');
+	$ok = '';
+	if(!preg_match('/^[0-9]*$/',$valeur)) return $erreur;
+	return $ok;
+}

verifier/siren.php

+<?php
+
+// Sécurité
+if (!defined("_ECRIRE_INC_VERSION")) return;
+
+/**
+ * 1/ Un SIREN comporte STRICTEMENT 9 caractères
+ * 1b/ Un SIRET comporte strictement 14 caractères
+ * 2/ Un siren/siret utilise une clef de controle "1-2"
+ *    Un siren/siret est donc valide si la somme des chiffres paires
+ *    + la somme du double de tous les chiffres impairs (16 = 1+6 = 7) est un multiple de 10
+ */
+
+function verifier_siren_dist($valeur, $options=array()){
+	$erreur = _T('verifier:erreur_siren');
+	$ok = '';
+
+	// Si pas 9 caractère, c'est déjà foiré !
+	if(!preg_match('/^[0-9]{9}$/',$valeur)) return $erreur;
+	
+	// On vérifie la clef de controle "1-2"
+	$somme = 0;
+	$i = 0; // Les impaires
+	while($i < 9){ $somme += $valeur[$i]; $i+=2; }
+	$i = 1; // Les paires !
+	while($i < 9){ if((2*$valeur[$i])>9) $somme += (2*$valeur[$i])-9; else $somme += 2*$valeur[$i]; $i+=2; }
+	
+	if($somme % 10) return $erreur;
+	
+	return $ok;
+}

verifier/siret.php

+<?php
+
+// Sécurité
+if (!defined("_ECRIRE_INC_VERSION")) return;
+
+/**
+ * 1/ Un SIREN comporte STRICTEMENT 9 caractères
+ * 1b/ Un SIRET comporte strictement 14 caractères
+ * 2/ Un siren/siret utilise une clef de controle "1-2"
+ *    Un siren/siret est donc valide si la somme des chiffres paires
+ *    + la somme du double de tous les chiffres impairs (16 = 1+6 = 7) est un multiple de 10
+ */
+
+function verifier_siret_dist($valeur, $options=array()){
+	$erreur = _T('verifier:erreur_siret');
+	$ok = '';
+
+	// Si pas 14 caractère, c'est déjà foiré !
+	if(!preg_match('/^[0-9]{14}$/',$valeur)) return $erreur;
+	if(preg_match('/[0]{8}/',$valeur)) return $erreur;
+
+	// Pour le SIRET on vérifie la clef de controle "1-2" avec les impaires *2
+	// (vs pairs*2 pour SIREN, parce qu'on part de la fin)
+	$somme = 0;
+	$i = 1; // Les paires
+	while($i < 14){ $somme += $valeur[$i]; $i+=2; }
+	$i = 0; // Les impaires !
+	while($i < 14){ if((2*$valeur[$i])>9) $somme += (2*$valeur[$i])-9; else $somme += 2*$valeur[$i]; $i+=2; }
+	
+	if($somme % 10) return $erreur;
+	
+	return $ok;
+}

verifier/taille.php

+<?php
+
+// Sécurité
+if (!defined("_ECRIRE_INC_VERSION")) return;
+
+/**
+ * Vérifier une taille minimale/maximale, pour un mot de passe par exemple
+ */
+
+function verifier_taille_dist($valeur, $options=array()){
+	$ok = true;
+	$erreur = '';
+	
+	if (isset($options['min']))
+		$ok = ($ok and (strlen($valeur) >= $options['min']));
+	
+	if (isset($options['max'])){
+		$ok = ($ok and (strlen($valeur) <= $options['max']));
+	}
+	
+	if (!$ok){
+		if (isset($options['min']) and isset($options['max']))
+			$erreur = _T('verifier:erreur_taille_entre', $options);
+		elseif (isset($options['max']))
+			$erreur = _T('verifier:erreur_taille_max', $options);
+		else
+			$erreur = _T('verifier:erreur_taille_min', $options);
+	}
+	
+	return $erreur;
+}

verifier/telephone_fr.php

+<?php
+
+// Sécurité
+if (!defined("_ECRIRE_INC_VERSION")) return;
+
+/**
+ * Un nombre est composé de chiffres
+ */
+
+function verifier_telephone_fr_dist($valeur, $options=array()){
+	$erreur = _T('verifier:erreur_telephone');
+	$ok = '';
+	// On accepte differentes notations, les points, les tirets, les espaces, les slashes
+	$tel = ereg_replace("\.|/|-| ",'',$valeur);
+
+	// On interdit les 000 etc. mais je pense qu'on peut faire plus malin
+	// TODO finaliser les numéros à la con
+	if($tel == '0000000000') return $erreur;
+	
+	if(!preg_match("/^0[0-9]{9}$/",$tel)) return $erreur;
+	
+	return $ok;
+}

verifier/url.php

+<?php
+
+// Sécurité
+if (!defined("_ECRIRE_INC_VERSION")) return;
+
+/**
+ * Une URL commence par HTTP:// contient un domaine, etc.
+ * Doit pouvoir recevoir en option le protocole (ou pas) FTP SSH SFTP HTTP etc.
+ * Si pas de protocole spécifié, commencer à :// ??
+ */
+function verifier_url_dist($valeur, $options=array()){
+	$erreur = _T('verifier:erreur_url');
+	$ok = '';
+
+	/*
+		TODO Faire une belle RegExp
+	*/
+
+	return $ok;
+}