349 lines
10 KiB
PHP
Executable File
349 lines
10 KiB
PHP
Executable File
<?php
|
|
/**
|
|
* cette classe générique va gèrer les principales informations relatives à un utilisateur
|
|
* on ne se préoccupe pas ici de la façon dont les données sont stockées (bd et/ou fichier)
|
|
* ni des spécificités de l'application
|
|
*
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
require_once("journal_erreurs.php");//pour les bugs...
|
|
class Utilisateur
|
|
{
|
|
public $id_utilisateur;//identifant numérique de l'utilisateur
|
|
protected $pseudo;
|
|
protected $passe; // le mot de passe en clair
|
|
protected $chiffre; // le mot de passe chiffré
|
|
protected $email;
|
|
protected $statut; // les droits sur l'application : s'agit-il d'un administrateur ? d'un simple utilisateur ?
|
|
protected $presentation; // texte de présentation pouvant être saisi par l'utilisateur.
|
|
protected $illustration; // nom du fichier image servant à illustrer le profil de l'utilisateur.
|
|
protected $origine; // indique l'origine de l'utilisateur, par exemple site partenaire, campagne emailing...
|
|
protected $ip_crea; // adresse IP de l'utilisateur lors de la création de son compte.
|
|
protected $time_crea; // timestamp de la création du compte utilisateur
|
|
protected $time_validation; // timestamp de la validation du compte utilisateur
|
|
public $erreurs=array(); // collecte les erreurs rencontrées à l'appel des différentes méthodes
|
|
public $connexion_ok; // booléen : l'utilisateur est-il connecté à son compte
|
|
/**
|
|
* Constructeur qui initialise certains attributs en testant les valeurs fournies
|
|
*
|
|
* @param infos_utilisateur tableau contenant les différentes données correspondant aux attributs homonymes.
|
|
* @return null
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function __construct($infos_utilisateur=null)
|
|
{
|
|
if((!empty($infos_utilisateur))&&(is_array($infos_utilisateur)))
|
|
{
|
|
$erreur_ok=false;
|
|
foreach ($infos_utilisateur as $attribut => $valeur)
|
|
{
|
|
$methode="set_$attribut";
|
|
if(method_exists(__CLASS__,$methode))
|
|
{
|
|
if(!$this->$methode($valeur))
|
|
$erreur_ok=true;
|
|
}
|
|
else
|
|
$this->$attribut=$valeur;
|
|
}
|
|
if(($erreur_ok)&&(empty($this->erreurs)))
|
|
$this->erreurs=(array) ERREUR_IMPREVUE;
|
|
}
|
|
}
|
|
/**
|
|
* Méthode testant la validité d'un pseudo et l'attribuant à l'objet si ok
|
|
*
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_pseudo($pseudo)
|
|
{
|
|
$pseudo=strip_tags(strval(trim($pseudo)));
|
|
$longueur=strlen($pseudo);
|
|
if(($longueur<UTILISATEUR_MIN_PSEUDO)||($longueur>UTILISATEUR_MAX_PSEUDO))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_PSEUDO_LONG);
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
$this->pseudo=$pseudo;
|
|
return true;
|
|
}
|
|
}
|
|
/**
|
|
* Méthode testant la validité d'un mot de passe avant de le chiffrer et de l'attribuer à l'objet si ok
|
|
*
|
|
* @param mot de passe non chiffré
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_passe($passe)
|
|
{
|
|
$passe=strval(trim($passe));
|
|
$longueur=strlen($passe);
|
|
if(($longueur<UTILISATEUR_MIN_PASSE)||($longueur>UTILISATEUR_MAX_PASSE))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_PASSE_LONG);
|
|
return false;
|
|
}
|
|
$chiffre=chiffrement($passe);
|
|
if($chiffre!=false)
|
|
{
|
|
$this->passe=$passe;
|
|
$this->chiffre=$chiffre;
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
/**
|
|
* Méthode testant la validité d'un email et l'affectant à l'objet si ok
|
|
*
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_email($email)
|
|
{
|
|
$email=strip_tags(strval(trim($email)));
|
|
$longueur=strlen($email);
|
|
if($longueur>UTILISATEUR_MAX_EMAIL)
|
|
$messages[]=ERREUR_UTILISA_EMAIL_LONG;
|
|
if(!filter_var($email,FILTER_VALIDATE_EMAIL))
|
|
$messages[]=ERREUR_EMAIL_ADRESSE_FORMAT;
|
|
if(empty($messages))
|
|
{
|
|
$this->email=$email;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,$messages);
|
|
return false;
|
|
}
|
|
}
|
|
/**
|
|
* Méthode testant la validité du statut et l'affectant à l'objet si ok
|
|
*
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_statut($statut)
|
|
{
|
|
$valeurs_ok=explode("|",UTILISATEUR_STATUTS);
|
|
if(empty($valeurs_ok))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_UTILISA_STATUTS_EXISTE));
|
|
return false;
|
|
}
|
|
if (!in_array($statut,$valeurs_ok))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_UTILISA_STATUT_VALIDE." >> $statut"));
|
|
return false;
|
|
}
|
|
$this->statut=$statut;
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode testant le texte de description avant de l'attribuer
|
|
*
|
|
* @return false si valeur non acceptée, true sinon
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_presentation($presentation)
|
|
{
|
|
if(!empty($presentation))
|
|
{
|
|
$presentation=strip_tags(strval(trim($presentation)));
|
|
$longueur=strlen($presentation);
|
|
if($longueur>UTILISATEUR_MAX_PRESENTATION)
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_PRESENTATION_LONG);
|
|
return false;
|
|
}
|
|
$this->presentation=$presentation;
|
|
return true;
|
|
}
|
|
else
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode testant la validité d'un fichier image (nom, format, taille...)
|
|
* Si ok, une miniature est créée localement et son adresse affectée à l'objet
|
|
* ! le pseudo doit donc être attribué à l'objet avant car il sert à nommer le fichier image
|
|
*
|
|
* @param $fichier : les infos du fichier qui vient d'être téléchargé
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_illustration($fichier)
|
|
{
|
|
if(!empty($fichier))
|
|
{
|
|
$adresse_temp=$fichier["tmp_name"];
|
|
if(!file_exists($adresse_temp))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_EXISTE." >> ".htmlentities($adresse_temp,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
if(empty($this->pseudo))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_UTILISA_PSEUDO_ABSENT));
|
|
return false;
|
|
}
|
|
$extension=strtolower(strrchr($fichier["name"],"."));
|
|
if (strpos(UTILISATEUR_ILLUS_EXTENSIONS,$extension)===false)
|
|
$messages[]=ERREUR_IMAGE_FORMAT;
|
|
$taille_max=min(intval(str_replace("M","000000",ini_get("upload_max_filesize"))),UTILISATEUR_ILLUS_MAX_TAILLE);
|
|
$taille_fichier=filesize($adresse_temp);
|
|
if($taille_fichier>$taille_max)
|
|
$messages[]=ERREUR_FICHIER_POIDS." (maximum : ".($taille_max/1000)." ko)";
|
|
if(empty($messages))
|
|
{
|
|
$pseudo=nettoye_chaine(strtolower($this->pseudo));
|
|
$adresse_illustration=UTILISATEUR_ILLUS_REP."/".$pseudo[0]."/".$pseudo.$extension;
|
|
$i=1;
|
|
while(file_exists($adresse_illustration))
|
|
{
|
|
$i++;
|
|
$adresse_illustration=UTILISATEUR_ILLUS_REP."/".$pseudo[0]."/".$pseudo.$i.$extension;
|
|
}
|
|
if(!file_exists(UTILISATEUR_ILLUS_REP."/".$pseudo[0]."/"))
|
|
{
|
|
if(!mkdir(UTILISATEUR_ILLUS_REP."/".$pseudo[0]."/",UTILISATEUR_ILLUS_REP_CHMOD,true))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_REP_CREA." >> ".UTILISATEUR_ILLUS_REP."/".$pseudo[0]."/"));
|
|
return false;
|
|
}
|
|
}
|
|
if((import_image($adresse_temp,$adresse_illustration,0,UTILISATEUR_ILLUS_MAX_LARGEUR)===true))
|
|
{
|
|
$this->illustration=substr(strrchr($adresse_illustration,"/"),1);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_IMAGE_CREATION));
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,$messages);
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
$this->illustration="";
|
|
}
|
|
/**
|
|
* Méthode testant la validité d'une origine et l'affectant à l'objet si ok
|
|
* la valeur fournie doit faire partie de celles déclarées ou être nulle
|
|
*
|
|
* @param origin chaine de caractères
|
|
* @return booléen
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_origine($origine)
|
|
{
|
|
if(!empty($origine))
|
|
{
|
|
$valeurs_ok=explode("|",UTILISATEUR_ORIGINES);
|
|
if(empty($valeurs_ok))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_UTILISA_ORIGINES_EXISTE));
|
|
return false;
|
|
}
|
|
if (!in_array($origine,$valeurs_ok))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_UTILISA_ORIGINE_VALIDE." >> $origine"));
|
|
return false;
|
|
}
|
|
$this->origine=$origine;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
$this->origine="inconnue";
|
|
return true;
|
|
}
|
|
}
|
|
/**
|
|
* Méthode supprimant le fichier image d'un utilisateur
|
|
*
|
|
* @param null
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function suppr_illustration()
|
|
{
|
|
if(!empty($this->illustration))
|
|
{
|
|
$fichier=$this->illustration;
|
|
$adresse_illustration=UTILISATEUR_ILLUS_REP."/".$fichier[0]."/".$fichier;
|
|
if(!file_exists($adresse_illustration))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_EXISTE." >> ".htmlentities($adresse_illustration,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
if(!unlink($adresse_illustration))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_SUPPR." >> ".htmlentities($adresse_illustration,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
$this->illustration="";
|
|
return true;
|
|
}
|
|
}
|
|
/**
|
|
* Méthode supprimant toutes les fichiers illustration des utilisateurs + les sous-répertoires
|
|
*
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
static function suppr_illustrations()
|
|
{
|
|
if(supprime_repertoire(UTILISATEUR_ILLUS_REP."/",false))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
/**
|
|
* Méthode retournant la valeur des attributs d'un utilisateur dans un tableau
|
|
*
|
|
* @param attributs : tableau php listant le nom des attributs que je souhaite exporter
|
|
* @return tableau php contenant les attributs et leurs valeurs. false si erreur.
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function export_utilisateur($attributs)
|
|
{
|
|
if(!is_array($attributs))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
foreach ($attributs as $attribut)
|
|
{
|
|
if (isset($this->$attribut))
|
|
$tab[$attribut]=$this->$attribut;
|
|
}
|
|
return $tab;
|
|
}
|
|
/**
|
|
* Affichage par défaut d'un objet
|
|
*
|
|
* @return chaîne de caractères listant la valeur de chaque attribut
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function __toString()
|
|
{
|
|
$texte="<h3>".__CLASS__."</h3>";
|
|
foreach($this as $key => $value)
|
|
{
|
|
if(is_array($value))
|
|
$value=affiche_tableau($value,"<li>#valeur</li>","<ul>","</ul>");
|
|
$texte.="$key : $value\n";
|
|
}
|
|
return $texte;
|
|
}
|
|
} |