\return array
*/
function annoter ($t_attendus, $t_proposes)
{
mb_internal_encoding( 'UTF-8');
$texte_annote = "";
$nombre_mots = 0;
$nombre_attendus = 0;
$nombre_majuscules = 0;
$nombre_ponctuations = 0;
$valeur_mots = 0;
$valeur_ponctuations = 0;
$valeur_majuscules = 0;
$nb_a = count($t_attendus);
$nb_p = count($t_proposes);
$rang_a = 0;
$rang_p = 0;
$ponctuations = array("...", ",","?",";",".",":","!");
$espacables = array(";",":","!","?");
while ($attendu = $t_attendus[$rang_a])//____________________________________________________pour chaque mot attendu
{//1
$increment_a = 1;
$increment_p =1;
$propose = $t_proposes[$rang_p];
$initiale_a = substr($attendu,0,1);
$initiale_p = substr($propose,0,1);
$reste_a = substr($attendu,1);
$reste_p = substr($propose,1);
if ($attendu == $propose)//_________________________________________________les deux mots sont égaux
{//2
if (in_array($attendu, $ponctuations))//___________________________c'est une ponctuation
{//3
$nombre_ponctuations +=1;
$valeur_ponctuations +=1;
}//3
else//_______________________________________________________ce n'est pas une ponctuation
{//3
if (est_majuscule ($initiale_a))//_______majuscule
{//4
$nombre_majuscules +=1;
$valeur_majuscules +=1;
$nombre_mots +=1;
$nombre_attendus ++;
$valeur_mots +=1;
}//4
else//___________________________________________minuscule
{
$nombre_mots +=1;
$nombre_attendus ++;
$valeur_mots +=1;
}//4
}//3
$texte_annote .= " ".$attendu;
}//2
else//______________________________________________________________________________les deux mots sont différents
{//2
if (in_array($attendu, $ponctuations))//_____________________________________attendu est une ponctuation
{//3
$espace_avant = in_array($attendu, $espacables) ? " ":"";
$nombre_ponctuations +=1;
if (in_array($propose, $ponctuations))//________________________propose est une ponctuation
{//4
$valeur_ponctuations +=0.5;
}
else//____________________________________________________propose n'est pas une ponctuation
{
$increment_p =0;
}//4
$texte_annote .= "$espace_avant$propose$espace_avant$attendu";
}//3
else//__________________________________________________________________attendu n'est pas une ponctuation
{//3
if (in_array($propose,$ponctuations))
{
$texte_annote.= "$propose";
$increment_a = 0;
}
else
{
$nombre_mots +=1;
$nombre_attendus ++;
if (est_majuscule($initiale_a))//_________________________________attendu est majuscule
{//4
$nombre_majuscules +=1;
if ($initiale_p == $initiale_a)//__________________même initiale majuscule
{//5
$valeur_majuscules +=1;
$reste_a = substr($attendu,1);
$reste_p = substr($propose,1);
$resultat = souligner ($reste_a, $reste_p);
$valeur_mots += valoriser_mot ($attendu,$propose, $resultat['difference']);
$texte_annote.= " ".$initiale_p.$resultat['souligne'];
}//5
else//______________________________________les initiales sont différentes
{//5
$reste_a = substr($attendu,1);
$reste_p = substr($propose,1);
if ($reste_a == $reste_p)//_______les restes sont identiques
{//6
$initiale_p = substr($propose,0,1);
if (strtoupper($initiale_p) != $initiale_a)
{
$valeur_mots += valoriser_mot ($attendu,$propose, 1);
}
else
{
$valeur_mots += valoriser_mot ($attendu,$propose, 0);
}
$texte_annote .= " $initiale_p$initiale_a$reste_a";
}//6
else//___________________________les restes sont différents
{//6
$attendu_test = strtolower($attendu);
$propose_test = strtolower($propose);
$resultat = souligner ($reste_a, $reste_p);
$valeur_mots += valoriser_mot ($attendu,$propose, $resultat['difference']);
$texte_annote.= " $initiale_p$initiale_a".$resultat['souligne'];
}//6
}//5
}//4
else//_______________________________________________________attendu n'est pas majuscule
{
if (est_majuscule ($initiale_p))
{
$reste_a = substr($attendu,1);
$valeur_majuscules -=1;
$reste_p = substr($propose,1);
$resultat = souligner ($reste_a, $reste_p);
$valeur_mots += valoriser_mot ($attendu,$propose, $resultat['difference']);
$texte_annote.= " $initiale_p$initiale_a".$resultat['souligne'];
}
else
{
$resultat = souligner ($attendu, $propose);
$valeur_mots += valoriser_mot ($attendu,$propose, $resultat['difference']);
$mot_corrige = $resultat['souligne'];
if ($mot_corrige == "$")
{
$texte_annote .= chr(39);
}
else
{
$texte_annote.= " ".$mot_corrige;
}
}
}//4
}
}//3
}//2
$rang_a += $increment_a;
$rang_p += $increment_p;
}//1
$valeur_mots /= $nombre_mots;
$valeur_ponctuations /= $nombre_ponctuations;
$valeur_majuscules = ($valeur_majuscules > 0) ? $valeur_majuscules / $nombre_majuscules: 0;
return array("valeur_mots"=>$valeur_mots,"valeur_majuscules"=>$valeur_majuscules, "valeur_ponctuations"=>$valeur_ponctuations,
"texte_annote"=>$texte_annote );
}
/*_____________________________________________________________________________________________________________ANNOTER*/
/*ANNOTER_1*/
/**
annoter_1 ($texte_1, $texte_2)
\brief destinée aux textes dont le nombre de mots est différent du nombre de mots attendus.
\details
\param $texte_1 array of string chaine de caractères dont les espaces ont été éliminés
\param $texte_2 array of string chaine de caractères dont les espaces ont été éliminés
On compare les mots de rang ia et ip:
test par levenshtein (la première est le mot proposé le second est le mot attendu :
retours
0 : les deux mots sont égaux
1 : majuscule initiale ou ponctution possible; sinon erreur de lettre
autres valeurs :
retour égal à longeur d'un des mots :
ponctuation possible par oubli d'un mot
mot oublié
mot ajouté
*/
function annoter_1($texte_1, $texte_2)
{
mb_internal_encoding( 'UTF-8');
$texte_annote = "";
$nombre_mots = 0;
$nombre_attendus = 0;
$nombre_majuscules = 0;
$nombre_ponctuations = 0;
$valeur_mots = 0;
$valeur_ponctuations = 0;
$valeur_majuscules = 0;
$rang_a = 0;
$rang_p = 0;
$difference = 0;
$texte_annote = array();
while (isset($texte_1[$rang_a]))
{
$attendu = $texte_1[$rang_a];
$increment_a = 1;
$increment_p = 1;
$propose = $texte_2[$rang_p];
$long_a = mb_strlen($attendu);
$long_p = mb_strlen($propose);
$init_a = $attendu[0];
$init_p = $propose[0];
/** $diff est le levenshtein des deux mots*/
$diff = levenshtein($propose,$attendu);
switch ($diff)
{
case 0://_______________________________________________________________________________________mots identiques
if (est_ponctuation($attendu))//_________________________________________attendu est une ponctuation
{
$nombre_ponctuations +=1;
$valeur_ponctuations +=1;
}
else//________________________________________________________attendu n'est pas une ponctuation
{
if (est_majuscule($init_a))//______________________attendu est une majuscule
{
$nombre_majuscules +=1;
$valeur_majuscules +=1;
$nombre_mots +=1;
$valeur_mots +=1;
}
else//_____________________________________ce n'est pas une majuscule
{
$nombre_mots +=1;
$valeur_mots +=1;
}
}
$texte_annote[]= $attendu;
break;
case 1://________________________________________________________________________________________Une différence
if (est_ponctuation ($attendu))//_____________________________le mot attendu est une ponctuation
/**on incrémente le nombre de ponctuations et l'incrément des mots attendus. */
{//1
$nombre_ponctuations +=1;
if (est_ponctuation($propose))
{
$texte_annote[] = "$propose$attendu";
}
else
{
/*vérification du mot suivant attendu*/
$increment_p = 0;
}
}
else
{//1
if (est_majuscule($init_a))//______________________attendu commence par une majuscule
{//2
$nombre_majuscules +=1;
$nombre_mots +=1;
if (est_majuscule($init_p))//proposé commence par une majuscule
{//3
if ($init_p == $init_a)//initiales identiques
{//4
/* L'erreur est ailleurs qu'à l'initiale*/
$valeur_majuscules +=1;
$attendu_test = mb_substr($attendu,1);
$propose_test = mb_substr($propose,1);
$resultat = souligner ($attendu_test, $propose_test, $difference);
$valeur_mots += valoriser_mot ($attendu,$propose, $resultat['difference']);
$souligne = $init_a.$resultat['souligne'];
$texte_annote[] = $souligne;
}//4
else//__________________initiales différentes
{//4
$attendu_test = mb_substr($attendu,1);
$texte_annote[] = "$init_p$init_a$attendu_test";
}//4
}//3
}
else//_____________________________________attendu ne commence pas par une majuscule
{//2
if (est_majuscule($init_p))//proposé commence par une majuscule
{//3
if (mb_strtolower ($init_p) == $init_a)// bonne lettre
{
$valeur_mots +=1;
$valeur_majuscules -=1;
$attendu_test = mb_substr($attendu,1);
$texte_annote[] = "$init_p$init_a$attendu_test";
}
else
{
$valeur_mots += 0.9;
$valeur_majuscules -=1;
$attendu_test = mb_substr($attendu,1);
$texte_annote[] = "$init_p$init_a$attendu_test";
}
}//3
else//_______________proposé ne commence pas par une majuscule
{
/* L'erreur est ailleurs qu'à l'initiale*/
$valeur_majuscules +=1;
$attendu_test = mb_substr($attendu,1);
$propose_test = mb_substr($propose,1);
$resultat = souligner ($attendu_test, $propose_test, $difference);
$valeur_mots += valoriser_mot ($attendu,$propose, $resultat['difference']);
$souligne = $init_a.$resultat['souligne'];
$texte_annote[] = $souligne;
}
} //2
}//1
break;
default://__________________________________________________________________________________dans les autres cas
if (est_ponctuation ($attendu))//______________________________________attendu est une ponctuation
/*incrémentation du nombre de ponctuations et avancement de 1 dans les mots attendus sans
changer de mot proposé*/
{//1
$nombre_ponctuations +=1;
$texte_annote[] = "$attendu";
$increment_p =0;
}
if (est_majuscule($init_a))//___________attendu a une majuscule
{//1
$nombre_majuscules +=1;
if (est_majuscule($init_p))//proposé a une majuscule
{//2
if ($init_a == $init_p)//bonne majuscule
{//3
$valeur_majuscules +=1;
$nombre_mots += 1;
$attendu_test = mb_substr($attendu,1);
$propose_test = mb_substr($propose,1);
$resultat = souligner ($attendu_test, $propose_test, $difference);
$valeur_mots += valoriser_mot ($attendu,$propose, $resultat['difference']);
$souligne = $init_a.$resultat['souligne'];
$texte_annote[] = $souligne;
}
else//________________mauvaise majuscule
{//3
$attendu_test = mb_substr($attendu,1);
$propose_test = mb_substr($propose,1);
$resultat = souligner ($attendu_test, $propose_test, $difference);
$nombre_mots += 1;
$valeur_mots += valoriser_mot ($attendu,$propose, $resultat['difference']);
$souligne = $resultat['souligne'];
$texte_annote[] = "$init_p$init_a$souligne";
}//3
}
else//proposé ne commence pas par une majuscule
{//2
if (mb_strtolower($init_a)== $init_p)//la lettre est bonne
{//3
$attendu_test = mb_substr($attendu,1);
$propose_test = mb_substr($propose,1);
$resultat = souligner ($attendu_test, $propose_test, $difference);
$nombre_mots += 1;
$valeur_mots += valoriser_mot ($attendu,$propose, $resultat['difference']);
$souligne = $resultat['souligne'];
$texte_annote[] = "$init_a$souligne";
}
else//____________________________la lettre est mauvaise
{//3
$attendu_test = mb_substr($attendu,1);
$propose_test = mb_substr($propose,1);
$resultat = souligner ($attendu_test, $propose_test, $difference);
$nombre_mots += 1;
$valeur_mots += valoriser_mot ($attendu,$propose, $resultat['difference']);
$souligne = $resultat['souligne'];
$texte_annote[] = "$init_p$init_a$souligne";
}//4
}//2
}
else//____________________________attendu n'est pas une majuscule
{//1
if (est_majuscule($init_p))//proposé a une majuscule
{//2
if (mb_strtolower($init_p) == $init_a)//lettre bonne
{//3
$attendu_test = mb_substr($attendu,1);
$propose_test = mb_substr($propose,1);
$resultat = souligner ($attendu_test, $propose_test, $difference);
$nombre_mots += 1;
$valeur_mots += valoriser_mot ($attendu,$propose, $resultat['difference']);
$souligne = $resultat['souligne'];
$texte_annote[] = "$init_p$init_a$souligne";
}
else//____________________majuscule proposée fausse
{//3
$attendu_test = mb_substr($attendu,1);
$propose_test = mb_substr($propose,1);
$difference =1;
$resultat = souligner ($attendu_test, $propose_test, $difference);
$nombre_mots += 1;
$valeur_mots += valoriser_mot ($attendu,$propose, $resultat['difference']);
$souligne = $resultat['souligne'];
$texte_annote[] = "$init_p$init_a$souligne";
}//3
}//2
else //proposé n'a pas de majuscule
{//2
$resultat = souligner ($attendu, $propose, $difference);
$diff_trouvee = $resultat['difference'];
$nombre_mots += 1;
$valeur_mots += valoriser_mot ($attendu,$propose, $resultat['difference']);
$souligne = $resultat['souligne'];
$texte_annote[] = $souligne;
}//2
}//1
break;
}
/* Quand la difference entre les deux mots est très importante, on tente de comparer en passant
au suivant de $texte_1 ou de $texte_2.
Si le résultat est meilleur on incorpore le mot et on continue normalement.
*/
/** $max_long integer longueur du plus long des deux mots comparés*/
$max_long = max($long_a, $long_p);
if (($diff_trouvee >= $max_long-1) and ($diff > 1))
{
$difference_prov=0;
$propose_prov = $texte_2[$rang_p+1];
$attendu_prov = $texte_1[$rang_a+1];
$lev_suivant_p = levenshtein($propose_prov, $attendu);
$lev_suivant_a = levenshtein ($propose, $attendu_prov);
if ($lev_suivant_a < $lev_suivant_p)
{
if (est_ponctuation($attendu_prov) != true)
{
$resultat = souligner ($attendu_prov,$propose, $difference_prov);
$difference_prov = $resultat['difference'];
if ($difference_prov <= 2)
{
$valeur_mots += $difference_prov;
$increment_a = 2;
$souligne = $resultat['souligne'];
$z = array_pop($texte_annote);
$texte_annote[] = "$attendu ".$souligne;
}
}
}
else
{
if (est_ponctuation($propose_prov) != true)
{
$resultat = souligner ($attendu,$propose_prov, $difference_prov);
$difference_prov = $resultat['difference'];
if ($difference_prov <= 2)
{
$valeur_mots += $difference_prov;//- $difference;
$increment_a = 2;
$souligne = $resultat['souligne'];
$z = array_pop($texte_annote);
$texte_annote[] = "$attendu ".$souligne;
}
}
}
}
$rang_a += $increment_a;
$rang_p += $increment_p;
}
$valeur_mots /= $nombre_mots;
$valeur_ponctuations /= $nombre_ponctuations;
$valeur_majuscules = ($valeur_majuscules > 0) ? $valeur_majuscules / $nombre_majuscules: 0;
return array("valeur_mots"=>$valeur_mots,"valeur_majuscules"=>$valeur_majuscules, "valeur_ponctuations"=>$valeur_ponctuations,
"texte_annote"=>$texte_annote );
}
/*___________________________________________________________________________________________________________ANNOTER_1*/
/*ARRONDI*/
/**
arrondi($nombre, $nombre_paliers) arrondi par seuils
\param $nombre float nombre à arrondir
\param $nombre_paliers integer le nombre de paliers entre lesquels se fait l'arrondi, par défaut :4
\return float $nombre arrondi
\details Le nombre est arrondi à la valeur inférieure
*/
function arrondi($nombre, $nombre_paliers = 4)
{
/** $entier partie entière du nombre à arrondir*/
$entier = intval($nombre);
/**$decimal partie décimale du nombre à arrondir*/
$decimal = $nombre - $entier;
/** $seuils array of float : tableau des paliers*/
$seuils = array();
/** $pas float : pas d'incrémentation des paliers*/
$pas = 1/$nombre_paliers;
$seuils[0]= 0;
for ($i = 1; $i <$nombre_paliers; $i++)
{
$seuils[$i] = $seuils[$i-1]+$pas;
}
/**$fini boolean : arret de boucle while*/
$fini = false;
$i=1;
while ($fini == false)
{
if ($decimal < $seuils[$i])
{
$ajustage = $seuils[$i-1];
$fini = true;
}
else
{
$i++;
}
}
return $entier+$ajustage;
}
/*____________________________________________________________________________________________________________ARRONDI*/
/*CATALOGUE*/
/**
catalogue($depart, $parent, $type)
\param $depart $string point de départ du parcours
\param $parent $string répertoire parent du répertoire en cours de parcours
\param $type string : type de fichiers à afficher
\li 'texte' : fichiers de texte
\li 'son' fichiers sonores
\return true
\details parcours l'arborescence des répertoires en créant à chaque niveau un select des fichiers du type voulu.
*/
function catalogue ($depart, $parent, $type, $cible)
{//1
switch ($type)
{//2
case "texte":
$acceptes = array("text", "txt", "asc", "ascii");
break;
case "son":
break;
}//2
$parent = dirname($depart);
print " dep $depart parent $parent";
$chargeables = "";
if ($charger)
{//3
print "";
closedir($handle);
}//3
return true;
}//2
}
/*___________________________________________________________________________________________________________CATALOGUE*/
/*COLONNES_DE_TEXTE*/
/**
colonnes_de_texte($chaine, $taille_fonte)
\brief calcule le nombre de colonnes qu'occupe une chaine
\param $chaine string : la chaine dont on calcule l'occupation
\param $taille_fonte integer : taille de la fonte en points
\return $colonnes integer nombre de colonnes
\details On calcule d'abord la taille en pixels, puis le nombre de colonnes
\ref analyser_saisie.php \ref analyser_frappe_dictee.php
*/
function colonnes_de_texte($chaine, $taille_fonte)
{
mb_internal_encoding( 'UTF-8');
$largeurs = array(
chr(0)=>278,chr(1)=>278,chr(2)=>278,chr(3)=>278,chr(4)=>278,chr(5)=>278,chr(6)=>278,chr(7)=>278,chr(8)=>278,chr(9)=>278,chr(10)=>278,chr(11)=>278,chr(12)=>278,chr(13)=>278,chr(14)=>278,chr(15)=>278,chr(16)=>278,chr(17)=>278,chr(18)=>278,chr(19)=>278,chr(20)=>278,chr(21)=>278,
chr(22)=>278,chr(23)=>278,chr(24)=>278,chr(25)=>278,chr(26)=>278,chr(27)=>278,chr(28)=>278,chr(29)=>278,chr(30)=>278,chr(31)=>278,' '=>278,'!'=>278,'"'=>355,'#'=>556,'$'=>556,'%'=>889,'&'=>667,'\''=>191,'('=>333,')'=>333,'*'=>389,'+'=>584,
','=>278,'-'=>333,'.'=>278,'/'=>278,'0'=>556,'1'=>556,'2'=>556,'3'=>556,'4'=>556,'5'=>556,'6'=>556,'7'=>556,'8'=>556,'9'=>556,':'=>278,';'=>278,'<'=>584,'='=>584,'>'=>584,'?'=>556,'@'=>1015,'A'=>667,
'B'=>667,'C'=>722,'D'=>722,'E'=>667,'F'=>611,'G'=>778,'H'=>722,'I'=>278,'J'=>500,'K'=>667,'L'=>556,'M'=>833,'N'=>722,'O'=>778,'P'=>667,'Q'=>778,'R'=>722,'S'=>667,'T'=>611,'U'=>722,'V'=>667,'W'=>944,
'X'=>667,'Y'=>667,'Z'=>611,'['=>278,'\\'=>278,']'=>278,'^'=>469,'_'=>556,'`'=>333,'a'=>556,'b'=>556,'c'=>500,'d'=>556,'e'=>556,'f'=>278,'g'=>556,'h'=>556,'i'=>222,'j'=>222,'k'=>500,'l'=>222,'m'=>833,
'n'=>556,'o'=>556,'p'=>556,'q'=>556,'r'=>333,'s'=>500,'t'=>278,'u'=>556,'v'=>500,'w'=>722,'x'=>500,'y'=>500,'z'=>500,'{'=>334,'|'=>260,'}'=>334,'~'=>584,chr(127)=>350,chr(128)=>556,chr(129)=>350,chr(130)=>222,chr(131)=>556,
chr(132)=>333,chr(133)=>1000,chr(134)=>556,chr(135)=>556,chr(136)=>333,chr(137)=>1000,chr(138)=>667,chr(139)=>333,chr(140)=>1000,chr(141)=>350,chr(142)=>611,chr(143)=>350,chr(144)=>350,chr(145)=>222,chr(146)=>222,chr(147)=>333,chr(148)=>333,chr(149)=>350,chr(150)=>556,chr(151)=>1000,chr(152)=>333,chr(153)=>1000,
chr(154)=>500,chr(155)=>333,chr(156)=>944,chr(157)=>350,chr(158)=>500,chr(159)=>667,chr(160)=>278,chr(161)=>333,chr(162)=>556,chr(163)=>556,chr(164)=>556,chr(165)=>556,chr(166)=>260,chr(167)=>556,chr(168)=>333,chr(169)=>737,chr(170)=>370,chr(171)=>556,chr(172)=>584,chr(173)=>333,chr(174)=>737,chr(175)=>333,
chr(176)=>400,chr(177)=>584,chr(178)=>333,chr(179)=>333,chr(180)=>333,chr(181)=>556,chr(182)=>537,chr(183)=>278,chr(184)=>333,chr(185)=>333,chr(186)=>365,chr(187)=>556,chr(188)=>834,chr(189)=>834,chr(190)=>834,chr(191)=>611,chr(192)=>667,chr(193)=>667,chr(194)=>667,chr(195)=>667,chr(196)=>667,chr(197)=>667,
chr(198)=>1000,chr(199)=>722,chr(200)=>667,chr(201)=>667,chr(202)=>667,chr(203)=>667,chr(204)=>278,chr(205)=>278,chr(206)=>278,chr(207)=>278,chr(208)=>722,chr(209)=>722,chr(210)=>778,chr(211)=>778,chr(212)=>778,chr(213)=>778,chr(214)=>778,chr(215)=>584,chr(216)=>778,chr(217)=>722,chr(218)=>722,chr(219)=>722,
chr(220)=>722,chr(221)=>667,chr(222)=>667,chr(223)=>611,chr(224)=>556,chr(225)=>556,chr(226)=>556,chr(227)=>556,chr(228)=>556,chr(229)=>556,chr(230)=>889,chr(231)=>500,chr(232)=>556,chr(233)=>556,chr(234)=>556,chr(235)=>556,chr(236)=>278,chr(237)=>278,chr(238)=>278,chr(239)=>278,chr(240)=>556,chr(241)=>556,
chr(242)=>556,chr(243)=>556,chr(244)=>556,chr(245)=>556,chr(246)=>556,chr(247)=>584,chr(248)=>611,chr(249)=>556,chr(250)=>556,chr(251)=>556,chr(252)=>556,chr(253)=>500,chr(254)=>556,chr(255)=>500);
//Get width of a string in the current font
$longueur_pixels = 0;
$longueur = mb_strlen($chaine);
for($i=0;$i< $longueur;$i++)
$longueur_pixels += $largeurs[$chaine[$i]];
/*8000 par tatonnements*/
$colonnes = round(($longueur_pixels*($taille_fonte/8000)),0);
$colonnes = ($colonnes == 0) ? 1: $colonnes;
return $colonnes;
}
/*__________________________________________________________________________________________________COLONNES_DE_TEXTE*/
/*CONNEXION*/
/**
connexion ($hote, $nom, $passe)
\brief effectue la connexion à mysql
\return $mysqli : ressource mysql
*/
function connexion ($hote="", $nom="", $passe="")
{
include('connexions.php');
global $ProblemeSql ;
; $mysqli = mysqli_init();
if ($mysqli === false)//_______________________________________________________________________initialisation échouée
{//1
print "$ProblemeSql";
$chaine = "échec de mysqli_init dans ".__FILE__." ligne ".__LINE__;
enregistrer_erreur($chaine);
exit;
}
else//_________________________________________________________________________________________initialisation réussie
{//1
$resultat = $mysqli->real_connect($ServeurMysql, $RootMysql, $PassRootMysql);
if ($resultat == false)//________________________________________________________connexion échouée
{//2
print "$ProblemeSql";
$chaine = "échec de mysqli_init dans ".__FILE__." ligne ".__LINE__;
enregistrer_erreur($chaine);
exit;
}
else
{
return $mysqli;
}
}
}
/*_________________________________________________________________________________________________________CONNEXION*/
/*CREER_AUTORISATION*/
/**
creer_autorisation()
\brief Crée une autorisation transmise par post et une autorisation hachée transmise par session.
\details L'algorithme est le même que celui de creer_hachage():
\li $semence : une chaine aléatoire de 22 caractères
\li $mot : une chaine aléatoire de 22 caractères
\li mot crypte : $mot crypte et la semence de cryptage concaténée.
\n La validité du couple est vérifiée par verifier_autor($clair, $crypte).
\return array($autorisation, $autorisation_cryptée)
*/
function creer_autorisation()
{
$force = "08";
/**$semence suite aléatoire de 22 caractères)*/
$semence = "";
for ($i = 0; $i < 22; $i++)
{
$semence .= substr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", mt_rand(0, 61), 1);
}
/**$mot suite aléatoire de 22 caractères) */
$mot = "";
for ($i = 0; $i < 22; $i++)
{
$mot .= substr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", mt_rand(0, 61), 1);
}
return array($mot, crypt($mot, "$2a$".$force."$".$semence).$semence);
}
/*________________________________________________________________________________________________CREER_AUTORISATION*/
/*CREER_GRAPHIQUE*/
/**
creer_graphique($donnees, $nom, $passe, $NomBdd)
\brief prépare l'affichage des résultats d'une dictée
\param $donnees sérialisation des éléments utiles (envoyé par corriger.php)
\param $nom string nom de l'utilisateur
\param $passe string mot de passe de l'utilisateur
\param $NomBdd string nom de la base de données
\return $chaine string HTML prête à être affichée
\details Description complete
\par Préparation de l'affichage graphique
Les valeurs des mots de 0 à 1 sont amenées à une valeur sur 80.
\n
Les valeurs des ponctuations de 0 à 1 sont amenées à une valeur sur 10.
\n
Les valeurs des majuscules de 0 à 1 sont amenées à une valeur sur 10.
\n
On constitue pour chaque série une chaine de ! en vert sur fond vert dont la longueur est la valeur recalculée
\n
La valeur totale est calculée
\n On constitue pour elle une chaine de ! en vert sur fond vert dont la longueur est la valeur recalculée suivie d'une
chaine de ! en rouge sur fond rouge pour la partie du otal qui n'atteint pas 100.
\par Préparation de l'affichage du texte et de ses commentaires
\par Préparation de l'affichage des résultats antérieurs
Consultation de la table resultats
\n Pour chaque ligne concernant l'élève connecté, lecture et remise en forme de la date, lecture du titre, du niveau et
du résultat.
\par Mise à jour du niveau de l'élève
Si son résultat est >= 80, son niveau devient celui de la dictée qu'il vient de faire (il est nécessairement >= à sonn iveau actuel.)
*/
function creer_graphique($donnees, $nom, $passe, $NomBdd)
{
/** $Captions et $SousTitres sont définis dans \ref kaligraphe.php
*/
global $Captions, $SousTitres;
$resultats= unserialize($donnees);
$texte_attendu = $resultats['texte_attendu'];
$texte_tape = $resultats['texte_tape'];
$texte_annote = $resultats['texte_annote'];
/*____________________________________________________________________________Préparation du graphique du résultat*/
/**$valeur_mots float qui peut avoir pris une valeur négative et qui est ramené à 0...1*/
$valeur_mots = max($resultats['valeur_mots'],0);
$id_utilisateur = $resultats['id_utilisateur'];
$id_dictee = $resultats['id_dictee'];
$niveau_dictee = $resultats['niveau_dictee'];
$niveau_scolaire = $resultats['niveau_scolaire'];
/** $valeur_mots_justes integer entre 0 et 80 tiré de $valeur_mots*/
$valeur_mots_justes = arrondi(80*$valeur_mots);
/** $chaine_mots string la valeur recalculée*/
$chaine_mots = "mots $valeur_mots_justes / 80 ";
/** $carre char: ! est choisi pour sa longueur raisonnable*/
$carre = "!";
/** $ligne_j string de ! en nombre égal à $valeur_mots_justes.
\details pas de mise en forme car elle sert pour montrer la valeur des mots justes et pour décaler la barre des ponctuations.
*/
$ligne_j = str_repeat ($carre,$valeur_mots_justes);
/** $barre_mots string ajout de la mise en forme*/
$barre_mots = "".$ligne_j."";
/**$valeur_ponctuation float peut avoir pris une valeur négative : est ramené à 0...1 puis transposée entre 0 et 10*/
$valeur_pontuation = max($resultats['valeur_ponctuation'],0);
$valeur_ponctuation =arrondi(10*$valeur_ponctuation);
/** $ligne_jp string de ! en nombre égal à $valeur_ponctuations.*/
$ligne_jp = str_repeat ($carre,$valeur_ponctuation);
/** $barre_ponct string
\details barre des mots justes rendue transparente suivie de la ligne des ponctuations justes avec
ajout de la mise en forme*/
$barre_ponct = "".$ligne_j."".$ligne_jp."";
/**$valeur_maj float peut avoir pris une valeur négative : est ramené à 0...1 puis transposée entre 0 et 10*/
$valeur_maj = max($resultats['valeur_maj'],0);
$valeur_maj =arrondi(10*$valeur_maj);
/** $ligne_jm string de ! en nombre égal à $valeur_maj.*/
$ligne_jm = str_repeat ($carre,$valeur_maj);
/** $barre_maj string
\dettails barre des mots justes suivie de la ligne des ponctuations justes rendue transparente suivie
de la basse des majuscules justes avec ajout de la mise en forme*/
$barre_maj = "".$ligne_j.$ligne_jp."".$ligne_jm."";
/** $total integer note finale*/
$total = $valeur_maj+$valeur_ponctuation+$valeur_mots_justes;
/**$barre_total_j string de ! de la longueur de $total*/
$barre_total_j = str_repeat ($carre,$total);
/**$barre_total_f string de ! de la longueur de 100-$total*/
$barre_total_f =str_repeat ($carre,100-$total);
/**$barre_total concaténation de $barre_total_j et $barre_total_f avec mise en forme*/
$barre_total = "".$barre_total_j."".$barre_total_f."";
$mysqli = connexion();
$mysqli->change_user($nom, $passe);
$table = $NomBdd.".kalig_resultats";
$table_1 = $NomBdd.".kalig_textes";
$requete = "insert into $table set id_utilisateur = $id_utilisateur, id_dictee= $id_dictee,
score = $total, niveau_dictee = $niveau_dictee, date = NOW()";
$mysqli->query($requete);
/** $anterieurs chaine html des résultats précédents*/
$anterieurs = "
$Captions[17]
$SousTitres[8]
$SousTitres[9]
$SousTitres[10]
$SousTitres[11]
";
$requete = "select * from $table as r, $table_1 as t where (r.id_dictee= t.id_dictee and id_utilisateur=$id_utilisateur) order by date desc limit 5;";
$resultat = $mysqli->query($requete);
$constance_niveau = 0;
$obj = $resultat->fetch_object();
$niveau_dictee_initial = $obj->degre;
$titre_fait = $obj->titre;
$score_fait = $obj->score;
$date_fait =$obj->date;
$t_date= date_parse($date_fait);
$date_fr = $t_date['day']."-".$t_date['month']."-".$t_date['year']." ".$t_date['hour'].":".$t_date['minute'];
$anterieurs .="
$date_fr
$titre_fait
$niveau_dictee_initial
$score_fait
";
/**mise à jour éventuelle du niveau de l'élève*/
if (($niveau_dictee_initial > $niveau_scolaire) and ($score_fait >=80))
{
$table = $NomBdd.".kalig_utilisateurs";
$requete = "update $table set niveau_scolaire = $niveau_dictee_initial where id_utilisateur = $id_utilisateur";
$mysqli->query($requete);
}
while($obj = $resultat->fetch_object())
{
$niveau_dictee = $obj->degre;
$titre_fait = $obj->titre;
$score_fait = $obj->score;
$date_fait =$obj->date;
$t_date= date_parse($date_fait);
$date_fr = $t_date['day']."-".$t_date['month']."-".$t_date['year']." ".$t_date['hour'].":".$t_date['minute'];
$anterieurs .="
$date_fr
$titre_fait
$niveau_dictee
$score_fait
";
}
$chaine = "
$Captions[13]
$SousTitres[1]
$valeur_mots_justes / 80
$barre_mots
$SousTitres[2]
$valeur_ponctuation / 10
$barre_ponct
$SousTitres[3]
$valeur_maj / 10
$barre_maj
$SousTitres[4]
$total / 100
$barre_total
$Captions[16]
$SousTitres[5]
$SousTitres[6]
$SousTitres[7]
$texte_attendu
$texte_tape
$texte_annote
".$anterieurs;
return $chaine;
}
/*_____________________________________________________________________________________________________CREER_GRAPHIQUE*/
/*CREER_HACHAGE*/
/**
creer_hachage($mot)
\brief hache le mot de passe
\version adaptée de la fonction de simans dot net sur fr2.php.net/manual
\param $mot string le mot à crypter
\return le mot crypté(60 cars)) et la semence (22 cars)) utilisée concaténée à la fin.
*/
function creer_hachage($mot )
{
$force = "08";
$semence = "";
for ($i = 0; $i < 22; $i++)
{
$semence .= substr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", mt_rand(0, 61), 1);
}
return crypt($mot, "$2a$".$force."$".$semence).$semence;
}
/*_______________________________________________________________________________________________________CREER_HACHAGE*/
/*CREER_ID*/
/**
creer_ID()
\brief crée nun id de session
\version adaptée de la fonction de simans dot net sur fr2.php.net/manual
\param $mot string le mot à crypter
\return le mot crypté(60 cars)) et la semence (22 cars)) utilisée concaténée à la fin.
*/
function creer_id($mot="" )
{
$mot = "";
for ($i = 0; $i <10; $i ++)
{
$mot .= substr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", mt_rand(0, 61), 1);
}
$force = "08";
$semence = "";
for ($i = 0; $i < 22; $i++)
{
$semence .= substr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", mt_rand(0, 61), 1);
}
return crypt($mot, "$2a$".$force."$".$semence).$semence;
}
/*_______________________________________________________________________________________________________CREER_HACHAGE*/
/*ENREGISTRER_ERREUR*/
/**
enregistrer_erreur($chaine)
\param $chaine string : message d'erreur
\brief écrit dans le fichier logs/erreurs.txt le message d'erreur qu'on lui envoie
*/
function enregistrer_erreur($chaine)
{
$date = date ("j-n-Y H-i");
$fic = fopen("logs/erreurs.txt", "a");
$message ="\n\n\n__________________________________________________________\n $date\n";
$message .= $chaine;
$message .="\n__________________________________________________________\n";
fputs($fic, $message);
fclose($fic);
}
/*________________________________________________________________________________________________ENREGISTRER_ERREUR*/
/*EST_MAJUSCULE*/
/**
est_majuscule($lettre)
\brief indique si une lettre est majuscule ou non
\param $lettre char
\return boolean
*/
function est_majuscule($lettre)
{
return ( strtoupper($lettre) == $lettre);
}
/*_______________________________________________________________________________________________________EST_MAJUSCULE*/
/*EST_PONCTUATION*/
/**
est_ponctuation($mot)
\brief indique si une mot est un signe de ponctuation
\param $mot string
\return boolean
*/
function est_ponctuation($mot)
{
$ponctuations = array("...", ",","?",";",".",":","!");
return in_array($mot, $ponctuations);
}
/*_______________________________________________________________________________________________________EST_PONCTUATION*/
/*FERME_LA*/
function ferme_la()
{
print "";
}
/*___________________________________________________________________________________________________________FERME_LA*/
/*GENERER_SELECT_DEGRE*/
/**
generer_select_degre ($degre=1)
\param $degre integer: le degré de dfficulté présélectionné, par défaut 1.
\return $select_degre string: un select utilisé dans saisir_texte.php et dans verifier_saisie.php
*/
function generer_select_degre ($degre=1)
{
/**
$t_niveaux array of strings utilisé dans analyser_saisie.php
\details alimente le sélecteur de niveaux $select_degre de analyser_saisie.php.
Les 42 degrés de Dubois Buyse correspondent à 9 niveaux scolaires.
*/
$t_niveau = array_fill(0,8, "CP");
$t_niveau = array_pad($t_niveau, 11, "CE 1");
$t_niveau = array_pad($t_niveau, 15, "CE 2");
$t_niveau = array_pad($t_niveau, 19, "CM 1");
$t_niveau = array_pad($t_niveau, 23, "CM 2");
$t_niveau = array_pad($t_niveau, 27, "Sixième");
$t_niveau = array_pad($t_niveau, 31, "Cinquième");
$t_niveau = array_pad($t_niveau, 35, "Quatrième");
$t_niveau = array_pad($t_niveau, 39, "Troisième");
$t_niveau = array_pad($t_niveau, 50, "Lycée et au-delà");
$i = 1;
$t_niveaux= array();
foreach ($t_niveau as $niveau)
{
$niveau = $i++." : ".$niveau;
$t_niveaux[] = $niveau;
}
$nb_niveaux = count($t_niveaux);
$selecteds = array_fill(0, $nb_niveaux, "");
$selecteds[$degre] = "selected = 'selected'";
/**
$select_degre string HTML dans analyser_saisie.php
\details sélecteur de niveau scolaire ou Dubois Buyse
*/
$select_degre = "";
return $select_degre;
}
/*_______________________________________________________________________________________________GENERER_SELECT_DEGRE*/
/*GENERER_SELECT_DOMINANTE*/
/**
generer_select_dominante ($dominante=0)
\details produit un select utilisé dans saisir_texte.php et dans verifier_saisie.php
*/
function Generer_select_dominante ($dominante =0)
{
global $t_dominantes;
$nb_dominantes = count($t_dominantes);
$selecteds = array_fill(0, $nb_dominantes, "");
$selecteds[$dominante] = "selected = 'selected'";
$select_dominante = "";
return $select_dominante;
}
/*____________________________________________________________________________________________GENERER_SELECT_DOMINANTE*/
/*GENERER_SELECT_MEDIA*/
/**
generer_select_media ($choisi=1)
\param $choisi integer par défaut 1;
\return string HTML
\details produit un select utilisé dans saisir_texte.php et dans verifier_saisie.php
\li 1 : dictée à écouter
\li 2 : dictée à recopier
\li 3 : dictée à réciter
\li 4 : dictée à lire et écouter
*/
function generer_select_media ($choisi=1)
{
$selected1 ="";
$selected2 ="";
$selected3 = "";
$selected4 = "";
switch ($choisi)
{
case 1:
$selected1= " selected = 'selected'";
break;
case 2:
$selected2 = " selected = 'selected'";
break;
case 3:
$selected3= " selected = 'selected'";
break;
case 4:
$selected4= " selected = 'selected'";
break;
}
$select_media = "";
return $select_media;
}
/*________________________________________________________________________________________________GENERER_SELECT_MEDIA*/
/*INIT_MAJUSCULE*/
/**
init_majuscule ($attendu, $propose)
\param $attendu array of char : le mot attendu
\param $propose array of char : le mot proposé
\brief $attendu et $propose commencent-ils tous les deux de la même façon
\return integer
\par valeurs de retourpossibles
\li 0 les deux mots commencent par la même majuscule
\li 1 les deux mots commencent par la même minuscule
\li 2 les deux mots commencent par la même lettre mais la majuscule manque dans propose
\li 3 les deux mots commencent par la même lettre mais la majuscule est en trop dans propose
\li 4 les deux mots ne commencent pas par la même lettre attendu et proposé sont majuscules
\li 5 les deux mots ne commencent pas par la même lettre attendu est majuscule proposé est minuscule
\li 6 les deux mots ne commencent pas par la même lettre attendu est minuscule proposé est majuscule
\li 7 les deux mots commencent par des minuscules différentes
*/
function init_majuscule ($attendu, $propose)
{
/**$resultat integer la valeur qui sera retournée*/
$resultat =0;
/**$lettre_a char initiale de $attendu*/
$lettre_a = substr($attendu, 0,1);
/**$lettre_p char initiale de $propose*/
$lettre_p = substr($propose, 0,1);
/** $maj_a boolean true si lettre_a est majuscule*/
$maj_a = est_majuscule($lettre_a);
/** $maj_p boolean true si lettre_p est majuscule*/
$maj_p = est_majuscule($lettre_p);
if ($maj_a)//____________________________________________________________________attendu commence par une majuscule
{//1
if ($maj_p)//_______________________________________________propose commence par une majuscule
{//2
if ($lettre_a == $lettre_p)//même lettre majuscule
{//3
$resultat = 0;
}//3
else//lettre majuscule dans les deux mots mais pas la même lettre
{//3
$resultat = 4;
}//3
}//2
else//_______________________________________________propose commence par une minuscule
{//2
if ($lettre_a == strtoupper($lettre_p)) //même lettre mais erreur de casse
{//3
$resultat = 2;
}//3
else//lettre majuscule dans attendu, minuscule diférente dans proposé
{//3
$resultat = 5;
}//3
}//2
}//1
else
{
if ($maj_p === false)//___________________________propose commence par une minuscule
{//2
if ($lettre_a == $lettre_p)
{//3
$resultat = 1;
}//3
else
{//3
$resultat = 7;
}//3
}//2
else//_____________________________________________propose commence par une majuscule
{//2
if (strtoupper($lettre_a) == $lettre_p)
{//3
$resultat =3;
}//3
else
{//3
$resultat =6;
}//3
}//2
}//1
return $resultat;
}
/*_______________________________________________________________________________________________________INIT_MAJUSCULE*/
/*INSCRIPTION_POSSIBLE*/
/**
inscription_possible($nom, $passe, $identifiant, $passe_identifiant, $email)
\param $nom string : nom souhaité par celui qui s'inscrit
\param $passe string : sera le mot de passe de celui qui s'inscrit
\param $identifiant string : le mot qui autorise une inscription immédiate
\param $passee_identifiant string : le mot dez passe associé
\param $email string : adresse électronique de celui qui s'inscrit
\return integer utilisé par inscrire.php
\par valeurs de retour cumulables
\li 0 : valeur initiale
\li 1 : nom trop court
\li 2 : nom trop long
\li 4 : mot de passe trop court
\li 8 : mot de passe trop long
\li 32: caractères interdits dans le nom
\li 64: caractères interdits dans le mot de passe
\li 128 : email présent mais mal rédigé
\li 512 : identifiant absent email présent et correct
\li 1024 : identifiant absent email absent ou incorrect
\li 2048 : tout va bien
*/
function inscription_possible($nom, $passe, $identifiant, $passe_identifiant, $email)
{
include ("connexions.php");
$message = "";
$Longueur = strlen($nom);
$possible = 0;
if ($Longueur < 5)//_________________________________________________________________________________nom trop court
{
$possible = 1 ;
}
else
{
if ($Longueur > 16)//__________________________________________________________________nom trop long
{
$possible = 2;
}
}
$Longueur = strlen($passe);
if ($Longueur < 5)//_________________________________________________________________________mot de passe trop court
{
$possible += 4 ;
}
else
{
if ($Longueur > 16)//____________________________________________________________mot de passe trop long
{
$possible += 8;
}
}
/* Mot de passe et nom de longueurs acceptables. test de présence de caractères interdits*/
$possible += (tester_mot($nom) == true) ? 32:0;
$possible += (tester_mot($passe) == true) ? 64:0;
if (!filter_var($email,FILTER_VALIDATE_EMAIL))
{
if ($email != "") $possible += 128;
}
/*_____________________________________________________________________________________________________________
INTERDIRE INSCRIPTION IMMEDIATE
il suffit de décommenter la ligne ci-dessous pour empêcher les inscriptions immédiates
*/
//$identifiant ="";
/*Mot de passe et nom corrects. Test de la présence de l'identifiant*/
if ($possible == 0)
{
$mysqli = mysqli_init();
if ($mysqli === false)//___________________________________________________________________initialisation échouée
{
print "$ProblemeSql";
$chaine = "échec de mysqli_init dans ".__FILE__." ligne ".__LINE__;
enregistrer_erreur($chaine);
}
else
{
if ($identifiant == "")
{
if (filter_var($email,FILTER_VALIDATE_EMAIL))
{
$possible = 512;
}
else
{
$possible = 1024;
}
}
else
{
$resultat = $mysqli->real_connect($ServeurMysql, $RootMysql, $PassRootMysql);
$mysqli->set_charset("utf8");
$requete = "select user from mysql.user where `user` = '$identifiant' and `password` = password('$passe_identifiant')";
$resultat = $mysqli->query($requete);
$obj = $resultat->fetch_object();
$user = $obj->user;
if ($user == $identifiant)
{
$possible = 2048;
}
else
{
if (filter_var($email,FILTER_VALIDATE_EMAIL))
{
$possible += 512;
}
else
{
$possible += 1024;
}
}
}
}
}
return $possible;
}
/*================================================================================================INSCRIPTION_POSSIBLE*/
/*NORMALISER_PONCTUATION*/
/**
normaliser_ponctuation($phrase)
\author Michel Barthélémy Billard Sirakawa
\date 30 septembre 2012
\details normalise les espaces entourant les signes de ponctuation.
\param $phrase string
\return $phrase string
*/
function normaliser_ponctuation($phrase)
{
$ponctuations = array("...", ",","?",";",".",":","!");
$phrase = preg_replace ('/ +, +/', ', ', $phrase);
$phrase = preg_replace('/ {2,}/', ' ',$phrase);
/**
$phrase string
\details
\li virgule remplacée par virgule espace
\li point remplacé par point espace
\li deux points, point-virgule, point d'interrogation, point d'exclamation, parenthèses accolades et crochets sont
remplacés par eux-mêmes entourés d'espaces.
*/
$phrase = preg_replace ('/ *, {0,}/', ' , ', $phrase);
$phrase = preg_replace ('/ *\.\.\. {0,}/', ' _ ', $phrase);
$phrase = preg_replace ('/ *\. {0,}/', ' . ', $phrase);
$phrase = preg_replace ('/ *: {0,}/', ' : ', $phrase);
$phrase = preg_replace ('/ *; {0,}/', ' ; ', $phrase);
$phrase = preg_replace ('/ *\? {0,}/', ' ? ', $phrase);
$phrase = preg_replace ('/ *! {0,}/', ' ! ', $phrase);
$phrase = preg_replace ('/ *\( {0,}/', ' ( ', $phrase);
$phrase = preg_replace ('/ *\) {0,}/', ' ) ', $phrase);
$phrase = preg_replace ('/ *\[ {0,}/', ' [ ', $phrase);
$phrase = preg_replace ('/ *\] {0,}/', ' ] ', $phrase);
$phrase = preg_replace ('/ *" {0,}/', ' " ', $phrase);
$phrase = preg_replace ('/ *\{ {0,}/', ' { ', $phrase);
$phrase = preg_replace ('/ *\} {0,}/', ' } ', $phrase);
$phrase = preg_replace ('/ {0,}\' {0,}/', ' $ ', $phrase);
return $phrase;
}
/*==============================================================================================NORMALISER_PONCTUATION*/
/*RECAPITULER======================================================================================================*/
/**
recapituler ($id_utilisateur, $niveau_utilisateur)
\param $id_utilisateur integer l'id de l'utilisateur dont on veut le bilan
\return $table_result string contenant le code html des résultats
\details parcourt la table kalig_resultats et, pour chaque dictée faite par l'utilisateur passé
en paramètre, note le résultat. L'affichage final est fait dictée par dictée, assorti d'un conseil.
*/
function recapituler ($id_eleve, $niveau_utilisateur)
{
session_start();
global $Conseils, $Captions, $SousTitres;
$t_niveaux = array("CP (DB 1 à 7)", "CE 1 (DB 8 à 11)", "CE 2 (DB 12 à 15)", "CM 1 (DB 16 à 19)", "CM 2 (DB 20 à 23)",
"Sixième (DB 24 à 27)", "Cinquième (DB 28 à 31)", "Quatrième (DB 32 à 35)", "Troisième (DB 36 à 39)", "Au delà (DB à partir de 40)" );
$t_niveaux = array_fill(0,8, "CP");
$t_niveaux = array_pad($t_niveaux, 11, "CE 1");
$t_niveaux = array_pad($t_niveaux, 15, "CE 2");
$t_niveaux = array_pad($t_niveaux, 19, "CM 1");
$t_niveaux = array_pad($t_niveaux, 23, "CM 2");
$t_niveaux = array_pad($t_niveaux, 27, "Sixième");
$t_niveaux = array_pad($t_niveaux, 31, "Cinquième");
$t_niveaux = array_pad($t_niveaux, 35, "Quatrième");
$t_niveaux = array_pad($t_niveaux, 39, "Troisième");
$t_niveaux = array_pad($t_niveaux, 50, "Lycée et au-delà");
include ("connexions.php");
$mysqli = mysqli_init();
if ($mysqli === false)//_________________________________________________________________________initialisation échouée
{//1
print "sqlinit $ProblemeSql";
$chaine = "échec de mysqli_init dans ".__FILE__." ligne ".__LINE__;
//enregistrer_erreur($chaine);
exit;
}
else//___________________________________________________________________________________________initialisation réussie
{//1
$resultat = $mysqli->real_connect($ServeurMysql, $RootMysql, $PassRootMysql);
if ($resultat == false)//________________________________________________________connexion échouée
{//2
print "sql $ProblemeSql";
$chaine = "échec de mysqli_connect dans ".__FILE__." ligne ".__LINE__;
//enregistrer_erreur($chaine);
exit;
}
else//___________________________________________________________________________connexion réussie
{//2
$table1 = $NomBdd.".kalig_resultats";
$table2 = $NomBdd.".kalig_textes";
$table_result = $Captions[13].$niveau_utilisateur."
";
$ind =1;
foreach($dictees_faites as $dictee)
{//3
$table_result .= "
{$dictees_faites[$ind]['date']}
{$dictees_faites[$ind]['titre']}
{$dictees_faites[$ind]['auteur']}
{$dictees_faites[$ind]['degre']}
{$dictees_faites[$ind++]['score']}
";
} //3
$table_result .="
";
}//2
}
$table_result .="
";
return $table_result;
}
/*==========================================================================================================RECAPITULER*/
function return_bytes($val) {
$val = trim($val);
$last = strtolower($val[strlen($val)-1]);
switch($last) {
// Le modifieur 'G' est disponible depuis PHP 5.1.0
case 'g':
$val *= 1024;
case 'm':
$val *= 1024;
case 'k':
$val *= 1024;
}
return $val;
}
/*TESTER_MOT*/
/**
tester_mot($mot)
\brief test de validité d'un nom d'utilisateur
\details teste si un nom d'utilisateur cotient des caractères interdits
\param $mot string : le mot à tester
\return boolean true si le mot ne contient pas de caractères interdits
*/
function tester_mot($mot)
{
$Interdits = array("%", "'", '"', "\\");
$Nb = count($Interdits);
$i = 0;
$Trouve = false;
while (($i < $Nb) and ($Trouve == false))
{
$Caractere = $Interdits[$i];
$Trouve = strpos ($mot, $Caractere);
if ($Trouve == false)
{
$i++;
}
}
return ($Trouve !== false) ? true: false ;
}
/*==========================================================================================================ESTER_MOT*/
/*VALORISER_MOT*/
/**
valoriser_mot ($attendu,$propose, $difference)
\param $attendu array of char : le mot attendu
\param $propose array of char : le mot proposé
\param $difference integer : la valeur des différences entre $attendu et $propse calculée par souligner \ref soulignement.php
\details Mode de calcul
\n
Sur un mot de \e n lettres avec \e d exprimant la valeur des erreurs commises:
Si d = 0
valeur = 1
Sinon
Si d > n
valeur = 0
Sinon
$valeur dépend du nombre de lettres différentes et du nombre de lettres manquantes
*/
function valoriser_mot ($attendu,$propose, $difference)
{
mb_internal_encoding( 'UTF-8');
$longueur_a = mb_strlen($attendu);
$longueur_p = mb_strlen($propose);
if ($difference == 0)//____________________________________________________________________________difference vaut 0
{
$valeur =1;
}
else//______________________________________________________________________________________difference ne vaut pas 0
{
if ($difference >= $longueur_p)//________________________difference >= au nombre de lettres du mot proposé
{
$valeur = 0;
}
else//________________________difference < au nombre de lettres du mot proposé
{
$valeur_lettre = 1/$longueur_a;
$ecart = abs($longueur_p - $longueur_a);
$valeur = max(1-($valeur_lettre*($ecart+$difference)),0);
}
}
return $valeur;
}
/*=======================================================================================================VALORISER_MOT*/
/*VERIFIER_AUTOR*/
/**
verifier_autor($mot_clair, $mot_code)
\brief vérification de l'autorisation
\param $mot_clair : l'autorisation véhiculée par $_POST
\param $mot_code : l'autorisation véhiculée par $_SESSION
\details Sur certains systèmes, les sessions posent problème: les valeurs sont transmises de façon aléatoire.
Pour contourner ce problème, ajoutez // avant return $retour et enlevez les // avant return true
*/
function verifier_autor($mot_clair, $mot_code)
{
$force = "08";
if (substr ($mot_code, 0, 60) == crypt($mot_clair, "$2a$".$force."$".substr($mot_code, 60)))
{
$retour = true;
}
else
{
$retour= false;
}
//return $retour
return true ;
}
/*___________________________________________________________________________________________________VERIFIER_AUTOR*/
/*VERIFIER_HACHAGE*/
function verifier_hachage($mot_clair, $mot_code)
{
$force = "08";
if (substr ($mot_code, 0, 60) == crypt($mot_clair, "$2a$".$force."$".substr($mot_code, 60)))
{
return true;
}
else
{
return false;
}
}
/*___________________________________________________________________________________________________VERIFIER_HACHAGE*/
/**
$debogueur string chaine de débogage
\par Débogage
Cette ligne ne doit être décoommentée qu'en cas d'erreur: on vérifie le bon chargement de kaligraphe.php:
si l'on ne voit pas la date, il y a un problème:
on décommente la ligne ci-dessous de fonctions.php
Si on voit le message, l'erreur est dans kaligraphe.php
Si on ne voit pas le message, l'erreur est dans fonctions.php
si on voit la date, il y a un problème dans le script en cours