969 lines
34 KiB
PHP
Executable File
969 lines
34 KiB
PHP
Executable File
<?php
|
|
/**
|
|
* classe dérivée de la classe Lien
|
|
* on a besoin de la classe FclFlux_rubrique pour ciblé les abonnés devant voir l'annonce
|
|
*
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
require_once("lien.php");
|
|
require_once("FclFlux_rubrique.php");
|
|
class FclFlux_annonce extends Lien
|
|
{
|
|
public $id_annonce;
|
|
private $emplacement; // désignation de l'emplacement où doit apparaître l'annonce dans les emails
|
|
private $titre; // désignation interne de l'annonce
|
|
private $annonce; // le texte de l'annonce
|
|
private $commentaires; // mémo interne concernant l'annonce
|
|
private $time_debut; // timestamp de la date de début de diffusion de l'annonce
|
|
private $time_fin; // timestamp de la date de fin de diffusion de l'annonce
|
|
private $nb_envois; // nombre de fois que l'annonce a été diffusée
|
|
private $nb_envois_uniques; // nombre d'abonnés différents ayant reçu au moins une fois l'annonce
|
|
private $nb_clics; // nombre de fois que l'annonce a été cliquée
|
|
private $nb_clics_uniques; // nombre d'abonnés différents ayant cliqué au moins une fois l'annonce
|
|
private $time_crea; // timestamp de la date de création de l'annonce
|
|
private $time_maj; // timestamp de la dernière mise à jour des infos de l'annonce (hors classement)
|
|
private $auteur; // objet de type FclFlux_utilisateur ou null (si utilisateur supprimé)
|
|
/**
|
|
* Constructeur qui initialise certains attributs en testant les valeurs fournies
|
|
* copier/ coller de la classe héritée du fait de méthodes contrôlant des attributs supplémentaires
|
|
*
|
|
* @param infos tableau contenant les différentes données correspondant aux attributs (supposés homonymes)
|
|
* @return null
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function __construct($infos=null)
|
|
{
|
|
if((!empty($infos))&&(is_array($infos)))
|
|
{
|
|
//les limites doivent être connues avant le reste
|
|
if(!empty($infos["limites"]))
|
|
$this->limites=$infos["limites"];
|
|
unset($infos["limites"]);
|
|
$erreur_ok=false;
|
|
foreach ($infos 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 vérifiant que le paramètre fourni fait partie des valeurs possibles
|
|
* et lui attribuant l'emplacement de l'annonce si c'est le cas
|
|
* cet attribut ne peut être vide
|
|
*
|
|
* @param la valeur à contrôler
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_emplacement($emplacement)
|
|
{
|
|
$valeurs_ok=explode("|",ANNONCE_EMPLACEMENTS);
|
|
if(empty($valeurs_ok))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
if (!in_array($emplacement,$valeurs_ok))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_AUTORISES." >> ".htmlentities($emplacement,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
$this->emplacement=$emplacement;
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode testant la validité du titre saisi pour une annonce et l'attribuant à l'objet si ok
|
|
*
|
|
* @param le texte à contôler
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_titre($titre)
|
|
{
|
|
if(empty($this->limites["annonce_max_titre"]))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$long_max=$this->limites["annonce_max_titre"];
|
|
if(!is_int($long_max))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
$titre=strip_tags(strval(trim($titre)));
|
|
$longueur=strlen($titre);
|
|
if($longueur>$long_max)
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) (str_replace("__MAX__",$long_max,ERREUR_ANNONCE_TITRE_LONG)));
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
$this->titre=$titre;
|
|
return true;
|
|
}
|
|
}
|
|
/**
|
|
* Méthode testant la validité du texte de l'annonce saisi et l'attribuant à l'objet si ok
|
|
*
|
|
* @param le texte à contôler
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_annonce($annonce)
|
|
{
|
|
if(empty($this->limites["annonce_max_texte"]))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$long_max=$this->limites["annonce_max_texte"];
|
|
if(!is_int($long_max))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
$annonce=strip_tags(strval(trim($annonce)));
|
|
$longueur=strlen($annonce);
|
|
if($longueur>$long_max)
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) (str_replace("__MAX__",$long_max,ERREUR_ANNONCE_TEXTE_LONG)));
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
$this->annonce=$annonce;
|
|
return true;
|
|
}
|
|
}
|
|
/**
|
|
* Méthode testant la validité du commentaire de l'annonce et l'attribuant à l'objet si ok
|
|
*
|
|
* @param le texte à contôler
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_commentaires($commentaires)
|
|
{
|
|
if(empty($this->limites["annonce_max_commentaires"]))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$long_max=$this->limites["annonce_max_commentaires"];
|
|
if(!is_int($long_max))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
$commentaires=strip_tags(strval(trim($commentaires)));
|
|
$longueur=strlen($commentaires);
|
|
if($longueur>$long_max)
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) (str_replace("__MAX__",$long_max,ERREUR_ANNONCE_COMMENTAIRE_LONG)));
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
$this->commentaires=$commentaires;
|
|
return true;
|
|
}
|
|
}
|
|
/**
|
|
* Méthode testant la validité de la date de début
|
|
* et la transformant en timestamp unix si ok pour l'attribuer à l'objet
|
|
*
|
|
* @param date de début au format JJ/MM/AAAA
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_time_debut($date_debut)
|
|
{
|
|
if(preg_match(DATE_FORMAT_EREG,$date_debut)==0)
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_AGENDA_DATE_DEBUT_FORMAT);
|
|
return false;
|
|
}
|
|
$tab_debut=explode("/",$date_debut);
|
|
$time_debut=mktime(0,0,0,$tab_debut[1],$tab_debut[0],$tab_debut[2]);
|
|
if($time_debut===false) return false;
|
|
$this->time_debut=$time_debut;
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode testant la validité d'une date de fin fournie
|
|
* et la transformant en timestamp unix si ok pour l'attribuer à l'objet
|
|
* la date de fin doit être postérieure à celle de début ainsi qu'à la date actuelle
|
|
*
|
|
* @param date de fin au format JJ/MM/AAAA
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_time_fin($date_fin)
|
|
{
|
|
if(!isset($this->time_debut))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_AGENDA_DATE_FIN_DEBUT_ABSENT);
|
|
return false;
|
|
}
|
|
if(preg_match(DATE_FORMAT_EREG,$date_fin)==0)
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_AGENDA_DATE_FIN_FORMAT);
|
|
return false;
|
|
}
|
|
$tab_fin=explode("/",$date_fin);
|
|
$time_fin=mktime(0,0,0,$tab_fin[1],$tab_fin[0],$tab_fin[2]);
|
|
if($time_fin===false) return false;
|
|
$time_actuel=time();
|
|
if($time_fin<=$time_actuel)
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_AGENDA_DATE_FIN_PASSE);
|
|
return false;
|
|
}
|
|
if($time_fin<$this->time_debut)
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_AGENDA_DATE_FIN_AVANT_DEBUT);
|
|
return false;
|
|
}
|
|
if((($time_fin)-($this->time_debut))<(3600*24))
|
|
$time_fin=$this->time_debut+(3600*24);
|
|
$this->time_fin=$time_fin;
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode vérifiant que le paramètre fourni est bien un utilisateur existant
|
|
* et lui attribuant l'annonce si c'est le cas
|
|
* cet attribut ne peut être vide
|
|
*
|
|
* @param la valeur à contrôler
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_auteur($auteur)
|
|
{
|
|
if(!($auteur instanceof FclFlux_utilisateur))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
if(empty($auteur->id_utilisateur))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
$existe=FclFlux_utilisateur::recherche($auteur->id_utilisateur,"id_utilisateur","id_utilisateur");
|
|
if(empty($existe))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT));
|
|
return false;
|
|
}
|
|
$this->auteur=$auteur;
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode enregistrant une nouvelle annonce
|
|
*
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function ajout()
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if((empty($this->titre))||(empty($this->annonce))||(empty($this->url))||(empty($this->designation))||(empty($this->time_debut))||(empty($this->time_fin)))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
if(empty($this->emplacement))
|
|
$this->emplacement="header";
|
|
$this->time_crea=time();
|
|
$prepare=$Bd->prepare("INSERT INTO annonces (emplacement,titre,annonce,lien_url,lien_ancre,commentaires,time_debut,time_fin,time_crea,auteur_id) VALUES (:emplacement,:titre,:annonce,:lien_url,:lien_ancre,:commentaires,:time_debut,:time_fin,:time_crea,:auteur_id)");
|
|
$ajout=$prepare->execute(array(':emplacement'=>$this->emplacement,':titre'=>$this->titre,':annonce'=>$this->annonce,':lien_url'=>$this->url,':lien_ancre'=>$this->designation,':commentaires'=>$this->commentaires,':time_debut'=>$this->time_debut,':time_fin'=>$this->time_fin,':time_crea'=>$this->time_crea,':auteur_id'=>$this->auteur->id_utilisateur));
|
|
if((test_requete(__FILE__,__LINE__,$ajout,$prepare)===false)) return false;
|
|
$this->id_annonce=$Bd->lastInsertId();
|
|
$prepare=null;
|
|
$this->get_infos_cache(true);
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode enregistrant une mise à jour des infos d'une annonce
|
|
*
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function actualise()
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if((empty($this->id_annonce))||(empty($this->titre))||(empty($this->annonce))||(empty($this->url))||(empty($this->designation))||(empty($this->time_debut))||(empty($this->time_fin)))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
if(empty($this->emplacement))
|
|
$this->emplacement="header";
|
|
$this->time_maj=time();
|
|
$prepare=$Bd->prepare("UPDATE annonces SET emplacement=:emplacement,titre=:titre,annonce=:annonce,lien_url=:lien_url,lien_ancre=:lien_ancre,commentaires=:commentaires,time_debut=:time_debut,time_fin=:time_fin,time_maj=:time_maj WHERE id_annonce=:id_annonce;");
|
|
$maj=$prepare->execute(array(':emplacement'=>$this->emplacement,':titre'=>$this->titre,':annonce'=>$this->annonce,':lien_url'=>$this->url,':lien_ancre'=>$this->designation,':commentaires'=>$this->commentaires,':time_debut'=>$this->time_debut,':time_fin'=>$this->time_fin,':time_maj'=>$this->time_maj,':id_annonce'=>$this->id_annonce));
|
|
if((test_requete(__FILE__,__LINE__,$maj,$prepare)===false)) return false;
|
|
$prepare=null;
|
|
$this->get_infos_cache(true);
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode testant si le ciblage d'une rubrique pour une annonce est déjà enregistré.
|
|
*
|
|
* @param la rubrique testée
|
|
* @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
|
|
**/
|
|
public function est_dans_rubrique($rubrique)
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(empty($this->id_annonce))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
if(!($rubrique instanceof FclFlux_rubrique))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
if(empty($rubrique->id_rubrique))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
$prepare=$Bd->prepare("SELECT * FROM annonces_rubriques_cible WHERE (rubrique_id=:id_rubrique AND annonce_id=:id_annonce)");
|
|
$recherche=$prepare->execute(array(":id_rubrique"=>$rubrique->id_rubrique,":id_annonce"=>$this->id_annonce));
|
|
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 enregistrant le ciblage d'une rubrique pour la diffusion d'une annonce
|
|
*
|
|
* @param $rubrique : objet de la classe rubrique
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function ajout_rubrique_cible($rubrique=null)
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(empty($this->id_annonce))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
if(!($rubrique instanceof FclFlux_rubrique))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
if(empty($rubrique->id_rubrique))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
$existe=FclFlux_rubrique::recherche($rubrique->id_rubrique,"id_rubrique");
|
|
if(empty($existe))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT));
|
|
return false;
|
|
}
|
|
$classement=$this->est_dans_rubrique($rubrique);
|
|
if($classement)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_DOUBLON));
|
|
return false;
|
|
}
|
|
$prepare=$Bd->prepare("INSERT INTO annonces_rubriques_cible (annonce_id,rubrique_id) VALUES (:id_annonce,:id_rubrique)");
|
|
$classement=$prepare->execute(array(':id_annonce'=>$this->id_annonce,':id_rubrique'=>$rubrique->id_rubrique));
|
|
if((test_requete(__FILE__,__LINE__,$classement,$prepare)===false)) return false;
|
|
$prepare=null;
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode enregistrant la suppression du ciblage d'une rubrique pour une annonce
|
|
*
|
|
* @param $rubrique : objet de la classe rubrique
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function suppr_rubrique_cible($rubrique=null)
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(empty($this->id_annonce))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
if(!($rubrique instanceof FclFlux_rubrique))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
if(empty($rubrique->id_rubrique))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
$classement=$this->est_dans_rubrique($rubrique);
|
|
if(!$classement)
|
|
return false;
|
|
$prepare=$Bd->prepare("DELETE FROM annonces_rubriques_cible WHERE (rubrique_id=:id_rubrique AND annonce_id=:id_annonce) LIMIT 1;");
|
|
$classement=$prepare->execute(array(':id_annonce'=>$this->id_annonce,':id_rubrique'=>$rubrique->id_rubrique));
|
|
if((test_requete(__FILE__,__LINE__,$classement,$prepare)===false)) return false;
|
|
$prepare=null;
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode supprimant l'enregistrement d'une annonce
|
|
*
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function supprime()
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(empty($this->id_annonce))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$prepare=$Bd->prepare("DELETE FROM annonces WHERE id_annonce=:id LIMIT 1;");
|
|
$suppr=$prepare->execute(array(':id'=>$this->id_annonce));
|
|
if((test_requete(__FILE__,__LINE__,$suppr,$prepare)===false)) return false;
|
|
$nb_enreg=$prepare->rowCount();
|
|
$prepare=null;
|
|
if($nb_enreg==0)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_SUPPR." >> ".intval($this->id_annonce)));
|
|
return false;
|
|
}
|
|
//suppression du fichier cache si il existe
|
|
$id=strval($this->id_annonce);
|
|
$chemin=CACHE_REP_ANNONCES."/".$id[0]."/$id.txt";
|
|
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 testant l'existence d'une annonce dans le bd via son id_annonce (seul champ identifiant)
|
|
*
|
|
* @param 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($valeur,$champ_sortie="*")
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
$prepare=$Bd->prepare("SELECT $champ_sortie FROM annonces WHERE id_annonce=: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 recherchant les annonces dans le bd pour un mots-clés donné
|
|
*
|
|
* @param 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 annonces WHERE id_annonce=:cherche_id OR titre LIKE :recherche OR annonce LIKE :recherche OR lien_url LIKE :recherche OR lien_ancre LIKE :recherche OR commentaires LIKE :recherche;");
|
|
$recherche=$prepare->execute(array(":cherche_id"=>$recherche,":recherche"=>$recherche_like));
|
|
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 sortant les principales infos d'une annonce.
|
|
*
|
|
* @param $crea_cache vaut true si on souhaite stocker le résultat dans un fichier, $champ_sortie les champs souhaités
|
|
* @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
|
|
**/
|
|
public function get_infos($crea_cache=false,$champ_sortie="*")
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(empty($this->id_annonce))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$id=strval($this->id_annonce);
|
|
$prepare=$Bd->prepare("SELECT $champ_sortie FROM annonces WHERE id_annonce=:id LIMIT 1;");
|
|
$recherche=$prepare->execute(array(":id"=>$id));
|
|
if((test_requete(__FILE__,__LINE__,$recherche,$prepare)===false)) return false;
|
|
$infos=$prepare->fetch(PDO::FETCH_ASSOC);
|
|
$prepare=null;
|
|
if(empty($infos))
|
|
return false;
|
|
if($crea_cache)
|
|
return crea_cache(CACHE_REP_ANNONCES."/".$id[0]."/$id.txt",$infos);
|
|
else
|
|
return $infos;
|
|
}
|
|
/**
|
|
* Méthode ouvrant le fichier cache contenant les infos d'une annonce
|
|
*
|
|
* @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'annonce fournies par le fichier (si trouvé), false en cas d'erreur
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function get_infos_cache($crea_cache=false)
|
|
{
|
|
if(empty($this->id_annonce))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$id=strval($this->id_annonce);
|
|
$fichier=CACHE_REP."/".CACHE_REP_ANNONCES."/".$id[0]."/$id.txt";
|
|
$infos=array();
|
|
if(!file_exists($fichier))
|
|
{
|
|
if($crea_cache)
|
|
{
|
|
if(empty($GLOBALS['Bd']))
|
|
require("connexion-bd.php");
|
|
if(empty($GLOBALS['Bd'])) return false;
|
|
$this->get_infos(true);
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
if(file_exists($fichier))//la création a pu foirer
|
|
include($fichier);
|
|
else
|
|
return false;
|
|
if(empty($t))
|
|
return false;
|
|
else
|
|
return $t;
|
|
}
|
|
/**
|
|
* Méthode listant les données connues concernant les rubriques ciblées par une annonce
|
|
*
|
|
* @return liste des des rubriques dans un tableau si trouvé (peut être vide), false en cas d'erreur
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function get_rubriques_infos()
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(empty($this->id_annonce))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$prepare=$Bd->prepare("SELECT distinct R.id_rubrique,R.nom FROM annonces_rubriques_cible as C,hub_rubriques as R WHERE ((R.id_rubrique=C.rubrique_id) and (C.annonce_id=:valeur)) ORDER BY R.nom ASC");
|
|
$recherche=$prepare->execute(array(":valeur"=>$this->id_annonce));
|
|
if((test_requete(__FILE__,__LINE__,$recherche,$prepare)===false)) return false;
|
|
$resultat=$prepare->fetchAll(PDO::FETCH_ASSOC);
|
|
$prepare=null;
|
|
return $resultat;
|
|
}
|
|
/**
|
|
* Méthode listant les rubriques actuellement ciblées par une annonce
|
|
*
|
|
* @param $arborescence vaut true si on va chercher les sous-rubriques
|
|
* @return liste des id des rubriques dans un tableau si trouvé (peut être vide), false en cas d'erreur
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function get_rubriques($arborescence=false)
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(empty($this->id_annonce))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$prepare=$Bd->prepare("SELECT rubrique_id FROM annonces_rubriques_cible WHERE annonce_id=:valeur");
|
|
$recherche=$prepare->execute(array(":valeur"=>$this->id_annonce));
|
|
if((test_requete(__FILE__,__LINE__,$recherche,$prepare)===false)) return false;
|
|
$resultat=$prepare->fetchAll(PDO::FETCH_ASSOC);
|
|
$prepare=null;
|
|
if(!empty($resultat))
|
|
{
|
|
$rubriques=array();
|
|
foreach($resultat as $rubrique)
|
|
{
|
|
$rubriques[]["id_rubrique"]=$rubrique["rubrique_id"];
|
|
if($arborescence)
|
|
{
|
|
$mere=new FclFlux_rubrique();
|
|
$mere->id_rubrique=$rubrique["rubrique_id"];
|
|
$filles=$mere->get_sous_arborescence();
|
|
if(!empty($filles))
|
|
$rubriques=array_merge($rubriques,$filles);
|
|
unset($mere);
|
|
}
|
|
}
|
|
}
|
|
if(!empty($rubriques))
|
|
return $rubriques;
|
|
else
|
|
return null;
|
|
}
|
|
/**
|
|
* Méthode renvoyant les données statistiques d'une annonce (affichages/clics)
|
|
*
|
|
* @return les stats dans un tableau php, false en cas d'erreur
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function get_stats()
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(empty($this->id_annonce))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$stats=array();
|
|
//je vérifie si les stats sont déjà connues
|
|
$annonce_infos=$this->get_infos(false,"nb_envois,nb_envois_uniques,nb_clics,nb_clics_uniques");
|
|
if((!empty($annonce_infos))&&(!empty($annonce_infos["nb_envois"])))
|
|
$stats=$annonce_infos;
|
|
else
|
|
{
|
|
$recherche=$Bd->query("SELECT id_diffusion FROM annonces_diffusions WHERE annonce_id=".$this->id_annonce.";");
|
|
if((test_requete(__FILE__,__LINE__,$recherche)===false)) return false;
|
|
$resultats=$recherche->fetchAll();
|
|
$stats["nb_envois"]=count($resultats);
|
|
$recherche=$Bd->query("SELECT DISTINCT utilisateur_id FROM annonces_diffusions WHERE annonce_id=".$this->id_annonce.";");
|
|
if((test_requete(__FILE__,__LINE__,$recherche)===false)) return false;
|
|
$resultats=$recherche->fetchAll();
|
|
$stats["nb_envois_uniques"]=count($resultats);
|
|
$recherche=$Bd->query("SELECT id_clic FROM annonces_clics WHERE annonce_id=".$this->id_annonce.";");
|
|
if((test_requete(__FILE__,__LINE__,$recherche)===false)) return false;
|
|
$resultats=$recherche->fetchAll();
|
|
$stats["nb_clics"]=count($resultats);
|
|
$recherche=$Bd->query("SELECT DISTINCT utilisateur_id FROM annonces_clics WHERE annonce_id=".$this->id_annonce.";");
|
|
if((test_requete(__FILE__,__LINE__,$recherche)===false)) return false;
|
|
$resultats=$recherche->fetchAll();
|
|
$stats["nb_clics_uniques"]=count($resultats);
|
|
unset($recherche);unset($resultats);
|
|
}
|
|
return $stats;
|
|
}
|
|
/**
|
|
* Méthode important le résultat final pour les nombres de clics et affichages d'une annonce dont la diffusion est achevée.
|
|
*
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function sauve_stats()
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(empty($this->id_annonce))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
// l'annonce est-elle toujours diffusée ?
|
|
$infos=$this->get_infos_cache(true);
|
|
if((empty($infos))||($infos["time_fin"]>time()))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_CACHE_CONTENU_ABSENT." >> ".$this->id_annonce));
|
|
return false;
|
|
}
|
|
// les stats
|
|
$stats=$this->get_stats();
|
|
if(empty($stats))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_RECHERCHE));
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
$sauve_stats=$Bd->query("UPDATE annonces SET nb_envois=".$stats["nb_envois"].",nb_envois_uniques=".$stats["nb_envois_uniques"].",nb_clics=".$stats["nb_clics"].",nb_clics_uniques=".$stats["nb_clics_uniques"]." WHERE id_annonce=".$this->id_annonce.";");
|
|
if((test_requete(__FILE__,__LINE__,$sauve_stats)===false))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_MAJ." >> ".$this->id_annonce));
|
|
return false;
|
|
}
|
|
$suppr_diffusions=$Bd->query("DELETE FROM annonces_diffusions WHERE annonce_id=".$this->id_annonce.";");
|
|
if((test_requete(__FILE__,__LINE__,$sauve_stats)===false))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_SUPPR." >> ".$this->id_annonce));
|
|
return false;
|
|
}
|
|
$suppr_diffusions=$Bd->query("DELETE FROM annonces_clics WHERE annonce_id=".$this->id_annonce.";");
|
|
if((test_requete(__FILE__,__LINE__,$sauve_stats)===false))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_SUPPR." >> ".$this->id_annonce));
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Méthode lançant la sauvegarde des stats des annonces expirées pour lesquelles ce traitement n'a pas encore été fait.
|
|
* On se laisse une marge de 15 jours pour compter les clics retardataires.
|
|
*
|
|
* @return booléen suivant succès, null si aucune annonce concernée
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
static function sauve_stats_annonces()
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
$date_limite=time()-3600*24*15;
|
|
$recherche=$Bd->query("SELECT id_annonce FROM annonces WHERE ((time_fin<=$date_limite) AND (id_annonce IN (SELECT DISTINCT annonce_id FROM annonces_diffusions)));");
|
|
if((test_requete(__FILE__,__LINE__,$recherche)===false)) return false;
|
|
$annonces_expire=$recherche->fetchAll(PDO::FETCH_ASSOC);
|
|
$recherche=null;$i=0;
|
|
if(empty($annonces_expire))
|
|
return null;
|
|
else
|
|
{
|
|
foreach($annonces_expire as $annonce_info)
|
|
{
|
|
$annonce_sauve=new FclFlux_annonce();
|
|
$annonce_sauve->id_annonce=$annonce_info["id_annonce"];
|
|
$sauve=$annonce_sauve->sauve_stats();
|
|
if($sauve===false)
|
|
return false;
|
|
$i++;
|
|
unset($annonce_sauve);unset($sauve);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
/**
|
|
* Méthode listant les annonces en cours de diffusion et les hubs concernés (permet de faire le lien avec l'abonnement)
|
|
*
|
|
* @param $infos_hub true si je souhaite récupérer les infos des hubs concernés par ces annonces
|
|
* @return les informations utiles des annonces dans un tableau php si trouvé + les id des hubs concernés. null si pas trouvé, false en cas d'erreur.
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
static function get_liste_annonces_encours($infos_hubs=true)
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
$present=time();
|
|
$recherche=$Bd->query("SELECT id_annonce,titre,emplacement,annonce,lien_url,lien_ancre,time_crea FROM annonces WHERE time_debut<=$present AND time_fin>=$present;");
|
|
if((test_requete(__FILE__,__LINE__,$recherche)===false)) return false;
|
|
$annonces=$recherche->fetchAll(PDO::FETCH_ASSOC);
|
|
$recherche=null;
|
|
if(empty($annonces))
|
|
return null;
|
|
else
|
|
{
|
|
// je cherche d'abord la liste des rubriques de hubs ciblées par chaque annonce (+ toutes les sous-rubriques)
|
|
// puis tous les hubs classés dans au moins une de ses rubriques
|
|
$resultats=array();$i=0;
|
|
foreach($annonces as $annonce_info)
|
|
{
|
|
$resultats[$i]=$annonce_info;
|
|
$annonce=new FclFlux_annonce();
|
|
$annonce->id_annonce=$annonce_info["id_annonce"];
|
|
if($infos_hubs===true)
|
|
{
|
|
$classement=$annonce->get_rubriques(true);
|
|
if(!empty($classement))
|
|
{
|
|
$rubriques_id=array();
|
|
foreach($classement as $rub)
|
|
$rubriques_id[]=intval($rub["id_rubrique"]);
|
|
$sql_in=implode(",",$rubriques_id);
|
|
$recherche=$Bd->query("SELECT DISTINCT id_hub FROM hub_classement_rubriques WHERE (id_rubrique in ($sql_in));");
|
|
if((test_requete(__FILE__,__LINE__,$recherche)===false)) return false;
|
|
$hubs=$recherche->fetchAll(PDO::FETCH_ASSOC);
|
|
$recherche=null;
|
|
if(!empty($hubs))
|
|
{
|
|
$resultats[$i]["hubs"]="";
|
|
foreach ($hubs as $hub_infos)
|
|
$resultats[$i]["hubs"].="[".$hub_infos["id_hub"]."]";
|
|
}
|
|
}
|
|
}
|
|
unset($annonce);
|
|
$i++;
|
|
}
|
|
return $resultats;
|
|
}
|
|
}
|
|
/**
|
|
* Méthode actualisant un journal comptabilisant les clics d'une annonce
|
|
*
|
|
* @param utilisateur concernés + action
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function ajout_journal_clic($utilisateur)
|
|
{
|
|
if(empty($this->id_annonce))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
if(!($utilisateur instanceof FclFlux_utilisateur))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
if(empty($utilisateur->id_utilisateur))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
//je ne teste pas ici si l'utilisateur existe réellement dans la bd car je cherche à éviter les requêtes sql
|
|
$repertoire_fichier=CACHE_REP."/".CACHE_REP_ANNONCES."/clics/";
|
|
$nom_fichier=strval(date('Y-m-d-H-i'));
|
|
$now=time();
|
|
$code="\$c[$now]['u_id']='".$utilisateur->id_utilisateur."';\$c[$now]['a_id']='".$this->id_annonce."';";
|
|
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 enregistrant le contenu du journal des clics sur les annonces
|
|
*
|
|
* @param null
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
static function sauve_journal_clics()
|
|
{
|
|
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_ANNONCES."/clics/";
|
|
if(file_exists($repertoire_fichier))
|
|
$rep=opendir($repertoire_fichier);
|
|
else
|
|
return false;
|
|
$clics=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($c))
|
|
$clics=$clics+$c;
|
|
unlink($repertoire_fichier.$fichier);//dans tous les cas, le fichier est supprimé
|
|
unset($a);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
closedir($rep);
|
|
$nb_import=0;
|
|
if(count($clics)!=0)
|
|
{
|
|
$prepare=$Bd->prepare("INSERT INTO annonces_clics (annonce_id,utilisateur_id,time_clic) VALUES (:annonce_id,:utilisateur_id,:time)");
|
|
foreach ($clics as $time_action=>$infos)
|
|
{
|
|
$test_utilisateur=FclFlux_utilisateur::recherche($infos["u_id"],"id_utilisateur","id_utilisateur");
|
|
if(!empty($test_utilisateur))
|
|
{
|
|
$test_annonce=self::recherche($infos["a_id"],"id_annonce,nb_clics");
|
|
if((!empty($test_annonce))&&(empty($test_annonce["nb_clics"])))//une fois les stats définitives importées, les clics ne sont plus enregistrées.
|
|
{
|
|
$ajout=$prepare->execute(array(':annonce_id'=>$infos["a_id"],':utilisateur_id'=>$infos["u_id"],':time'=>$time_action));
|
|
if((test_requete(__FILE__,__LINE__,$ajout,$prepare)===false)) return false;
|
|
$nb_import++;
|
|
}
|
|
}
|
|
}
|
|
$prepare=null;
|
|
}
|
|
return $nb_import;
|
|
}
|
|
/**
|
|
* Affichage par défaut d'un objet
|
|
* il semble que la méthode héritée ne prenne pas en compte les nouveaux attributs ?
|
|
*
|
|
* @return chaîne de caractères listant la valeur de chaque attribut
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function __toString()
|
|
{
|
|
$texte="<h3>".__CLASS__."</h3>";
|
|
foreach($this as $key => $value)
|
|
{
|
|
if(is_array($value))
|
|
$value=affiche_tableau($value,"<li>#valeur</li>","<ul>","</ul>");
|
|
$texte.="$key : $value\n";
|
|
}
|
|
return $texte;
|
|
}
|
|
}//fin de la classe
|