2163 lines
89 KiB
PHP
Executable File
2163 lines
89 KiB
PHP
Executable File
<?php
|
|
/**
|
|
* classe dérivée de la classe Utilisateurs
|
|
* on va spécifier ici tout ce qui est propre à cette application :
|
|
* manipulation base de données, cache, stockage des sessions, attributs supplémentaires...
|
|
*
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
require_once("utilisateur.php");
|
|
class FclFlux_utilisateur extends Utilisateur
|
|
{
|
|
protected $fuseau_horaire;// utile pour heure envoi des abonnements / email
|
|
/**
|
|
* Constructeur qui initialise certains attributs en testant les valeurs fournies
|
|
* Recopier de la classe héritée car attribut supplémentaire
|
|
*
|
|
* @param infos_utilisateur tableau contenant les différentes données correspondant aux attributs homonymes.
|
|
* @return null
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function __construct($info=null)
|
|
{
|
|
if((!empty($info))&&(is_array($info)))
|
|
{
|
|
$erreur_ok=false;
|
|
foreach ($info 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é du fuseau horaire et l'attribuant à l'objet si ok
|
|
*
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_fuseau_horaire($fuseau=null)
|
|
{
|
|
$fuseau_defaut=date_default_timezone_get();
|
|
if(empty($fuseau))
|
|
$fuseau=$fuseau_defaut;
|
|
else
|
|
{
|
|
$tz=new DateTimeZone($fuseau_defaut);
|
|
$zones=$tz->listIdentifiers();
|
|
if(!in_array($fuseau,$zones))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT." >> ".htmlentities($fuseau,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
}
|
|
$this->fuseau_horaire=$fuseau;
|
|
return true;
|
|
}
|
|
/**
|
|
* Test si une valeur donnée pour un champ est déjà utilisée par un autre utilisateur
|
|
* id_utilisateur doit être connu si il s'agit d'un utilisateur existant
|
|
*
|
|
* @param le champ recherché, l'attribut devant avoir le même nom
|
|
* @return true si valeur non trouvée
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function est_libre($champ="pseudo")
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(empty($this->$champ))//à ajouter aussi dans les autres classes
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
if(empty($this->id_utilisateur))//nouvel utilisateur non encore enregistré
|
|
{
|
|
$prepare=$Bd->prepare("SELECT id_utilisateur FROM utilisateurs WHERE $champ=:valeur");
|
|
$recherche=$prepare->execute(array(":valeur"=>$this->$champ));
|
|
}
|
|
else
|
|
{
|
|
$prepare=$Bd->prepare("SELECT id_utilisateur FROM utilisateurs WHERE ($champ=:valeur and id_utilisateur!=:id)");
|
|
$recherche=$prepare->execute(array(":valeur"=>$this->$champ,":id"=>$this->id_utilisateur));
|
|
}
|
|
if((test_requete(__FILE__,__LINE__,$recherche,$prepare)===false)) return false;
|
|
$resultat=$prepare->fetch();
|
|
$prepare=null;
|
|
if(empty($resultat))//pas de doublon
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
/**
|
|
* Méthode cherchant un utilisateur dans le bd via une valeur l'identifiant de manière unique
|
|
* champs acceptés : id_utilisateur,pseudo,email
|
|
*
|
|
* @param la valeur recherchée, le champ de recherche et les champs souhaités en sortie
|
|
* @return les données de la table dans un tableau si trouvé. false si pas trouvé ou en cas d'erreur
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
static function recherche($valeur,$champ_recherche="id_utilisateur",$champ_sortie="*")
|
|
{
|
|
global $Bd;
|
|
if(strpos("id_utilisateur,pseudo,email",$champ_recherche)===false)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_CHAMP_RECHERCHE." >> ".htmlentities($champ_recherche,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
$prepare=$Bd->prepare("SELECT $champ_sortie FROM utilisateurs WHERE $champ_recherche=:valeur");
|
|
$recherche=$prepare->execute(array(":valeur"=>$valeur));
|
|
if((test_requete(__FILE__,__LINE__,$recherche,$prepare)===false)) return false;
|
|
$resultat=$prepare->fetch(PDO::FETCH_ASSOC);
|
|
$prepare=null;
|
|
if(empty($resultat))
|
|
return false;
|
|
else
|
|
return $resultat;
|
|
}
|
|
/**
|
|
* Méthode de recherche parmi les comptes utilisateur.
|
|
*
|
|
* @param l'expression recherchée + les champs souhaités en sortie
|
|
* @return les données de la table dans un tableau php si trouvé. false si pas trouvé ou en cas d'erreur.
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
static function recherche_globale($recherche,$champ_sortie="*")
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
$recherche=strip_tags(strval(trim($recherche)));
|
|
$recherche_like="%".str_replace(" ","%",$recherche)."%";
|
|
$prepare=$Bd->prepare("SELECT $champ_sortie FROM utilisateurs WHERE (pseudo LIKE :recherche_l OR email LIKE :recherche_l OR presentation LIKE :recherche_l OR id_utilisateur=:recherche) ORDER BY pseudo ASC;");
|
|
$recherche=$prepare->execute(array(":recherche_l"=>$recherche_like,":recherche"=>$recherche));
|
|
if((test_requete(__FILE__,__LINE__,$recherche,$prepare)===false)) return false;
|
|
$resultat=$prepare->fetchAll(PDO::FETCH_ASSOC);
|
|
$prepare=null;
|
|
if(empty($resultat))
|
|
return false;
|
|
else
|
|
return $resultat;
|
|
}
|
|
/**
|
|
* Méthode vérifiant que l'utilisateur est un administrateur
|
|
*
|
|
* @return booléen
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function est_admin()
|
|
{
|
|
global $Bd;
|
|
if(empty($this->id_utilisateur))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$infos=self::recherche($this->id_utilisateur,"id_utilisateur","statut");
|
|
if(empty($infos))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT." >> ".intval($this->id_utilisateur)));
|
|
return false;
|
|
}
|
|
if($infos["statut"]=="administrateur")
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
/**
|
|
* Méthode créant le fichier cache contenant les infos d'un utilisateur
|
|
* id_utilisateur doit être connu
|
|
*
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function crea_cache()
|
|
{
|
|
if(empty($this->id_utilisateur))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$info=self::recherche($this->id_utilisateur,"id_utilisateur","pseudo,email,statut,presentation,illustration,time_validation");
|
|
if($info===false)
|
|
return false;
|
|
/*if(empty($info["time_validation"]))-> à revoir, bug lors création compte
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_ACTION_NON_AUTORISEE." >> ".intval($this->id_utilisateur)));
|
|
return false;
|
|
}*/
|
|
$id=strval($this->id_utilisateur);
|
|
return crea_cache(CACHE_REP_UTILISATEURS."/".$id[0]."/$id.txt",$info);
|
|
}
|
|
/**
|
|
* Méthode de suppression du fichier cache contenant les infos utiles d'un utilisateur
|
|
* id_utilisateur doit être connu
|
|
*
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function suppr_cache()
|
|
{
|
|
if(empty($this->id_utilisateur))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$fichier=$this->id_utilisateur.".txt";
|
|
$chemin=CACHE_REP."/".CACHE_REP_UTILISATEURS."/".$fichier[0]."/".$fichier;
|
|
if((file_exists($chemin))&&(!unlink($chemin)))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_SUPPR." >> ".htmlentities($chemin,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
//ses marque-pages
|
|
$chemin=CACHE_REP."/".CACHE_REP_UTILISATEURS."/".$fichier[0]."/MP-$fichier";
|
|
if((file_exists($chemin))&&(!unlink($chemin)))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_SUPPR." >> ".htmlentities($chemin,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
//ses abonnements
|
|
$chemin=CACHE_REP."/".CACHE_REP_UTILISATEURS."/".$fichier[0]."/abo-$fichier";
|
|
if((file_exists($chemin))&&(!unlink($chemin)))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_SUPPR." >> ".htmlentities($chemin,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode enregistrant un nouvel utilisateur lors de la création de son compte
|
|
* pseudo, email et origine doivent être fournis
|
|
*
|
|
* @param $crea_session à true si il faut créer une session à l'utilisateur en cas de succès,
|
|
* $validation=false si compte créé sans devoir valider l'email (compte créé par un administrateur)
|
|
* $validation=true si processus de validation classique
|
|
* $validation=ext si la suite est traitée par une méthode externe (ex.: publication d'une annonce)
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function ajout($crea_session=false,$validation=true)
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(empty($this->pseudo)||(empty($this->email))||(empty($this->origine)))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_CHAMPS_ABSENTS);
|
|
return false;
|
|
}
|
|
$pseudo_depart=$this->pseudo;
|
|
$i=2;$trouve=false;
|
|
while((strlen($this->pseudo)<=UTILISATEUR_MAX_PSEUDO)&&(!$trouve))
|
|
{
|
|
if(!($this->est_libre("pseudo")))
|
|
{//pour ne pas bloquer, on cherche un pseudo libre en incrémentant
|
|
$this->pseudo=$pseudo_depart.$i;
|
|
$i++;
|
|
}
|
|
else
|
|
$trouve=true;
|
|
}
|
|
if(!$trouve)//je suis sorti parce que trop de caractères...
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_PSEUDO_LIBRE);
|
|
return false;
|
|
}
|
|
if(!($this->est_libre("email")))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_EMAIL_LIBRE);
|
|
return false;
|
|
}
|
|
$ip=getIp();
|
|
if($ip===false)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_AUTORISES));
|
|
return false;
|
|
}
|
|
if(empty($this->fuseau_horaire))
|
|
$this->fuseau_horaire=date_default_timezone_get();
|
|
$this->ip_crea=$ip;
|
|
$this->time_crea=time();
|
|
$this->statut="utilisateur";//toujours le cas lors d'une création de compte. Attribut nécessaire pour créer session + loin.
|
|
$prepare=$Bd->prepare("INSERT INTO utilisateurs (pseudo,email,ip_crea,time_crea,origine,fuseau_horaire) VALUES (:pseudo,:email,:ip_crea,:time_crea,:origine,:fuseau)");
|
|
$ajout=$prepare->execute(array(':pseudo'=>$this->pseudo,':email'=>$this->email,':ip_crea'=>$this->ip_crea,':time_crea'=>$this->time_crea,':origine'=>$this->origine,':fuseau'=>$this->fuseau_horaire));
|
|
if((test_requete(__FILE__,__LINE__,$ajout,$prepare)===false)) return false;
|
|
$this->id_utilisateur=$Bd->lastInsertId();
|
|
$prepare=null;
|
|
if(empty($this->id_utilisateur))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_AJOUT." >> ".htmlentities($this->email,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
// + sauvegardes
|
|
$prepare_svg=$Bd->prepare("INSERT INTO utilisateurs_svg (id_utilisateur,time_maj,pseudo,email,ip_crea,time_crea,origine,fuseau_horaire) VALUES (:id,:time_maj,:pseudo,:email,:ip_crea,:time_crea,:origine,:fuseau)");
|
|
$svg=$prepare_svg->execute(array(':id'=>$this->id_utilisateur,':time_maj'=>$this->time_crea,':pseudo'=>$this->pseudo,':email'=>$this->email,':ip_crea'=>$this->ip_crea,':time_crea'=>$this->time_crea,':origine'=>$this->origine,':fuseau'=>$this->fuseau_horaire));
|
|
if((test_requete(__FILE__,__LINE__,$svg,$prepare_svg)===false)) return false;
|
|
$prepare_svg=null;
|
|
$ticket=crea_ticket($this->id_utilisateur,TICKET_VALID_REP,"valid");
|
|
if($ticket===false)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_CREA));
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_VALIDATION_MESSAGE);
|
|
}
|
|
else
|
|
{
|
|
$id=substr($ticket,(strrpos($ticket,"/"))+1);
|
|
if($validation===true)
|
|
{//l'utilisatdeur doit valider son compte
|
|
// + envoi du message avec PHPMailer
|
|
$Mail_expediteur_email=EMAIL_TRANSACTIONNEL_DE;
|
|
$Mail_expediteur_nom=SITE_NOM;
|
|
$Mail_destinataire_email=$this->email;
|
|
$Mail_destinataire_nom=$this->pseudo;
|
|
$Mail_sujet=COMPTE_VALIDATION_OBJET;
|
|
// message alternatif lorsque le html n'est pas lu :
|
|
$Mail_boby_txt=str_replace(array("__NOM_UTILISATEUR__","__ID__"),array($this->pseudo,$id),COMPTE_VALIDATION_CORPS);
|
|
//-- version html :
|
|
//texte invisible (sauf certains webmail ?) :
|
|
$Mail_html_sujet="Valider sans tarder votre inscription sur ".SITE_NOM.".";
|
|
//entête avant logo :
|
|
$Mail_html_header="<p>Valider sans tarder votre inscription sur ".SITE_NOM.".</p>";
|
|
//texte du message, hors liste de liens :
|
|
$Mail_html_intro=str_replace("__NOM_UTILISATEUR__",htmlentities($this->pseudo),COMPTE_VALIDATION_CORPS_HTML);
|
|
//liens sous forme de grands boutons. L'ancre ne doit donc pas être trop longue :
|
|
$Mail_html_liens_action[0]="<a href='".PAGE_VALIDATION_COMPTE.$id."'>Valider.</a>";
|
|
//footer du mail html :
|
|
$Mail_html_footer="<p><a href='".SITE_URL."'>".SITE_NOM."</a>, ".SITE_SLOGAN."</p>";
|
|
$Mail_boby_html="";
|
|
ob_start();
|
|
include(BASE_REP."../www/".TEMPLATE_REP."/mail/defaut.php");
|
|
$Mail_boby_html=ob_get_contents();
|
|
ob_end_clean();
|
|
$SMTP_CustomHeader["X-Mailin-Tag"]="inscription";
|
|
// connexion au serveur smtp si il y a lieu :
|
|
require(BASE_REP."../divers/phpmailer-initialise.php");
|
|
require(BASE_REP."../divers/phpmailer-envoi.php");
|
|
if(!$mail->Send())
|
|
{
|
|
sleep(2);// blocage temporaire smtp ???
|
|
if(!$mail->Send())
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_EMAIL_ENVOI.$mail->ErrorInfo));
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_VALIDATION_MESSAGE);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
else if($validation=="ext")
|
|
$this->ticket=$id;
|
|
else//compte automatiquement validé
|
|
$this->valide($id,false);
|
|
}
|
|
if((empty($this->erreurs))&&($crea_session))
|
|
$this->crea_session(false,true);
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode appelée lors de la validation de son compte par un utilisateur
|
|
* On va notamment générer son mot de passe et l'enregister
|
|
*
|
|
* @param l'adresse du ticket contenant l'identifiant de l'utilisateur, $crea_session=true si on souhaite créer une session temporaire
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function valide($ticket,$crea_session=false)
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(strpos($ticket,"/")!==false)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_AUTORISES));
|
|
return false;
|
|
}
|
|
if(!file_exists(TICKET_VALID_REP."/$ticket"))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_VALIDATION_LIEN);
|
|
return false;
|
|
}
|
|
$id_utilisateur=file_get_contents(TICKET_VALID_REP."/$ticket");
|
|
if(empty($id_utilisateur))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_EXISTE." >> ".htmlentities($ticket,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
unlink(TICKET_VALID_REP."/$ticket");
|
|
$info=self::recherche((int) $id_utilisateur);
|
|
if($info===false)
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_VALIDATION_EXPIRE);
|
|
return false;
|
|
}
|
|
if(!empty($info["time_validation"]))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_VALIDATION_DOUBLE);
|
|
return false;
|
|
}
|
|
$passe=crea_passe();
|
|
if($passe===false)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_UTILISA_PASSE_CREA." >> ".intval($id_utilisateur)));
|
|
return false;
|
|
}
|
|
$this->set_passe($passe);
|
|
if(empty($this->erreurs))
|
|
{
|
|
$this->id_utilisateur=(int) $id_utilisateur;
|
|
$this->time_validation=time()+1;//+1 pour éviter bug clé primaire quand la validation suit l'enregistrement du compte
|
|
$prepare=$Bd->prepare("UPDATE utilisateurs SET passe=:passe,time_validation=:time where id_utilisateur=:id");
|
|
$maj=$prepare->execute(array(':passe'=>$this->chiffre,':time'=>$this->time_validation,':id'=>$this->id_utilisateur));
|
|
if((test_requete(__FILE__,__LINE__,$maj,$prepare)===false)) return false;
|
|
$nb_enreg=$prepare->rowCount();
|
|
$prepare=null;
|
|
if($nb_enreg==0)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_MAJ." >> ".intval($this->id_utilisateur)));
|
|
return false;
|
|
}
|
|
$prepare_svg=$Bd->prepare("INSERT INTO utilisateurs_svg (id_utilisateur,time_maj,passe,time_validation) VALUES (:id,:time_maj,:passe,:time)");
|
|
$svg=$prepare_svg->execute(array(':id'=>$this->id_utilisateur,':time_maj'=>$this->time_validation,':passe'=>$this->chiffre,':time'=>$this->time_validation));
|
|
if((test_requete(__FILE__,__LINE__,$svg,$prepare_svg)===false)) return false;
|
|
$prepare_svg=null;
|
|
$this->pseudo=$info["pseudo"];
|
|
$this->email=$info["email"];
|
|
// + envoi du message avec PHPMailer
|
|
$Mail_expediteur_email=EMAIL_TRANSACTIONNEL_DE;
|
|
$Mail_expediteur_nom=SITE_NOM;
|
|
$Mail_destinataire_email=$this->email;
|
|
$Mail_destinataire_nom=$this->pseudo;
|
|
$Mail_sujet=ENVOI_MOT_PASSE_OBJET;
|
|
// message alternatif lorsque le html n'est pas lu :
|
|
$Mail_boby_txt=str_replace(array("__NOM_UTILISATEUR__","__PASSE__"),array($this->pseudo,$this->passe),ENVOI_MOT_PASSE_CORPS);
|
|
//-- version html :
|
|
//texte invisible (sauf certains webmail ?) :
|
|
$Mail_html_sujet="Bienvenue sur ".SITE_NOM.". Voici votre mot de passe.";
|
|
//entête avant logo :
|
|
$Mail_html_header="<p>Bienvenue sur ".SITE_NOM.". Voici votre mot de passe.</p>";
|
|
//texte du message, hors liste de liens :
|
|
$Mail_html_intro=str_replace(array("__NOM_UTILISATEUR__","__PASSE__"),array($this->pseudo,$this->passe),ENVOI_MOT_PASSE_CORPS_HTML);
|
|
$Mail_html_items[0]="<p>Pour vous connecter, <a href='".PAGE_CONNEXION."'>cliquez-ici</a>.</p>";
|
|
$Mail_html_items[1]="<p>Pour modifier votre mot de passe ou votre email, <a href='".PAGE_MAJ_IDENTIFIANT."'>cliquez-ici</a>.</p>";
|
|
$Mail_html_items[2]="<p>Pour modifier vos autres informations (pseudo, ...), <a href='".PAGE_MAJ_INFOS_PERSO."'>cliquez-ici</a>.</p>";
|
|
$Mail_html_items[3]="<p>Pour gérer vos abonnements (sites, jours d'envoi...), <a href='".PAGE_ABO_LISTE."'>cliquez-ici</a>.</p>";
|
|
$Mail_html_items[4]="<p>Pour stopper temporairement l'envoi de vos abonnements (vacances...), <a href='".PAGE_ABSENCES_LISTE."'>cliquez-ici</a>.</p>";
|
|
$Mail_html_items[5]="<p>Pour proposer une actualité locale (spectacle, conférence, promo ...), <a href='".PAGE_AJOUT_POST."'>cliquez-ici</a>.</p>";
|
|
$Mail_html_complement="<p><b>Dernier conseil :</b> pour éviter que les messages de ".SITE_NOM." arrivent dans votre dossier \"spam\", ajoutez <a href='mailto:".EMAIL_MAILINGS."'>".EMAIL_MAILINGS."</a> à votre carnet d'adresses.</p>";
|
|
//footer du mail html :
|
|
$Mail_html_footer="<p><a href='".SITE_NOM."'>".SITE_NOM."</a>, ".SITE_SLOGAN."</p>";
|
|
$Mail_boby_html="";
|
|
ob_start();
|
|
include(BASE_REP."../www/".TEMPLATE_REP."/mail/defaut.php");
|
|
$Mail_boby_html=ob_get_contents();
|
|
ob_end_clean();
|
|
$SMTP_CustomHeader["X-Mailin-Tag"]="bienvenue";
|
|
// connexion au serveur smtp si il y a lieu :
|
|
require(BASE_REP."../divers/phpmailer-initialise.php");
|
|
require(BASE_REP."../divers/phpmailer-envoi.php");
|
|
if(!$mail->Send())
|
|
{
|
|
sleep(2);// blocage temporaire smtp ???
|
|
if(!$mail->Send())
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_EMAIL_ENVOI.$mail->ErrorInfo));
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_EMAIL_ENVOI);
|
|
}
|
|
}
|
|
$this->crea_cache();
|
|
$this->statut=$info["statut"];
|
|
if((empty($this->erreurs))&&($crea_session))
|
|
$this->crea_session(false);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
/**
|
|
* Méthode enregistrant une mise à jour des informations de l'utilisateur
|
|
* l'email et le mot de passe nécessitent une procédure spéciale
|
|
* @param @suppr_illustration pour les demandes de suppression de l'image,
|
|
* $identifiants_ok si on peut changer l'email et le mot de passe sans passer par la procédure normale (doit être demandé par un administrateur)
|
|
*
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function actualise($suppr_illustration=false,$identifiants_ok=false)
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(!isset($this->id_utilisateur))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
if(!($this->est_libre("pseudo")))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_PSEUDO_LIBRE);
|
|
$this->suppr_illustration();
|
|
return false;
|
|
}
|
|
if($suppr_illustration)
|
|
$this->illustration="";//pour suppression réelle ci-dessous
|
|
if(isset($this->illustration))
|
|
{//je viens de télécharger une nouvelle illustration ou souhaite enregistrer une suppression
|
|
$ancien=self::recherche($this->id_utilisateur,"id_utilisateur","illustration");
|
|
if($ancien===false)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_RECHERCHE." >> ".$this->id_utilisateur));
|
|
return false;
|
|
}
|
|
$ancien_illustration=$ancien["illustration"];
|
|
if(!empty($ancien_illustration))
|
|
unlink(UTILISATEUR_ILLUS_REP."/".$ancien_illustration[0]."/".$ancien_illustration);
|
|
$prepare=$Bd->prepare("UPDATE utilisateurs SET illustration=:illustration WHERE id_utilisateur=:id_utilisateur;");
|
|
$maj=$prepare->execute(array(':illustration'=>$this->illustration,':id_utilisateur'=>$this->id_utilisateur));
|
|
// + sauvegardes
|
|
$prepare_svg=$Bd->prepare("INSERT INTO utilisateurs_svg (id_utilisateur,time_maj,illustration) VALUES (:id,:time_maj,:illustration)");
|
|
$svg=$prepare_svg->execute(array(':id'=>$this->id_utilisateur,':time_maj'=>time()+1,':illustration'=>$this->illustration));//à revoir, +1 pour éviter doublon sql
|
|
}
|
|
elseif(($identifiants_ok)&&(!empty($this->email))&&($_SESSION["statut"]=="administrateur"))
|
|
{
|
|
if(!($this->est_libre("email")))//doit tout de même être unique...
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_EMAIL_LIBRE);
|
|
return false;
|
|
}
|
|
if(empty($this->passe))
|
|
{
|
|
$prepare=$Bd->prepare("UPDATE utilisateurs SET pseudo=:pseudo,presentation=:presentation,email=:email,fuseau_horaire=:fuseau WHERE id_utilisateur=:id_utilisateur;");
|
|
$maj=$prepare->execute(array(':pseudo'=>$this->pseudo,':presentation'=>$this->presentation,':id_utilisateur'=>$this->id_utilisateur,':email'=>$this->email,':fuseau'=>$this->fuseau_horaire));
|
|
// + sauvegardes
|
|
$prepare_svg=$Bd->prepare("INSERT INTO utilisateurs_svg (id_utilisateur,time_maj,pseudo,presentation,email,fuseau_horaire) VALUES (:id,:time_maj,:pseudo,:presentation,:email,:fuseau)");
|
|
$svg=$prepare_svg->execute(array(':id'=>$this->id_utilisateur,':time_maj'=>time(),':pseudo'=>$this->pseudo,':presentation'=>$this->presentation,':email'=>$this->email,':fuseau'=>$this->fuseau_horaire));
|
|
}
|
|
else
|
|
{
|
|
$prepare=$Bd->prepare("UPDATE utilisateurs SET pseudo=:pseudo,presentation=:presentation,email=:email,passe=:passe,fuseau_horaire=:fuseau WHERE id_utilisateur=:id_utilisateur;");
|
|
$maj=$prepare->execute(array(':pseudo'=>$this->pseudo,':presentation'=>$this->presentation,':id_utilisateur'=>$this->id_utilisateur,':email'=>$this->email,':passe'=>$this->chiffre,':fuseau'=>$this->fuseau_horaire));
|
|
// + sauvegardes
|
|
$prepare_svg=$Bd->prepare("INSERT INTO utilisateurs_svg (id_utilisateur,time_maj,pseudo,presentation,email,passe,fuseau_horaire) VALUES (:id,:time_maj,:pseudo,:presentation,:email,:passe,:fuseau)");
|
|
$svg=$prepare_svg->execute(array(':id'=>$this->id_utilisateur,':time_maj'=>time(),':pseudo'=>$this->pseudo,':presentation'=>$this->presentation,':email'=>$this->email,':passe'=>$this->chiffre,':fuseau'=>$this->fuseau_horaire));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$prepare=$Bd->prepare("UPDATE utilisateurs SET pseudo=:pseudo,presentation=:presentation,fuseau_horaire=:fuseau WHERE id_utilisateur=:id_utilisateur;");
|
|
$maj=$prepare->execute(array(':pseudo'=>$this->pseudo,':presentation'=>$this->presentation,':id_utilisateur'=>$this->id_utilisateur,':fuseau'=>$this->fuseau_horaire));
|
|
// + sauvegardes
|
|
$prepare_svg=$Bd->prepare("INSERT INTO utilisateurs_svg (id_utilisateur,time_maj,pseudo,presentation,fuseau_horaire) VALUES (:id,:time_maj,:pseudo,:presentation,:fuseau)");
|
|
$svg=$prepare_svg->execute(array(':id'=>$this->id_utilisateur,':time_maj'=>time(),':pseudo'=>$this->pseudo,':presentation'=>$this->presentation,':fuseau'=>$this->fuseau_horaire));
|
|
}
|
|
if((test_requete(__FILE__,__LINE__,$maj,$prepare)===false))
|
|
{
|
|
$this->suppr_illustration();
|
|
return false;
|
|
}
|
|
$prepare=null;
|
|
if((test_requete(__FILE__,__LINE__,$svg,$prepare_svg)===false)) return false;
|
|
$prepare_svg=null;
|
|
$this->crea_cache();
|
|
}
|
|
/**
|
|
* Méthode enregistrant une mise à jour des informations de connexion (email / mot de passe)
|
|
* l'ancien mot de passe doit nécessairement être fourni et contrôlé
|
|
* dans le cas d'un chgt d'email, un lien de vérification sera envoyé sur la nouvelle adresse
|
|
*
|
|
* @param le nouveau mot de passe si chgt
|
|
* @return false en cas d'erreur, null sinon.
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function actualise_infos_connexion($nouveau_passe="")
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if((empty($this->id_utilisateur))||(empty($this->email))||(empty($this->passe)))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$resultat=self::recherche($this->id_utilisateur,"id_utilisateur","passe,email,pseudo");
|
|
if($resultat===false) return false;
|
|
if(!(password_verify($this->passe,$resultat["passe"])))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_PASSE_CORRECT);
|
|
return false;
|
|
}
|
|
if($this->email!=$resultat["email"])
|
|
{
|
|
if(!($this->est_libre("email")))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_EMAIL_LIBRE);
|
|
return false;
|
|
}
|
|
$ticket=crea_ticket($this->email."|".$this->id_utilisateur,TICKET_VALID_REP,"email");
|
|
if($ticket===false)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_CREA));
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
// + envoi du message avec PHPMailer
|
|
$Mail_expediteur_email=EMAIL_TRANSACTIONNEL_DE;
|
|
$Mail_expediteur_nom=SITE_NOM;
|
|
$Mail_destinataire_email=$this->email;
|
|
$Mail_destinataire_nom=$this->pseudo;
|
|
$Mail_sujet=NOUVEL_EMAIL_VALIDATION_OBJET;
|
|
// message alternatif lorsque le html n'est pas lu :
|
|
$id=substr($ticket,(strrpos($ticket,"/"))+1);
|
|
$Mail_boby_txt=str_replace(array("__NOM_UTILISATEUR__","__ID__"),array($resultat["pseudo"],$id),NOUVEL_EMAIL_VALIDATION_CORPS);
|
|
//-- version html :
|
|
//texte invisible (sauf certains webmail ?) :
|
|
$Mail_html_sujet="Valider sans tarder votre nouvelle adresse email sur ".SITE_NOM.".";
|
|
//entête avant logo :
|
|
$Mail_html_sujet="Valider sans tarder votre nouvelle adresse email sur ".SITE_NOM.".";
|
|
//texte du message, hors liste de liens :
|
|
$Mail_html_intro=str_replace("__NOM_UTILISATEUR__",htmlentities($resultat["pseudo"]),NOUVEL_EMAIL_VALIDATION_CORPS_HTML);
|
|
//liens sous forme de grands boutons. L'ancre ne doit donc pas être trop longue :
|
|
$Mail_html_liens_action[0]="<a href='".PAGE_VALIDATION_EMAIL.$id."'>Valider.</a>";
|
|
//footer du mail html :
|
|
$Mail_html_footer="<p><a href='".SITE_NOM."'>".SITE_NOM."</a>, ".SITE_SLOGAN."</p>";
|
|
$Mail_boby_html="";
|
|
ob_start();
|
|
include(BASE_REP."../www/".TEMPLATE_REP."/mail/defaut.php");
|
|
$Mail_boby_html=ob_get_contents();
|
|
ob_end_clean();
|
|
$SMTP_CustomHeader["X-Mailin-Tag"]="nouvel_email";
|
|
// connexion au serveur smtp si il y a lieu :
|
|
require(BASE_REP."../divers/phpmailer-initialise.php");
|
|
require(BASE_REP."../divers/phpmailer-envoi.php");
|
|
if(!$mail->Send())
|
|
{
|
|
sleep(2);// blocage temporaire smtp ???
|
|
if(!$mail->Send())
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_EMAIL_ENVOI.$mail->ErrorInfo));
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(!empty($nouveau_passe))
|
|
{
|
|
if($this->set_passe($nouveau_passe)===true)
|
|
{
|
|
$prepare=$Bd->prepare("UPDATE utilisateurs SET passe=:passe WHERE id_utilisateur=:id_utilisateur;");
|
|
$maj=$prepare->execute(array(':passe'=>$this->chiffre,':id_utilisateur'=>$this->id_utilisateur));
|
|
if((test_requete(__FILE__,__LINE__,$maj,$prepare)===false)) return false;
|
|
$nb_enreg=$prepare->rowCount();
|
|
if($nb_enreg==0)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_MAJ." >> ".intval($this->id_utilisateur)));
|
|
return false;
|
|
}
|
|
$prepare=null;
|
|
// + sauvegardes
|
|
$prepare_svg=$Bd->prepare("INSERT INTO utilisateurs_svg (id_utilisateur,time_maj,passe) VALUES (:id,:time_maj,:passe)");
|
|
$svg=$prepare_svg->execute(array(':id'=>$this->id_utilisateur,':time_maj'=>time(),':passe'=>$this->chiffre));
|
|
if((test_requete(__FILE__,__LINE__,$svg,$prepare_svg)===false)) return false;
|
|
$prepare_svg=null;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Méthode enregistrant une mise à jour du fuseau horaire uniquement.
|
|
*
|
|
* @param
|
|
* @return booléen suivant succès.
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function actualise_fuseau_horaire()
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if((empty($this->id_utilisateur))||(empty($this->fuseau_horaire)))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$prepare=$Bd->prepare("UPDATE utilisateurs SET fuseau_horaire=:fuseau WHERE id_utilisateur=:id_utilisateur;");
|
|
$maj=$prepare->execute(array(':fuseau'=>$this->fuseau_horaire,':id_utilisateur'=>$this->id_utilisateur));
|
|
if((test_requete(__FILE__,__LINE__,$maj,$prepare)===false)) return false;
|
|
$prepare=null;
|
|
// + sauvegardes
|
|
$timeS=time()+2;//time_maj doit être différent
|
|
$prepare_svg=$Bd->prepare("INSERT INTO utilisateurs_svg (id_utilisateur,time_maj,fuseau_horaire) VALUES (:id,:time_maj,:fuseau)");
|
|
$svg=$prepare_svg->execute(array(':id'=>$this->id_utilisateur,':time_maj'=>$timeS,':fuseau'=>$this->fuseau_horaire));
|
|
if((test_requete(__FILE__,__LINE__,$svg,$prepare_svg)===false)) return false;
|
|
$prepare_svg=null;
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode appelée lors de la validation de chgt d'adresse email
|
|
*
|
|
* @param $ticket l'adresse du ticket contenant l'identifiant de l'utilisateur + sa nouvelle adresse
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function valide_email($ticket)
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(strpos($ticket,"/")!==false)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_AUTORISES));
|
|
return false;
|
|
}
|
|
if(!file_exists(TICKET_VALID_REP."/$ticket"))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_VALIDATION_EMAIL_LIEN);
|
|
return false;
|
|
}
|
|
$donnees_fichier=file_get_contents(TICKET_VALID_REP."/$ticket");
|
|
if(empty($donnees_fichier))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_EXISTE." >> ".htmlentities($ticket,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
unlink(TICKET_VALID_REP."/$ticket");
|
|
$donnees_fichier=explode("|",$donnees_fichier);
|
|
$info=self::recherche((int) $donnees_fichier[1],"id_utilisateur","id_utilisateur");
|
|
if($info===false) return false;
|
|
if($this->id_utilisateur!=(int) $donnees_fichier[1])//comparaison à l'id de l'utilisateur connecté
|
|
return false;
|
|
if($this->set_email($donnees_fichier[0])!==false)
|
|
{
|
|
$prepare=$Bd->prepare("UPDATE utilisateurs SET email=:email where id_utilisateur=:id");
|
|
$maj=$prepare->execute(array(':email'=>$this->email,':id'=>$this->id_utilisateur));
|
|
if((test_requete(__FILE__,__LINE__,$maj,$prepare)===false)) return false;
|
|
$nb_enreg=$prepare->rowCount();
|
|
if($nb_enreg==0)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_MAJ." >> ".intval($this->id_utilisateur)));
|
|
return false;
|
|
}
|
|
$prepare=null;
|
|
// + sauvegardes
|
|
$prepare_svg=$Bd->prepare("INSERT INTO utilisateurs_svg (id_utilisateur,time_maj,email) VALUES (:id,:time_maj,:email)");
|
|
$svg=$prepare_svg->execute(array(':id'=>$this->id_utilisateur,':time_maj'=>time(),':email'=>$this->email));
|
|
if((test_requete(__FILE__,__LINE__,$svg,$prepare_svg)===false)) return false;
|
|
$prepare_svg=null;
|
|
//+ le cache
|
|
$this->crea_cache();
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
/**
|
|
* Méthode envoyant un nouveau mot de passe à l'utilisateur bloqué
|
|
*
|
|
* @param null mais attribut doit être fourni
|
|
* @return booléen suivant réussite
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function get_nouveau_passe()
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
$resultat=self::recherche($this->email,"email","id_utilisateur,pseudo");
|
|
if($resultat===false)
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_PASSE_ENVOI);
|
|
return false;
|
|
}
|
|
$passe=crea_passe();
|
|
if($this->set_passe($passe)===false) return false;
|
|
$prepare=$Bd->prepare("UPDATE utilisateurs SET passe=:passe where email=:email");
|
|
$maj=$prepare->execute(array(':email'=>$this->email,':passe'=>$this->chiffre));
|
|
if((test_requete(__FILE__,__LINE__,$maj,$prepare)===false)) return false;
|
|
$nb_enreg=$prepare->rowCount();
|
|
if($nb_enreg==0)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_MAJ." >> ".intval($resultat["id_utilisateur"])));
|
|
return false;
|
|
}
|
|
$prepare=null;
|
|
// + sauvegardes
|
|
$prepare_svg=$Bd->prepare("INSERT INTO utilisateurs_svg (id_utilisateur,time_maj,passe) VALUES (:id,:time_maj,:passe)");
|
|
$svg=$prepare_svg->execute(array(':id'=>$resultat["id_utilisateur"],':time_maj'=>time(),':passe'=>$this->chiffre));
|
|
if((test_requete(__FILE__,__LINE__,$svg,$prepare_svg)===false)) return false;
|
|
$prepare_svg=null;
|
|
// + envoi du message avec PHPMailer
|
|
$Mail_expediteur_email=EMAIL_TRANSACTIONNEL_DE;
|
|
$Mail_expediteur_nom=SITE_NOM;
|
|
$Mail_destinataire_email=$this->email;
|
|
$Mail_destinataire_nom=$resultat["pseudo"];
|
|
$Mail_reponse_email=EMAIL_TRANSACTIONNEL_DE;
|
|
$Mail_sujet=ENVOI_NOUVEAU_MOT_PASSE_OBJET;
|
|
// message alternatif lorsque le html n'est pas lu :
|
|
$Mail_boby_txt=str_replace(array("__NOM_UTILISATEUR__","__PASSE__"),array($resultat["pseudo"],$this->passe),ENVOI_NOUVEAU_MOT_PASSE_CORPS);
|
|
//-- version html :
|
|
//texte invisible (sauf certains webmail ?) :
|
|
$Mail_html_sujet="Votre nouveau mot de passe ".SITE_NOM.".";
|
|
//entête avant logo :
|
|
$Mail_html_sujet="Votre nouveau mot de passe ".SITE_NOM.".";
|
|
//texte du message, hors liste de liens :
|
|
$Mail_html_intro=str_replace(array("__NOM_UTILISATEUR__","__PASSE__"),array($resultat["pseudo"],$this->passe),ENVOI_NOUVEAU_MOT_PASSE_CORPS_HTML);
|
|
//liens sous forme de grands boutons. L'ancre ne doit donc pas être trop longue :
|
|
$Mail_html_items[0]="<p>Pour vous connecter, <a href='".PAGE_CONNEXION."'>cliquez-ici</a>.</p>";
|
|
$Mail_html_items[1]="<p>Pour modifier votre mot de passe ou votre email, <a href='".PAGE_MAJ_IDENTIFIANT."'>cliquez-ici</a>.</p>";
|
|
$Mail_html_items[2]="<p>Pour modifier vos autres informations (pseudo,...), <a href='".PAGE_MAJ_INFOS_PERSO."'>cliquez-ici</a>.</p>";
|
|
$Mail_html_items[3]="<p>Pour gérer vos abonnements (sites, jours d'envoi...), <a href='".PAGE_ABO_LISTE."'>cliquez-ici</a>.</p>";
|
|
//footer du mail html :
|
|
$Mail_html_footer="<p><a href='".SITE_NOM."'>".SITE_NOM."</a>, ".SITE_SLOGAN."</p>";
|
|
$Mail_boby_html="";
|
|
ob_start();
|
|
include(BASE_REP."../www/".TEMPLATE_REP."/mail/defaut.php");
|
|
$Mail_boby_html=ob_get_contents();
|
|
ob_end_clean();
|
|
$SMTP_CustomHeader["X-Mailin-Tag"]="nouveau_passe";
|
|
// connexion au serveur smtp si il y a lieu :
|
|
require_once(BASE_REP."../divers/phpmailer-initialise.php");
|
|
require_once(BASE_REP."../divers/phpmailer-envoi.php");
|
|
if(!$mail->Send())
|
|
{
|
|
sleep(2);// blocage temporaire smtp ???
|
|
if(!$mail->Send())
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,$mail->ErrorInfo));
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode envoyant un lien par email permettant à un utilisateur de supprimer son compte
|
|
*
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function get_lien_suppression()
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(empty($this->email))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_CHAMPS_ABSENTS);
|
|
return false;
|
|
}
|
|
// est-ce qu'un compte existe pour cette email ?
|
|
$infos=FclFlux_utilisateur::recherche($this->email,"email","id_utilisateur,pseudo,statut");
|
|
if(empty($infos))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_RECHERCHE));
|
|
return false;
|
|
}
|
|
if($infos["statut"]=="administrateur")
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_ACTION_NON_AUTORISEE));
|
|
return false;
|
|
}
|
|
//tout semble ok et on peut créé le ticket qui va bien
|
|
$txt=$infos["id_utilisateur"]."|".time();
|
|
$ticket=crea_ticket($txt,TICKET_SUPPR_REP,"suppr");
|
|
if($ticket===false)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_CREA));
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_CREA_LIEN_SUPPRESSION);
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
$id=substr($ticket,(strrpos($ticket,"/"))+1);
|
|
// envoi du message avec PHPMailer
|
|
$Mail_expediteur_email=EMAIL_TRANSACTIONNEL_DE;
|
|
$Mail_expediteur_nom=SITE_NOM;
|
|
$Mail_destinataire_email=$this->email;
|
|
$Mail_destinataire_nom=$infos["pseudo"];
|
|
$Mail_sujet=COMPTE_LIEN_SUPPRESSION_OBJET;
|
|
// message alternatif lorsque le html n'est pas lu :
|
|
$Mail_boby_txt=str_replace(array("__NOM_UTILISATEUR__","__ID__"),array($Mail_destinataire_nom,$id),COMPTE_LIEN_SUPPRESSION_CORPS);
|
|
//-- version html :
|
|
//texte invisible (sauf certains webmail ?) :
|
|
$Mail_html_sujet="Supprimez votre compte sur ".SITE_NOM." ?";
|
|
//entête avant logo :
|
|
$Mail_html_header="<p>Procédure de suppression de compte.</p>";
|
|
//texte du message, hors liste de liens :
|
|
$Mail_html_intro=str_replace("__NOM_UTILISATEUR__",htmlentities($Mail_destinataire_nom),COMPTE_LIEN_SUPPRESSION_CORPS_HTML);
|
|
//liens sous forme de grands boutons. L'ancre ne doit donc pas être trop longue :
|
|
$Mail_html_liens_action[0]="<a href='".PAGE_LIEN_SUPPRESSION_COMPTE.$id."'>Confirmer la suppression.</a>";
|
|
//footer du mail html :
|
|
$Mail_html_footer="<p><a href='".SITE_NOM."'>".SITE_NOM."</a>, ".SITE_SLOGAN."</p>";
|
|
$Mail_boby_html="";
|
|
ob_start();
|
|
include(BASE_REP."../www/".TEMPLATE_REP."/mail/defaut.php");
|
|
$Mail_boby_html=ob_get_contents();
|
|
ob_end_clean();
|
|
$SMTP_CustomHeader["X-Mailin-Tag"]="supprime_compte";
|
|
// connexion au serveur smtp si il y a lieu :
|
|
require(BASE_REP."../divers/phpmailer-initialise.php");
|
|
require(BASE_REP."../divers/phpmailer-envoi.php");
|
|
if(!$mail->Send())
|
|
{
|
|
sleep(2);// blocage temporaire smtp ???
|
|
if(!$mail->Send())
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_EMAIL_ENVOI.$mail->ErrorInfo));
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_CREA_LIEN_SUPPRESSION);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode appelée lorsqu'un utilisateur clique sur le lien lui permettant de supprimer son compte
|
|
*
|
|
* @param l'adresse du ticket à contrôler
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function test_lien_suppression($ticket)
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(strpos($ticket,"/")!==false)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_AUTORISES));
|
|
return false;
|
|
}
|
|
if(!file_exists(TICKET_SUPPR_REP."/$ticket"))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_LIEN_SUPPRESSION);
|
|
return false;
|
|
}
|
|
$donnees_fichier=explode("|",file_get_contents(TICKET_SUPPR_REP."/$ticket"));
|
|
unlink(TICKET_SUPPR_REP."/$ticket");
|
|
if(count($donnees_fichier)!=2)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_AUTORISES." >> ".htmlentities(implode("|",$donnees_fichier),ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
if($donnees_fichier[1]<(time()-3600*COMPTE_LIEN_SUPPRESSION_MAX_DUREE))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_LIEN_SUPPRESSION);
|
|
return false;
|
|
}
|
|
$info=self::recherche((int) $donnees_fichier[0]);
|
|
if($info===false)
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_LIEN_SUPPRESSION);
|
|
return false;
|
|
}
|
|
if(empty($this->erreurs))
|
|
{
|
|
$this->id_utilisateur=(int) $donnees_fichier[0];
|
|
$this->supprime();
|
|
if(empty($this->erreurs))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
/**
|
|
* Méthode supprimant les infos d'un utilisateur
|
|
* ne concerne pas la table des sauvegardes, ni celles des sessions ayant une durée de vie + longue
|
|
* je garde tout de même dans table sauvegardes la date de suppression du compte (pour stats)
|
|
* si tout se passe bien il faudra supprimer la session de l'utilisateur connecté (sauf si admin)
|
|
*
|
|
* @param $valide booléen pour savoir si il s'agit d'un utilisateur ayant validé son compte ou non
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function supprime($valide=true)
|
|
{
|
|
global $Bd;
|
|
if(!isset($this->id_utilisateur))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
$resultat=$this->recherche($this->id_utilisateur,"id_utilisateur","illustration");
|
|
if(empty($resultat))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT));
|
|
return false;
|
|
}
|
|
// je commence par supprimer tous les enregistrements dépendants (pour suppression des fichiers associés).
|
|
// -- les abonnements
|
|
require_once("FclFlux_abonnement.php");
|
|
$abos=FclFlux_abonnement::get_liste_abo_cache($this,true);//force la création du cache
|
|
if(!empty($abos))
|
|
{
|
|
$infos["proprietaire"]=$this;
|
|
foreach($abos as $abo_infos)
|
|
{
|
|
$infos["id_abonnement"]=$abo_infos["id_abonnement"];
|
|
$abo=new FclFlux_abonnement($infos);
|
|
$abo->supprime();
|
|
unset($abo);
|
|
}
|
|
}
|
|
$prepare=$Bd->prepare("DELETE FROM utilisateurs WHERE id_utilisateur=:id_utilisateur;");
|
|
$suppr=$prepare->execute(array(':id_utilisateur'=>$this->id_utilisateur));
|
|
if((test_requete(__FILE__,__LINE__,$suppr,$prepare)===false));
|
|
$nb_enreg=$prepare->rowCount();
|
|
if(empty($nb_enreg))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_SUPPR." >> ".intval($this->id_utilisateur)));
|
|
return false;
|
|
}
|
|
$prepare=null;
|
|
if($valide)
|
|
{
|
|
// + sauvegardes
|
|
$prepare_svg=$Bd->prepare("INSERT INTO utilisateurs_svg (id_utilisateur,time_maj,time_suppr) VALUES (:id,:time,:time)");
|
|
$svg=$prepare_svg->execute(array(':id'=>$this->id_utilisateur,':time'=>time()));
|
|
if((test_requete(__FILE__,__LINE__,$svg,$prepare_svg)===false)) return false;
|
|
$prepare_svg=null;
|
|
}
|
|
$this->illustration=$resultat["illustration"];
|
|
$this->suppr_illustration();
|
|
$this->suppr_cache();
|
|
if(($valide)&&((empty($_SESSION)||($_SESSION["statut"]!="administrateur"))))//c'est un admin qui supprime un compte
|
|
$this->supprime_session();
|
|
}
|
|
/**
|
|
* Méthode ouvrant le fichier cache contenant les infos d'un utilisateur
|
|
*
|
|
* @param crea_cache : un booléen pour savoir si il faut tester la création du fichier en cas d'absence
|
|
* @return tableau contenant les infos de l'utilisateur fournies par le fichier (si trouvé), false en cas d'erreur
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function get_infos_cache($crea_cache=false)
|
|
{
|
|
global $Bd;
|
|
if(empty($this->id_utilisateur))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$id=strval($this->id_utilisateur);
|
|
$fichier=CACHE_REP."/".CACHE_REP_UTILISATEURS."/".$id[0]."/$id.txt";
|
|
$infos=array();
|
|
if(!file_exists($fichier))
|
|
{
|
|
if($crea_cache)
|
|
{
|
|
require("connexion-bd.php");
|
|
if(empty($GLOBALS['Bd'])) return false;
|
|
if(!$this->crea_cache())
|
|
return false;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
include($fichier);
|
|
if(empty($t))
|
|
return false;
|
|
else
|
|
{
|
|
foreach($t as $key => $value)
|
|
{
|
|
if(!is_array($value))
|
|
$infos[$key]=stripslashes($value);
|
|
}
|
|
}
|
|
if(empty($infos))
|
|
return false;
|
|
else
|
|
return $infos;
|
|
}
|
|
/**
|
|
* Méthode contrôlant les données saisies lors d'une tentative de connexion
|
|
*
|
|
* @param persistence : booléen indiquant si souhait de créer une session persistante via cookies
|
|
* @return booléen suivant réussite
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function test_connexion($persistence=false)
|
|
{
|
|
global $Bd;
|
|
if((empty($this->email))||(empty($this->passe)))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_CHAMPS_ABSENTS);
|
|
return false;
|
|
}
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
$resultat=$this->recherche($this->email,"email","passe,id_utilisateur,pseudo,statut,time_validation");
|
|
if(($resultat===false)||(!(password_verify($this->passe,$resultat["passe"]))))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_CONNEXION);
|
|
return false;
|
|
}
|
|
//données utiles pour création session & co
|
|
$this->id_utilisateur=$resultat["id_utilisateur"];
|
|
$this->pseudo=$resultat["pseudo"];
|
|
$this->statut=$resultat["statut"];
|
|
//première connexion ok d'un utilisateur n'ayant pas validé son compte lors de l'inscription
|
|
//mais ayant demandé et reçu un nouveau mot de passe :
|
|
if($resultat["time_validation"]==0)
|
|
{
|
|
$prepare=$Bd->prepare("UPDATE utilisateurs SET time_validation=:time where id_utilisateur=:id");
|
|
$maj=$prepare->execute(array(':time'=>time(),':id'=>$this->id_utilisateur));
|
|
test_requete(__FILE__,__LINE__,$maj,$prepare);//on ne bloque pas même si c'est gênant...
|
|
}
|
|
if($this->crea_session($persistence,true)!==false)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
/**
|
|
* Méthode contrôlant les données passées par l'url
|
|
* et créant une session à l'utilisateur si elles sont ok
|
|
*
|
|
* @param objet utilisateur pour le propriétaire de l'abonnement, le timestamp d'envoi du message + la clé générée lors du même envoi
|
|
* @return booléen suivant si les données sont ok et la session de l'utilisateur créé
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function crea_session_lien_abo($time_lien,$cle_lien)
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if((empty($time_lien))||(empty($cle_lien)))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$prepare=$Bd->prepare("SELECT U.id_utilisateur,U.pseudo,U.statut FROM utilisateurs as U,abonnements_mail as A WHERE (U.id_utilisateur=A.utilisateur_id AND A.time_envoi=:time AND A.cle=:cle);");
|
|
$recherche=$prepare->execute(array(":time"=>$time_lien,":cle"=>$cle_lien));
|
|
if((test_requete(__FILE__,__LINE__,$recherche,$prepare)===false)) return false;
|
|
$abo_infos=$prepare->fetch(PDO::FETCH_ASSOC);
|
|
$prepare=null;
|
|
if(empty($abo_infos))
|
|
return false;
|
|
else
|
|
{
|
|
if($abo_infos["statut"]=="administrateur")
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,"Tentative de connexion non autorisée en tant qu'administrateur."));
|
|
return false;
|
|
}
|
|
$this->id_utilisateur=$abo_infos["id_utilisateur"];
|
|
$this->pseudo=$abo_infos["pseudo"];
|
|
$this->statut=$abo_infos["statut"];
|
|
$this->crea_session(false,false);
|
|
return $this->connexion_ok;
|
|
}
|
|
}
|
|
/**
|
|
* Méthode envoyant un lien par email permettant de se connecter sans mot de passe
|
|
*
|
|
* @param l'utilisateur a-t'il demandé une connexion persistente ?
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function get_lien_connexion($persistence=false)
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(empty($this->email))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_CHAMPS_ABSENTS);
|
|
return false;
|
|
}
|
|
// est-ce qu'un compte existe pour cette email ?
|
|
$infos=FclFlux_utilisateur::recherche($this->email,"email","id_utilisateur,pseudo,statut");
|
|
if(empty($infos))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_EMAIL_CONNEXION);
|
|
return false;
|
|
}
|
|
if($infos["statut"]=="administrateur")
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_ACTION_NON_AUTORISEE));
|
|
return false;
|
|
}
|
|
//tout semble ok et on peut créé le ticket qui va bien
|
|
$txt=$infos["id_utilisateur"]."|".time()."|".$persistence;
|
|
$ticket=crea_ticket($txt,TICKET_CONNECT_REP,"cnx");
|
|
if($ticket===false)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_CREA));
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_CREA_LIEN_CONNEXION);
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
$id=substr($ticket,(strrpos($ticket,"/"))+1);
|
|
// envoi du message avec PHPMailer
|
|
// connexion au serveur smtp si il y a lieu :
|
|
$Mail_expediteur_email=EMAIL_TRANSACTIONNEL_DE;
|
|
$Mail_expediteur_nom=SITE_NOM;
|
|
$Mail_destinataire_email=$this->email;
|
|
$Mail_destinataire_nom=$infos["pseudo"];
|
|
$Mail_sujet=COMPTE_LIEN_CONNEXION_OBJET;
|
|
// message alternatif lorsque le html n'est pas lu :
|
|
$Mail_boby_txt=str_replace(array("__NOM_UTILISATEUR__","__ID__"),array($Mail_destinataire_nom,$id),COMPTE_LIEN_CONNEXION_CORPS);
|
|
//-- version html :
|
|
//texte invisible (sauf certains webmail ?) :
|
|
$Mail_html_sujet="Lien de connexion à ".SITE_NOM.".";
|
|
//entête avant logo :
|
|
$Mail_html_header="<p>Vous connecter à ".SITE_NOM.".</p>";
|
|
//texte du message, hors liste de liens :
|
|
$Mail_html_intro=str_replace("__NOM_UTILISATEUR__",htmlentities($Mail_destinataire_nom),COMPTE_LIEN_CONNEXION_CORPS_HTML);
|
|
//liens sous forme de grands boutons. L'ancre ne doit donc pas être trop longue :
|
|
$Mail_html_liens_action[0]="<a href='".PAGE_LIEN_CONNEXION_COMPTE.$id."'>Connexion.</a>";
|
|
//footer du mail html :
|
|
$Mail_html_footer="<p><a href='".SITE_URL."'>".SITE_NOM."</a>, ".SITE_SLOGAN."</p>";
|
|
$Mail_boby_html="";
|
|
ob_start();
|
|
include(BASE_REP."../www/".TEMPLATE_REP."/mail/defaut.php");
|
|
$Mail_boby_html=ob_get_contents();
|
|
ob_end_clean();
|
|
$SMTP_CustomHeader["X-Mailin-Tag"]="lien_connexion_sans_passe";
|
|
require(BASE_REP."../divers/phpmailer-initialise.php");
|
|
require(BASE_REP."../divers/phpmailer-envoi.php");
|
|
//echo var_dump($mail);
|
|
if(!$mail->Send())
|
|
{
|
|
sleep(2);// blocage temporaire smtp ???
|
|
if(!$mail->Send())
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_EMAIL_ENVOI.$mail->ErrorInfo));
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_CREA_LIEN_CONNEXION);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode appelée lorsqu'un utilisateur clique sur un lien de connexion envoyé sur son email
|
|
*
|
|
* @param l'adresse du ticket à contrôler
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function crea_session_lien_connexion($ticket)
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(strpos($ticket,"/")!==false)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_AUTORISES));
|
|
return false;
|
|
}
|
|
if(!file_exists(TICKET_CONNECT_REP."/$ticket"))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_LIEN_CONNEXION);
|
|
return false;
|
|
}
|
|
$donnees_fichier=explode("|",file_get_contents(TICKET_CONNECT_REP."/$ticket"));
|
|
unlink(TICKET_CONNECT_REP."/$ticket");
|
|
if(count($donnees_fichier)!=3)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_AUTORISES." >> ".htmlentities(implode("|",$donnees_fichier),ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
if($donnees_fichier[1]<(time()-60*COMPTE_LIEN_CONNEXION_MAX_DUREE))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_LIEN_CONNEXION);
|
|
return false;
|
|
}
|
|
$info=self::recherche((int) $donnees_fichier[0]);
|
|
if($info===false)
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_LIEN_CONNEXION);
|
|
return false;
|
|
}
|
|
if(empty($this->erreurs))
|
|
{
|
|
$this->id_utilisateur=(int) $donnees_fichier[0];
|
|
$this->pseudo=$info["pseudo"];
|
|
$this->statut=$info["statut"];
|
|
if(empty($this->erreurs))
|
|
$this->crea_session($donnees_fichier[2]);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
/**
|
|
* Méthode enregistrant une nouvelle session
|
|
* un fichier temporaire contiendra l'id de l'utilisateur + le timestamp et différentes infos pour les stats
|
|
* si connexion persistente demandée, on créé un cookie + un ticket pour les futurs contrôles du cookie
|
|
* mais connexion persistente interdite pour les administrateurs.
|
|
*
|
|
* @param persistence (booléen) souhait ou non d'une connexion persistente (cookies),
|
|
* initialise_session (booléen) : session déjà initialisée au préalable ?
|
|
* @return booléen suivant réussite
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function crea_session($persistence,$initialise_session=false)
|
|
{
|
|
if((empty($this->id_utilisateur))||(empty($this->pseudo))||(empty($this->statut))) return false;
|
|
if(!$initialise_session)
|
|
{
|
|
session_save_path(SESSIONS_REP);
|
|
ini_set("session.use_only_cookies",1);
|
|
session_regenerate_id(true);
|
|
session_start();
|
|
}
|
|
$ip_connexion=getIp();
|
|
$user_agent=$_SERVER["HTTP_USER_AGENT"];
|
|
if((empty($ip_connexion))||(empty($user_agent)))
|
|
return false;
|
|
$_SESSION["id_utilisateur"]=$this->id_utilisateur;
|
|
$_SESSION["pseudo"]=htmlspecialchars($this->pseudo);//donnée que j'affiche
|
|
$_SESSION["statut"]=$this->statut;
|
|
$_SESSION["controle"]=$user_agent;
|
|
$_SESSION["controle_ip"]=$ip_connexion;
|
|
$referer="";
|
|
if(!empty($_SERVER["HTTP_REFERER"]))
|
|
$referer=$_SERVER["HTTP_REFERER"];
|
|
if(!empty($_SESSION))
|
|
{
|
|
$this->connexion_ok=true;
|
|
$code=htmlentities($this->id_utilisateur)."##".time()."##".$ip_connexion."##".htmlentities($user_agent)."##".htmlentities($referer);
|
|
$ticket=crea_ticket($code,SESSIONS_TEMP_REP,"ses");
|
|
if($ticket===false)
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_CREA));
|
|
}
|
|
else
|
|
return false;
|
|
if(($persistence===true)&&($this->statut!="administrateur"))
|
|
{
|
|
$str_mois=strval(date("Y/m"));
|
|
$code=$this->id_utilisateur.",".$_SESSION["controle"].",".$_SESSION["controle_ip"];
|
|
$ticket=crea_ticket($code,COOKIES_REP."/".$str_mois,"cook");
|
|
if($ticket===false)
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_CREA));
|
|
else
|
|
{
|
|
$date_expire_cookie=time()+3600*24*180;//6 mois, durée max autorisée par la cnil...
|
|
setcookie("ctrl",str_replace("cook","",substr($ticket,(strrpos($ticket,"/"))+1)),$date_expire_cookie,"/",SITE_COOKIES_DOMAINE);
|
|
setcookie("mois",strval(date("Y-m")),$date_expire_cookie,"/",SITE_COOKIES_DOMAINE);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Méthode enregistrant un cookie éphémère
|
|
* dans le but de stocker une adresse vers laquelle rediriger l'utilisateur une fois qu'il sera connecté
|
|
*
|
|
* @param l'url vers laquelle rediriger le gus + la durée de vie en jours du cookie
|
|
* @return booléen suivant réussite
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
static function crea_cookie_redirection($url=SITE_URL,$duree=1)
|
|
{
|
|
if(strpos($url,SITE_COOKIES_DOMAINE)===false) return false;
|
|
$date_expire_cookie=time()+(3600*24)*$duree;
|
|
setcookie("rdg",$url,$date_expire_cookie,"/",SITE_COOKIES_DOMAINE);
|
|
}
|
|
/**
|
|
* Méthode testant les cookies de connexion
|
|
* si tout est ok, on créé des variables de session
|
|
* sinon on supprime les éventuels cookies
|
|
*
|
|
* @return booléen suivant réussite
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function test_cookies()
|
|
{
|
|
if((empty($_COOKIE["ctrl"]))||(empty($_COOKIE["mois"])))
|
|
return false;
|
|
if((strpos("/",$_COOKIE["ctrl"])!==false)||(strpos("/",$_COOKIE["mois"])!==false))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_AUTORISES));
|
|
setcookie("ctrl","",time()-42000,"/",SITE_COOKIES_DOMAINE);
|
|
setcookie("mois","",time()-42000,"/",SITE_COOKIES_DOMAINE);
|
|
return false;
|
|
}
|
|
$tab_mois=explode("-",$_COOKIE["mois"]);
|
|
$mois_ok=array("01","02","03","04","05","06","07","08","09","10","11","12");
|
|
if(!in_array($tab_mois[1],$mois_ok))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_AUTORISES));
|
|
setcookie("ctrl","",time()-42000,"/",SITE_COOKIES_DOMAINE);
|
|
setcookie("mois","",time()-42000,"/",SITE_COOKIES_DOMAINE);
|
|
return false;
|
|
}
|
|
$chemin_ticket=COOKIES_REP."/".intval($tab_mois[0])."/".$tab_mois[1]."/cook".$_COOKIE["ctrl"];
|
|
if(!file_exists($chemin_ticket))
|
|
{
|
|
$this->supprime_session();
|
|
return false;
|
|
}
|
|
$code=explode(",",file_get_contents($chemin_ticket));
|
|
/* bloque certains utilisateurs et ne protège pas de grand chose...
|
|
* $ip_connexion=getIp();
|
|
$user_agent=$_SERVER["HTTP_USER_AGENT"];
|
|
if((empty($ip_connexion))||(empty($user_agent)))
|
|
return false;
|
|
if(($code[1]!=$user_agent)&&($code[2]!=$ip_connexion))//il semble que le user-agent change parfois aussi en cours de route, les 2 c'est louche !
|
|
{
|
|
$this->supprime_session();
|
|
return false;
|
|
}*/
|
|
$this->id_utilisateur=intval($code[0]);
|
|
$infos=$this->get_infos_cache(true);//force la création du cache si nécessaire
|
|
if(empty($infos))
|
|
{
|
|
$this->id_utilisateur=null;
|
|
$this->supprime_session();
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
$this->pseudo=stripslashes($infos["pseudo"]);
|
|
$this->statut=stripslashes($infos["statut"]);
|
|
$this->crea_session(false,true);
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode testant si l'utilisateur est connecté ou non
|
|
* si oui l'objet courant se voit attribuer les données de la session
|
|
*
|
|
* @param $destroy, booléen suivant si je veux détruire ou non la variable de session, $admin à true si page uniquement pour les administrateurs
|
|
* @return booléen suivant si connexion active ou non
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function test_session($destroy=true,$admin=false)
|
|
{
|
|
if(MSG_MAINTENANCE!="")
|
|
return false;
|
|
session_save_path(SESSIONS_REP);
|
|
ini_set("session.use_only_cookies",1);
|
|
session_start();
|
|
if(empty($_SESSION))
|
|
$this->test_cookies();
|
|
/*
|
|
// bloque certains utilisateurs et ne sécurise pas grand chose..
|
|
// données servant à contrôler la session :
|
|
$ip_connexion=getIp();
|
|
$user_agent=$_SERVER["HTTP_USER_AGENT"];
|
|
if((empty($ip_connexion))||(empty($user_agent)))
|
|
return false;
|
|
if((!empty($_SESSION["id_utilisateur"]))&&(!empty($_SESSION["pseudo"]))&&(!empty($_SESSION["statut"]))&&(($_SESSION["controle"]==$user_agent)||($_SESSION["controle_ip"]==$ip_connexion)))//il semble que le user-agent change parfois aussi en cours de route mais les 2 c'est louche !*/
|
|
if((!empty($_SESSION["id_utilisateur"]))&&(!empty($_SESSION["pseudo"]))&&(!empty($_SESSION["statut"])))
|
|
{
|
|
$this->id_utilisateur=$_SESSION["id_utilisateur"];
|
|
$this->pseudo=strval($_SESSION["pseudo"]);//atttibut privé ne pouvant être utilisé en dehors de la classe. Du coup, voir si vraiment utile ?
|
|
$this->statut=strval($_SESSION["statut"]);//idem
|
|
$this->connexion_ok=true;
|
|
if(($admin)&&($_SESSION["statut"]!="administrateur"))
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if(($destroy)&&(!empty($_SESSION)))
|
|
{
|
|
$_SESSION=array();
|
|
session_destroy();
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Méthode supprimant tout ce qui est rapport avec une session
|
|
* cookies, fichiers de contrôle et variables de session
|
|
*
|
|
* @param null
|
|
* @return booléen suivant réussite
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function supprime_session()
|
|
{
|
|
if(!isset($_SESSION))
|
|
{
|
|
session_save_path(SESSIONS_REP);
|
|
session_start();
|
|
}
|
|
if((!empty($_COOKIE["ctrl"]))&&(!empty($_COOKIE["mois"])))
|
|
{
|
|
if((strpos("/",$_COOKIE["ctrl"])!==false)||(strpos("/",$_COOKIE["mois"])!==false))
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_AUTORISES));
|
|
else
|
|
{
|
|
$tab_mois=explode("-",$_COOKIE["mois"]);
|
|
$mois_ok=array("01","02","03","04","05","06","07","08","09","10","11","12");
|
|
if(!in_array($tab_mois[1],$mois_ok))
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_AUTORISES));
|
|
else
|
|
{
|
|
$chemin_ticket=COOKIES_REP."/".intval($tab_mois[0])."/".$tab_mois[1]."/cook".$_COOKIE["ctrl"];
|
|
unlink($chemin_ticket);
|
|
}
|
|
}
|
|
setcookie("ctrl","",time()-42000,"/",SITE_COOKIES_DOMAINE);
|
|
setcookie("mois","",time()-42000,"/",SITE_COOKIES_DOMAINE);
|
|
}
|
|
setcookie("rdg","",time()-42000,"/",SITE_COOKIES_DOMAINE);//peut exister si l'utilisateur a été redirigé lors de la connexion
|
|
$_SESSION=array();
|
|
if (ini_get("session.use_cookies"))
|
|
{
|
|
$params=session_get_cookie_params();
|
|
setcookie(session_name(),"",time()- 42000,$params["path"],$params["domain"],$params["secure"], $params["httponly"]);
|
|
}
|
|
session_destroy();
|
|
if(empty($_SESSION))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
/**
|
|
* Méthode important dans la bd le contenu des fichiers temporaires de session
|
|
* puis supprimant les fichiers en question
|
|
*
|
|
* @param null
|
|
* @return booléen suivant réussite
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
static function sauve_sessions()
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(!is_dir(SESSIONS_TEMP_REP))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_REP_EXISTE." >> ".htmlentities(SESSIONS_REP,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
$rep=opendir(SESSIONS_TEMP_REP);
|
|
$tab=array();
|
|
while($fichier=readdir($rep))
|
|
{
|
|
if(!(is_dir(SESSIONS_TEMP_REP."/$fichier"))&&($fichier!=".")&&($fichier!=".."))
|
|
$tab[$fichier]=file_get_contents(SESSIONS_TEMP_REP."/$fichier");
|
|
}
|
|
closedir($rep);
|
|
$nb_import=0;
|
|
if(!empty($tab))
|
|
{
|
|
$prepare=$Bd->prepare("INSERT INTO utilisateurs_sessions (utilisateur_id,time_session,ip_session,config,referer) VALUES (:id,:time,:ip,:config,:referer)");
|
|
foreach ($tab as $fichier=>$contenu)
|
|
{
|
|
$tab2=explode("##",$contenu);
|
|
if(count($tab2)==5)
|
|
{
|
|
$ajout=$prepare->execute(array(':id'=>$tab2[0],':time'=>$tab2[1],':ip'=>$tab2[2],':config'=>$tab2[3],':referer'=>$tab2[4]));
|
|
test_requete(__FILE__,__LINE__,$ajout,$prepare);//pour infos mais je ne bloque pas sinon fichier non supprimé
|
|
$nb_import++;
|
|
}
|
|
unlink(SESSIONS_TEMP_REP."/$fichier");//contenu ok ou pas, le fichier est supprimé...
|
|
}
|
|
$prepare=null;
|
|
}
|
|
return $nb_import;
|
|
}
|
|
/**
|
|
* Méthode actualisant un journal comptabilisant les pages visitées par un abonné connecté
|
|
*
|
|
* @param $page affichée et $contexte de l'affichage (pour distinguer les mails)
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function ajout_journal_affichage($page=null,$contexte="site")
|
|
{
|
|
if(empty($this->id_utilisateur))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
if(empty($page) || (strpos($page,SITE_URL) === false && strpos($page,str_replace("https", "http", SITE_URL)) === false))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
else
|
|
$page=str_replace(SITE_URL,"",$page);
|
|
if(empty($page))
|
|
$page="accueil";
|
|
$contextes_ok=explode("|",ABO_AFFICHAGES_CONTEXTE);
|
|
if (!in_array($contexte,$contextes_ok))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_AUTORISES." >> ".htmlentities($contexte,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
$repertoire_fichier=CACHE_REP."/".CACHE_REP_UTILISATEURS."/affichages/";
|
|
$nom_fichier=strval(date('Y-m-d-H-i'));
|
|
$now=time();
|
|
if($contexte=="email")
|
|
$config=$_SERVER['HTTP_USER_AGENT'];
|
|
else
|
|
$config=null;//info déjà récupérée lors de la connexion au site
|
|
$code="\$a[$now]['c']='".$contexte."';\$a[$now]['u_id']='".$this->id_utilisateur."';\$a[$now]['page']=\"".htmlentities($page,ENT_QUOTES)."\";\$a[$now]['conf']=\"".htmlentities($config,ENT_QUOTES)."\";";
|
|
if(file_exists($repertoire_fichier.$nom_fichier))
|
|
{
|
|
if(!file_put_contents($repertoire_fichier.$nom_fichier,$code,FILE_APPEND | LOCK_EX))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_ECRITURE));
|
|
return false;
|
|
}
|
|
else
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if(!file_exists($repertoire_fichier))
|
|
{
|
|
if(!mkdir($repertoire_fichier,CACHE_REP_CHMOD,true))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_REP_CREA));
|
|
return false;
|
|
}
|
|
}
|
|
if(!file_put_contents($repertoire_fichier.$nom_fichier,"<?php\n$code",LOCK_EX))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_ECRITURE));
|
|
return false;
|
|
}
|
|
else
|
|
return true;
|
|
}
|
|
}
|
|
/**
|
|
* Méthode retournant la liste des administrateurs du site
|
|
*
|
|
* @param null
|
|
* @return les données de la table dans un tableau si trouvé, false si pas trouvé ou en cas d'erreur
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
static function get_admins()
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
$get_admins=$Bd->query("SELECT id_utilisateur,pseudo,email FROM utilisateurs WHERE statut='administrateur';");
|
|
if((test_requete(__FILE__,__LINE__,$get_admins)===false)) return false;
|
|
$resultat=$get_admins->fetchAll(PDO::FETCH_ASSOC);
|
|
if(empty($resultat))
|
|
return false;
|
|
else
|
|
return $resultat;
|
|
}
|
|
/**
|
|
* Méthode enregistrant le contenu du journal des affichages
|
|
*
|
|
* @param null
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
static function sauve_journal_affichages()
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
$time_limite=time()-60;//un fichier est créé / minute, donc si fichier a + de 60 secondes, on peut l'importer
|
|
$repertoire_fichier=CACHE_REP."/".CACHE_REP_UTILISATEURS."/affichages/";
|
|
$rep=opendir($repertoire_fichier);
|
|
$affichages=array();
|
|
while($fichier=readdir($rep))
|
|
{
|
|
if(!(is_dir($repertoire_fichier.$fichier))&&($fichier!=".")&&($fichier!=".."))
|
|
{
|
|
$dates_fichier=explode("-",$fichier);
|
|
if(!checkdate($dates_fichier[1],$dates_fichier[2],$dates_fichier[0]))
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_DATE_VALIDE));
|
|
else
|
|
{
|
|
$time_fichier=filemtime($repertoire_fichier.$fichier);
|
|
if($time_fichier<$time_limite)
|
|
{
|
|
include($repertoire_fichier.$fichier);
|
|
if(is_array($a))
|
|
$affichages=$affichages+$a;
|
|
unlink($repertoire_fichier.$fichier);//dans tous les cas, le fichier est supprimé
|
|
unset($a);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
closedir($rep);$nb_import=0;
|
|
if(count($affichages)!=0)
|
|
{
|
|
$prepare=$Bd->prepare("INSERT INTO utilisateurs_affichages (utilisateur_id,page,config,time_affichage,contexte) VALUES (:id,:page,:config,:time,:contexte)");
|
|
foreach ($affichages as $time_a=>$infos)
|
|
{
|
|
$test_utilisateur=FclFlux_utilisateur::recherche($infos["u_id"],"id_utilisateur","id_utilisateur");
|
|
if(!empty($test_utilisateur))
|
|
{
|
|
$ajout=$prepare->execute(array(':id'=>$infos["u_id"],':page'=>$infos["page"],':config'=>$infos["conf"],':time'=>$time_a,':contexte'=>$infos["c"]));
|
|
if((test_requete(__FILE__,__LINE__,$ajout,$prepare)===false)) return false;
|
|
$nb_import++;
|
|
}
|
|
}
|
|
$prepare=null;
|
|
}
|
|
return $nb_import;
|
|
}
|
|
/**
|
|
* Méthode vidant les valeurs anciennes de la table comptant les affichages
|
|
* tout en archivant certaines statistiques de configuration
|
|
*
|
|
* @param mois à archiver format YYYY-N, vide si c'est le mois précédent
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
static function nettoye_logs_affichages($mois=null)
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
//d'abord les affichages des utilisateurs connectés sur le site
|
|
$time_limite=time()-NB_JOURS_LOGS_AFFICHAGES*3600*24;
|
|
$suppr_log=$Bd->query("DELETE FROM utilisateurs_affichages WHERE contexte='site' AND time_affichage<$time_limite;");
|
|
if((test_requete(__FILE__,__LINE__,$suppr_log)===false)) return false;
|
|
unset($suppr_log);
|
|
//pour les logs d'email, soit le mois à traiter est fourni,
|
|
//soit je traite le mois précédent mais seulement si nous sommes le 1er du mois.
|
|
if(empty($mois)&&(date("j")==1))
|
|
{
|
|
$m=date("n");
|
|
if($m!=1)
|
|
{
|
|
$m=$m-1;
|
|
$mois=date("Y")."-$m";
|
|
}
|
|
else
|
|
{
|
|
$a=date("Y")-1;
|
|
$mois="$a-12";//décembre de l'année précédente
|
|
}
|
|
}
|
|
if(!empty($mois))
|
|
{
|
|
$Date_debut=explode("-",$mois);
|
|
$time_premier_jour=mktime(0,0,0,intval($Date_debut[1]),1,intval($Date_debut[0]));
|
|
if($time_premier_jour===false)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT.$mois));
|
|
return false;
|
|
}
|
|
if($Date_debut[1]=="12")//chgt d'année
|
|
{
|
|
$Date_fin[1]=1;
|
|
$Date_fin[0]=$Date_debut[0]+1;
|
|
}
|
|
else
|
|
{
|
|
$Date_fin[1]=$Date_debut[1]+1;
|
|
$Date_fin[0]=$Date_debut[0];
|
|
}
|
|
$time_dernier_jour=mktime(0,0,0,$Date_fin[1],1,$Date_fin[0]);
|
|
if($time_dernier_jour===false)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT.$Date_fin[0]."-".$Date_fin[1]));
|
|
return false;
|
|
}
|
|
$recherche_config=$Bd->query("SELECT config,count(DISTINCT utilisateur_id) AS nb FROM utilisateurs_affichages WHERE contexte='email' AND time_affichage>=$time_premier_jour AND time_affichage<$time_dernier_jour GROUP BY config;");
|
|
if((test_requete(__FILE__,__LINE__,$recherche_config)===false)) return false;
|
|
$resultats=$recherche_config->fetchAll(PDO::FETCH_ASSOC);
|
|
unset($recherche_config);
|
|
$prepare=$Bd->prepare("INSERT INTO utilisateurs_config_svg (config,mois,nb_utilisateurs) VALUES (:config,:mois,:nb)");
|
|
foreach($resultats as $config)
|
|
{
|
|
$ajout=$prepare->execute(array(':config'=>$config["config"],':mois'=>$mois,':nb'=>$config["nb"]));
|
|
if((test_requete(__FILE__,__LINE__,$ajout,$prepare)===false)) return false;
|
|
}
|
|
//pas de bug arrivé là, je peux supprimer les enregistrements du mois.
|
|
$suppr_log=$Bd->query("DELETE FROM utilisateurs_affichages WHERE contexte='email' AND time_affichage>=$time_premier_jour AND time_affichage<$time_dernier_jour;");
|
|
if((test_requete(__FILE__,__LINE__,$suppr_log)===false)) return false;
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode parcourant les répertoires contenant des fichiers temporaires pour supprimer ceux obsolètes
|
|
* concernés : tickets validation compte/nouvelle email, fichiers/session, fichiers ctrl des cookies, tickets de connexion
|
|
*
|
|
* @param null
|
|
* @return booléen suivant réussite
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
static function supprime_fichiers_temp()
|
|
{
|
|
if(is_dir(SESSIONS_REP))
|
|
{
|
|
$rep=opendir(SESSIONS_REP);
|
|
while($fichier=readdir($rep))
|
|
{
|
|
if(!(is_dir(SESSIONS_REP."/".$fichier))&&($fichier!=".")&&($fichier!=".."))
|
|
{
|
|
if(filemtime(SESSIONS_REP."/".$fichier)<(time()-3600*3))
|
|
{
|
|
if(!unlink(SESSIONS_REP."/".$fichier))
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_SUPPR." >> ".SESSIONS_REP."/".htmlentities($fichier,ENT_QUOTES)));
|
|
}
|
|
}
|
|
}
|
|
closedir($rep);
|
|
}
|
|
if(is_dir(COOKIES_REP))
|
|
{
|
|
$time_limite_cookies=time()-(180*24*3600);//durée max cnil
|
|
$date_limite=date("Y-m",$time_limite_cookies);
|
|
$dates_limite=explode("-",$date_limite);
|
|
$rep=opendir(COOKIES_REP);
|
|
while($fichier=readdir($rep))
|
|
{
|
|
if((is_dir(COOKIES_REP."/".$fichier))&&($fichier!=".")&&($fichier!=".."))
|
|
{
|
|
if(intval($fichier)<intval($dates_limite[0]))
|
|
supprime_repertoire(COOKIES_REP."/".$fichier);
|
|
else
|
|
{
|
|
$rep2=opendir(COOKIES_REP."/".$fichier);
|
|
while($fichier2=readdir($rep2))
|
|
{
|
|
if((is_dir(COOKIES_REP."/".$fichier."/".$fichier2))&&($fichier2!=".")&&($fichier2!=".."))
|
|
{
|
|
if(intval($fichier2)<intval($dates_limite[1]))
|
|
supprime_repertoire(COOKIES_REP."/".$fichier."/".$fichier2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
closedir($rep);
|
|
}
|
|
if(is_dir(TICKET_VALID_REP))
|
|
{
|
|
$rep=opendir(TICKET_VALID_REP);
|
|
while($fichier=readdir($rep))
|
|
{
|
|
if(!(is_dir(TICKET_VALID_REP."/$fichier"))&&($fichier!=".")&&($fichier!=".."))
|
|
{
|
|
if(strpos($fichier,"valid")!==false)
|
|
{
|
|
if(filemtime(TICKET_VALID_REP."/$fichier")<(time()-3600*24*COMPTE_VALIDATION_MAX_DUREE))
|
|
{
|
|
if(!unlink(TICKET_VALID_REP."/".$fichier))
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_SUPPR." >> ".TICKET_VALID_REP."/".htmlentities($fichier,ENT_QUOTES)));
|
|
}
|
|
}
|
|
else if(strpos($fichier,"email")!==false)
|
|
{
|
|
if(filemtime(TICKET_VALID_REP."/$fichier")<(time()-3600*24*NOUVEL_EMAIL_MAX_DUREE_VALIDATION))
|
|
{
|
|
if(!unlink(TICKET_VALID_REP."/".$fichier))
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_SUPPR." >> ".TICKET_VALID_REP."/".htmlentities($fichier,ENT_QUOTES)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
closedir($rep);
|
|
}
|
|
if(is_dir(TICKET_CONNECT_REP))
|
|
{
|
|
$rep=opendir(TICKET_CONNECT_REP);
|
|
while($fichier=readdir($rep))
|
|
{
|
|
if(!(is_dir(TICKET_CONNECT_REP."/".$fichier))&&($fichier!=".")&&($fichier!=".."))
|
|
{
|
|
if(filemtime(TICKET_CONNECT_REP."/".$fichier)<(time()-60*COMPTE_LIEN_CONNEXION_MAX_DUREE))
|
|
{
|
|
if(!unlink(TICKET_CONNECT_REP."/".$fichier))
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_SUPPR." >> ".TICKET_CONNECT_REP."/".htmlentities($fichier,ENT_QUOTES)));
|
|
}
|
|
}
|
|
}
|
|
closedir($rep);
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode supprimant les données sauvegardées / anciens utilisateurs
|
|
* ceci inclus les données de leurs sessions
|
|
* on garde néanmoins une version anonymisée des enregistrements de création / suppresion de compte (pour stats) !!!
|
|
* supprime aussi les utilisateurs qui n'ont pas validé leur compte au-delà la date limite ou encore étant inactif depuis + d'un an
|
|
*
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
static function supprime_anciens_utilisateurs()
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
$time_limite=time()-DUREE_SVG_DONNEES*24*3600;
|
|
$cherche_anciens=$Bd->query("SELECT id_utilisateur,time_maj,time_crea,time_suppr FROM utilisateurs_svg WHERE (id_utilisateur NOT IN (SELECT id_utilisateur FROM utilisateurs)) and (id_utilisateur in (SELECT id_utilisateur FROM utilisateurs_svg GROUP BY id_utilisateur HAVING MAX(time_maj)<$time_limite));");
|
|
if((test_requete(__FILE__,__LINE__,$cherche_anciens)===false))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_RECHERCHE." >> ".$time_limite));
|
|
return false;
|
|
}
|
|
$resultats=$cherche_anciens->fetchAll(PDO::FETCH_ASSOC);
|
|
$cherche_anciens=null;
|
|
$prepare_suppr=$Bd->prepare("DELETE FROM utilisateurs_svg WHERE id_utilisateur=:id AND time_maj=:time;");
|
|
$prepare_anonyme=$Bd->prepare("UPDATE utilisateurs_svg SET pseudo=NULL,passe=NULL,email=NULL,presentation=NULL,illustration=NULL,ip_crea=NULL,fuseau_horaire=NULL WHERE id_utilisateur=:id AND time_maj=:time;");
|
|
$i=0;
|
|
while(isset($resultats[$i]))
|
|
{
|
|
if(($resultats[$i]["time_crea"]!=$resultats[$i]["time_maj"])&&(empty($resultats[$i]["time_suppr"])))
|
|
{
|
|
$suppr=$prepare_suppr->execute(array(':id'=>$resultats[$i]["id_utilisateur"],':time'=>$resultats[$i]["time_maj"]));
|
|
if((test_requete(__FILE__,__LINE__,$suppr,$prepare_suppr)===false))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_SUPPR." >> ".$resultats[$i]["id_utilisateur"]));
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{// je garde les dates de création et suppression du compte mais sans données perso
|
|
$maj=$prepare_anonyme->execute(array(':id'=>$resultats[$i]["id_utilisateur"],':time'=>$resultats[$i]["time_maj"]));
|
|
if((test_requete(__FILE__,__LINE__,$maj,$prepare_anonyme)===false))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_MAJ." >> ".$resultats[$i]["id_utilisateur"]));
|
|
return false;
|
|
}
|
|
}
|
|
$i++;
|
|
}
|
|
$prepare_suppr=null;$prepare_anonyme=null;
|
|
$suppr_sessions=$Bd->query("DELETE FROM utilisateurs_sessions WHERE utilisateur_id IN (select id_utilisateur FROM utilisateurs_svg WHERE time_suppr< $time_limite);");
|
|
if((test_requete(__FILE__,__LINE__,$suppr_sessions)===false))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_SUPPR));
|
|
return false;
|
|
}
|
|
$suppr_sessions=null;
|
|
//les utilisateurs qui n'ont pas validé leur compte dans les temps sont supprimés des 2 tables
|
|
$suppr_sans_validation=$Bd->query("DELETE FROM utilisateurs_svg WHERE id_utilisateur IN (SELECT id_utilisateur FROM utilisateurs WHERE time_validation=0 and time_crea<".(time()-(3600*24*COMPTE_VALIDATION_MAX_DUREE)).");");
|
|
if((test_requete(__FILE__,__LINE__,$suppr_sans_validation)===false))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_SUPPR." >> ".$time_limite));
|
|
return false;
|
|
}
|
|
//l'utilisateur ayant pu s'abonner et modifier ses infos lors de la création de son compte, il faut lancer une suppression "normale" (fichiers cache, etc.)
|
|
//!!! peut-être garder des stats quelque part ???
|
|
$suppr_sans_validation=$Bd->query("SELECT id_utilisateur FROM utilisateurs WHERE time_validation=0 and time_crea<".(time()-(3600*24*COMPTE_VALIDATION_MAX_DUREE)).";");
|
|
if((test_requete(__FILE__,__LINE__,$suppr_sans_validation)===false))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_RECHERCHE));
|
|
return false;
|
|
}
|
|
$resultat_suppr=$suppr_sans_validation->fetchAll(PDO::FETCH_ASSOC);
|
|
$suppr_sans_validation=null;
|
|
foreach($resultat_suppr as $suppr)
|
|
{
|
|
$ancien=new FclFlux_utilisateur();
|
|
$ancien->id_utilisateur=$suppr["id_utilisateur"];
|
|
$ancien->supprime(false);
|
|
unset($ancien);
|
|
}
|
|
}
|
|
/**
|
|
* Méthode retournant les principales stats concernant les utilisateurs du site durant une période donnée :
|
|
* création comptes, email envoyés, clics, etc.
|
|
*
|
|
* @param timestamp de début et de fin de la période visée
|
|
* @return un tableau contenant les chiffres
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
static function get_stats_utilisateurs($time_debut=0,$time_fin=0)
|
|
{
|
|
global $Bd;global $hub_site;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(empty($time_fin))
|
|
$time_fin=time();
|
|
if((empty($time_debut))&&($time_debut!=0))
|
|
$time_debut=$time_fin-3600*24;
|
|
$statistiques=array();
|
|
// les comptes créés :
|
|
$get_stats=$Bd->query("SELECT id_utilisateur FROM utilisateurs WHERE time_crea>$time_debut AND time_crea<$time_fin;");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["nb_comptes"]=$get_stats->rowCount();
|
|
// les comptes validés :
|
|
$get_stats=$Bd->query("SELECT id_utilisateur FROM utilisateurs WHERE time_validation>$time_debut AND time_validation<$time_fin;");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["nb_comptes_valide"]=$get_stats->rowCount();
|
|
// tous les comptes de + de 6 mois :
|
|
$time_limite_6mois=time()-3600*24*180;
|
|
$get_stats=$Bd->query("SELECT DISTINCT id_utilisateur FROM utilisateurs_svg WHERE time_crea<$time_limite_6mois;");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["nb_comptes_6mois"]=$get_stats->rowCount();
|
|
// tous les comptes de + de 1 an :
|
|
$time_limite_1an=time()-3600*24*365;
|
|
$get_stats=$Bd->query("SELECT DISTINCT id_utilisateur FROM utilisateurs_svg WHERE time_crea<$time_limite_1an;");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["nb_comptes_1an"]=$get_stats->rowCount();
|
|
// les comptes supprimés :
|
|
$get_stats=$Bd->query("SELECT id_utilisateur FROM utilisateurs_svg WHERE time_suppr>$time_debut AND time_suppr<$time_fin;");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["nb_comptes_suppr"]=$get_stats->rowCount();
|
|
// pour toutes les stats sur les abonnements, on ne compte pas l'abonnement par défaut aux news du site :
|
|
$sup_sql="";
|
|
if(!empty($hub_site["id"]))
|
|
$sup_sql="AND id_abonnement NOT IN (SELECT DISTINCT id_abonnement FROM abonnements_hub WHERE id_hub=".$hub_site["id"].")";
|
|
// tous les abonnements :
|
|
$get_stats=$Bd->query("SELECT id_abonnement FROM abonnements WHERE time_crea>$time_debut AND time_crea<$time_fin $sup_sql;");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["nb_abo"]=$get_stats->rowCount();
|
|
// les abonnements avec envoi / mail :
|
|
$get_stats=$Bd->query("SELECT id_abonnement FROM abonnements WHERE time_crea>$time_debut AND time_crea<$time_fin AND jours_alerte!='' $sup_sql;");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["nb_abo_email"]=$get_stats->rowCount();
|
|
// tous les abonnés :
|
|
$get_stats=$Bd->query("SELECT distinct auteur_id FROM abonnements WHERE time_crea>$time_debut AND time_crea<$time_fin $sup_sql;");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["nb_abonnes"]=$get_stats->rowCount();
|
|
// tous les abonnés de + de 6 mois :
|
|
$get_stats=$Bd->query("SELECT distinct auteur_id FROM abonnements WHERE time_crea<$time_limite_6mois $sup_sql;");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["nb_abonnes_6mois"]=$get_stats->rowCount();
|
|
// tous les abonnés de + de 1an :
|
|
$get_stats=$Bd->query("SELECT distinct auteur_id FROM abonnements WHERE time_crea<$time_limite_1an $sup_sql;");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["nb_abonnes_1an"]=$get_stats->rowCount();
|
|
// les abonnés avec au moins un abonnement actif :
|
|
$get_stats=$Bd->query("SELECT distinct auteur_id FROM abonnements WHERE time_crea>$time_debut AND time_crea<$time_fin AND jours_alerte!='' $sup_sql;");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["nb_abonnes_email"]=$get_stats->rowCount();
|
|
// les abonnés toujours actifs au-delà de 6 mois :
|
|
$get_stats=$Bd->query("SELECT distinct auteur_id FROM abonnements WHERE time_crea<$time_limite_6mois AND jours_alerte!='' $sup_sql;");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["nb_abonnes_email_6mois"]=$get_stats->rowCount();
|
|
// les abonnés toujours actifs au-delà de 1 an :
|
|
$get_stats=$Bd->query("SELECT distinct auteur_id FROM abonnements WHERE time_crea<$time_limite_1an AND jours_alerte!='' $sup_sql;");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["nb_abonnes_email_1an"]=$get_stats->rowCount();
|
|
// tous les comptes sans abonnements :
|
|
$statistiques["nb_fantomes"]=$statistiques["nb_comptes_valide"]-$statistiques["nb_abonnes"];
|
|
// les comptes ayant au moins un abonnement mais aucun actif :
|
|
$statistiques["nb_abonnes_desactives"]=$statistiques["nb_abonnes"]-$statistiques["nb_abonnes_email"];
|
|
// tous les emails envoyés :
|
|
$get_stats=$Bd->query("SELECT abonnement_id FROM abonnements_mail WHERE time_envoi>$time_debut AND time_envoi<$time_fin;");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["nb_mail_envoyes"]=$get_stats->rowCount();
|
|
// les emails envoyés uniques :
|
|
$get_stats=$Bd->query("SELECT distinct utilisateur_id FROM abonnements_mail WHERE time_envoi>$time_debut AND time_envoi<$time_fin;");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["nb_mail_uniques_envoyes"]=$get_stats->rowCount();
|
|
// tous les clics dans les emails :
|
|
$get_stats=$Bd->query("SELECT id_clic FROM stat_clics_posts WHERE time_clic>$time_debut AND time_clic<$time_fin AND contexte='email';");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["nb_clics_email"]=$get_stats->rowCount();
|
|
// les clics uniques dans les emails :
|
|
$get_stats=$Bd->query("SELECT distinct utilisateur_id FROM stat_clics_posts WHERE time_clic>$time_debut AND time_clic<$time_fin AND contexte='email';");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["nb_clics_uniques_email"]=$get_stats->rowCount();
|
|
// tous les clics web sur le site :
|
|
$get_stats=$Bd->query("SELECT id_clic FROM stat_clics_posts WHERE time_clic>$time_debut AND time_clic<$time_fin AND contexte='site';");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["nb_clics_site"]=$get_stats->rowCount();
|
|
// les clics uniques sur le site :
|
|
$get_stats=$Bd->query("SELECT distinct utilisateur_id FROM stat_clics_posts WHERE time_clic>$time_debut AND time_clic<$time_fin AND contexte='site';");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["nb_clics_uniques_site"]=$get_stats->rowCount();
|
|
// tous les clics sur la période :
|
|
$statistiques["nb_clics"]=$statistiques["nb_clics_email"]+$statistiques["nb_clics_site"];
|
|
// tous les clics uniques :
|
|
$get_stats=$Bd->query("SELECT distinct utilisateur_id FROM stat_clics_posts WHERE time_clic>$time_debut AND time_clic<$time_fin;");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["nb_clics_uniques"]=$get_stats->rowCount();
|
|
unset($get_stats);
|
|
unset($stats);
|
|
if(empty($statistiques))
|
|
return false;
|
|
else
|
|
return $statistiques;
|
|
}
|
|
/**
|
|
* Méthode retournant les principales stats concernant les adresses emails des utilisateurs du site durant une période donnée.
|
|
* Pour chaque domaine : nombre de comptes actifs, inactifs, cliqueurs...
|
|
*
|
|
* @param timestamp de début et de fin de la période visée, $nb_min nombre minimum d'utilisateur ayant une adresse de ce fournisseur.
|
|
* @return un tableau contenant les chiffres
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
static function get_stats_email($time_debut=0,$time_fin=0,$nb_min=2)
|
|
{
|
|
global $Bd;global $hub_site;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(empty($time_fin))
|
|
$time_fin=time();
|
|
if((empty($time_debut))&&($time_debut!=0))
|
|
$time_debut=$time_fin-3600*24;
|
|
$statistiques=array();
|
|
// les fournisseurs d'adresses email des comptes actifs ou non :
|
|
$get_stats=$Bd->query("SELECT SUBSTRING(email,(LOCATE(\"@\",email))+1) AS ndd,count(*) AS cpt FROM utilisateurs GROUP BY ndd HAVING cpt>$nb_min ORDER BY count(*) DESC;");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["liste_emails_total"]=$get_stats->fetchAll();
|
|
// pour toutes les stats sur les abonnements, on ne compte pas l'abonnement par défaut aux news du site :
|
|
$sup_sql="";
|
|
if(!empty($hub_site["id"]))
|
|
$sup_sql="AND id_abonnement NOT IN (SELECT DISTINCT id_abonnement FROM abonnements_hub WHERE id_hub=".$hub_site["id"].")";
|
|
// les fournisseurs d'adresses email des comptes ayant encore au moins un abonnement actif :
|
|
$get_stats=$Bd->query("SELECT SUBSTRING(email,(LOCATE(\"@\",email))+1) AS ndd,count(*) AS cpt FROM utilisateurs WHERE (id_utilisateur in (SELECT distinct auteur_id FROM abonnements WHERE jours_alerte!='' $sup_sql)) GROUP BY ndd HAVING Cpt>$nb_min ORDER BY cpt DESC;");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["liste_emails_actifs"]=$get_stats->fetchAll();
|
|
// les fournisseurs d'adresses email des cliqueurs sur la période demandée :
|
|
$get_stats=$Bd->query("SELECT SUBSTRING(email,(LOCATE(\"@\",email))+1) AS ndd,count(*) AS cpt FROM utilisateurs WHERE (id_utilisateur in (SELECT distinct utilisateur_id FROM stat_clics_posts WHERE time_clic>$time_debut AND time_clic<$time_fin)) GROUP BY ndd HAVING Cpt>$nb_min ORDER BY cpt DESC;");
|
|
if((test_requete(__FILE__,__LINE__,$get_stats)!==false))
|
|
$statistiques["liste_emails_cliqueur"]=$get_stats->fetchAll();
|
|
unset($get_stats);
|
|
if(empty($statistiques))
|
|
return false;
|
|
else
|
|
return $statistiques;
|
|
}
|
|
/**
|
|
* Méthode fournissant à un administrateur, certaines infos concernant l'utilisateur.
|
|
*
|
|
* @param
|
|
* @return tableaux avec les différentes données
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function get_infos_admin()
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(empty($this->id_utilisateur))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
$id_utilisateur=$this->id_utilisateur;
|
|
$infos=array();
|
|
//ses abonnements.
|
|
$get_abos=$Bd->query("SELECT * FROM abonnements WHERE auteur_id=$id_utilisateur;");
|
|
if((test_requete(__FILE__,__LINE__,$get_abos)===false)) return false;
|
|
$abos=$get_abos->fetchAll(PDO::FETCH_ASSOC);
|
|
if(count($abos)!=0)
|
|
{
|
|
$i=0;
|
|
foreach ($abos as $abo)
|
|
{
|
|
$infos["abos"][$i]=$abo;
|
|
//dernier envoi réussi ?
|
|
$get_dernier_envoi=$Bd->query("SELECT time_envoi FROM abonnements_mail WHERE abonnement_id=".$abo["id_abonnement"]." ORDER BY time_envoi DESC LIMIT 0,1;");
|
|
if((test_requete(__FILE__,__LINE__,$get_dernier_envoi)===false)) return false;
|
|
$envoi=$get_dernier_envoi->fetchAll(PDO::FETCH_ASSOC);
|
|
if(!empty($envoi[0]["time_envoi"]))
|
|
$infos["abos"][$i]["time_dernier_envoi"]=$envoi[0]["time_envoi"];
|
|
//liste des hubs concernés par cet abonnement
|
|
$get_hubs=$Bd->query("SELECT H.nom,H.id_hub FROM hub AS H,abonnements_hub AS A WHERE ((H.id_hub=A.id_hub) AND (A.id_abonnement=".$abo["id_abonnement"]."));");
|
|
if((test_requete(__FILE__,__LINE__,$get_hubs)===false)) return false;
|
|
$hubs=$get_hubs->fetchAll(PDO::FETCH_ASSOC);
|
|
if(count($hubs)!=0)
|
|
$infos["abos"][$i]["hubs"]=$hubs;
|
|
$i++;
|
|
}
|
|
}
|
|
$get_dernier_envoi=null;$get_hubs=null;$get_abos=null;
|
|
// dernières activités du compte
|
|
$hier=time()-3600*24;
|
|
$semaine=time()-3600*24*7;
|
|
//les 10 dernières sessions enregistrées
|
|
$get_sessions=$Bd->query("SELECT * FROM utilisateurs_sessions WHERE utilisateur_id=$id_utilisateur AND time_session>$semaine ORDER BY time_session DESC LIMIT 0,10;");
|
|
$sessions=$get_sessions->fetchAll(PDO::FETCH_ASSOC);
|
|
if(count($sessions)!=0)
|
|
$infos["sessions"]=$sessions;
|
|
$get_sessions=null;
|
|
//les pages où il est passé
|
|
$get_pages=$Bd->query("SELECT page,time_affichage,contexte FROM utilisateurs_affichages WHERE utilisateur_id=$id_utilisateur AND time_affichage>$semaine ORDER BY time_affichage DESC;");
|
|
$pages=$get_pages->fetchAll(PDO::FETCH_ASSOC);
|
|
$nb_pages=count($pages);
|
|
if(count($pages)!=0)
|
|
$infos["pages"]=$pages;
|
|
return $infos;
|
|
}
|
|
} |