1781 lines
70 KiB
PHP
Executable File
1781 lines
70 KiB
PHP
Executable File
<?php
|
|
/**
|
|
* Classe décrivant les annonces ou liens partagés dans les hubs.
|
|
* Ils peuvent parvenir des flux associés aux hubs ou être postés par les abonnés du hub.
|
|
* On traite aussi ici les statistiques concernant les clics ou partages des utilisateurs,
|
|
* un journal permettant de les enregistrer de manière différée.
|
|
* On a besoin de la classe FclFlux_utilisateur pour désigner les auteurs des annonces ou encore des clics / partages...
|
|
* + de la classe FclFlux_flux pour désigner le flux à l'origine du lien si c'est le cas.
|
|
* + de la classe FclFlux_hub pour désigner le hub où est posté l'annonce.
|
|
*
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
require_once("FclFlux_utilisateur.php");
|
|
require_once("FclFlux_flux.php");
|
|
require_once("FclFlux_hub.php");
|
|
class FclFlux_post extends Lien
|
|
{
|
|
public $id_post;
|
|
protected $hub; // le hub de publication de l'annonce.
|
|
protected $flux; // le flux à l'origine du lien si c'est le cas.
|
|
protected $auteur; // l'auteur ayant posté l'annonce si c'est le cas.
|
|
protected $ancre; // ancre du lien + titre de l'annonce si cest le cas.
|
|
protected $url; // url de la page liée si c'est le cas.
|
|
protected $annonce; // le texte de l'annonce en complément du lien si posté par un utilisateur.
|
|
protected $time_crea; // timestamp de l'enregistrement de l'annonce.
|
|
protected $time_flux; // timestamp de la date fournie par le flux si c'est le cas.
|
|
protected $time_validation; // timestamp de validation de l'annonce si postée dans un hub sans en être administrateur.
|
|
protected $time_diffusion; // timestamp de la date de début de diffusion de l'annonce si différente de la date de validation.
|
|
protected $time_expiration; // timestamp de la date d'expiration de l'annonce si la durée est différente de celle par défaut.
|
|
protected $illustration; // nom du fichier image servant à illustrer l'annonce.
|
|
public $limites=array(); // tailles limites des attributs
|
|
public $erreurs=array(); // erreurs rencontrées dans les méthodes.
|
|
/**
|
|
* Constructeur qui initialise certains attributs en testant les valeurs fournies
|
|
* copier/ coller de la classe héritée mais méthodes contrôlant des champs 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 est bien un hub existant
|
|
* et lui destinant l'annonce si c'est le cas
|
|
*
|
|
* @param la valeur à contrôler
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_hub($hub)
|
|
{
|
|
if(!($hub instanceof FclFlux_hub))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
if(empty($hub->id_hub))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
if(($hub->recherche($hub->id_hub,"id_hub","id_hub")===false))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT." >> ".htmlentities($hub->id_hub,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
$this->hub=$hub;
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode vérifiant que le paramètre fourni est bien un flux existant
|
|
* et lui attribuant l'origine de l'annonce si c'est le cas
|
|
*
|
|
* @param la valeur à contrôler (peut être vide).
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_flux($flux)
|
|
{
|
|
if(empty($flux))
|
|
return true;
|
|
if(!($flux instanceof FclFlux_flux))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
if(empty($flux->id_flux))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
if(($flux->recherche($flux->id_flux,"id_flux","id_flux")===false))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT." >> ".htmlentities($flux->id_flux,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
$this->flux=$flux;
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode vérifiant que le paramètre fourni est bien un utilisateur existant
|
|
* et lui attribuant l'origine de l'annonce si c'est le cas
|
|
*
|
|
* @param la valeur à contrôler (peut être vide)
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_auteur($auteur)
|
|
{
|
|
if(empty($auteur))
|
|
return true;
|
|
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." >> ".intval($auteur->id_utilisateur)));
|
|
return false;
|
|
}
|
|
$this->auteur=$auteur;
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode testant la validité du texte du lien.
|
|
* et l'attribuant à l'objet si ok
|
|
*
|
|
* @param la désignation à contrôler
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_ancre($ancre)
|
|
{
|
|
if((empty($this->limites["ancre_long_min"]))||(empty($this->limites["ancre_long_max"])))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$long_min=$this->limites["ancre_long_min"];
|
|
$long_max=$this->limites["ancre_long_max"];
|
|
if((!is_int($long_min))||(!is_int($long_max))||($long_max<$long_min))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
$ancre=strip_tags(strval(trim($ancre)));
|
|
$longueur=strlen($ancre);
|
|
if(($longueur<$long_min)||($longueur>$long_max))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) (str_replace(array("__MIN__","__MAX__"),array($long_min,$long_max),ERREUR_POST_ANCRE_LONG)));
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
$this->ancre=$ancre;
|
|
return true;
|
|
}
|
|
}
|
|
/**
|
|
* Méthode testant la validité d'une url fournie
|
|
* on contrôle le format de l'url et sa longueur
|
|
* si tout est ok, on l'attribut à l'objet
|
|
*
|
|
* @param l'url à contrôler (peut être vide si annonce publiée sur le site)
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_url($url)
|
|
{
|
|
if(empty($url))
|
|
return true;
|
|
$long_min=(!empty($this->limites["url_long_min"]))?$this->limites["url_long_min"]:0;
|
|
if(empty($this->limites["url_long_max"]))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$long_max=$this->limites["url_long_max"];
|
|
if((($long_min!=0)&&(!is_int($long_min)))||(!is_int($long_max))||($long_max<$long_min))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
$url=strip_tags(strval(trim($url)));
|
|
$longueur=strlen($url);
|
|
if(($longueur<$long_min)||($longueur>$long_max))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) (str_replace(array("__MIN__","__MAX__"),array($long_min,$long_max),ERREUR_LIEN_URL_LONG)));
|
|
return false;
|
|
}
|
|
if(!filter_var($url,FILTER_VALIDATE_URL))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_LIEN_URL_FORMAT);
|
|
return false;
|
|
}
|
|
$this->url=$url;
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode testant la validité du texte de l'annonce
|
|
* et l'attribuant à l'objet si ok
|
|
*
|
|
* @param le texte à contrôler (peut être vide si un lien est fourni)
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_annonce($annonce,$html_ok=false)
|
|
{
|
|
if(empty(strip_tags($annonce)))
|
|
return true;
|
|
if((empty($this->limites["annonce_long_min"]))||(empty($this->limites["annonce_long_max"])))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$long_min=$this->limites["annonce_long_min"];
|
|
$long_max=$this->limites["annonce_long_max"];
|
|
if((!is_int($long_min))||(!is_int($long_max))||($long_max<$long_min))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
$annonce=strval(trim($annonce));
|
|
$longueur=strlen(strip_tags($annonce));
|
|
if(($longueur<$long_min)||($longueur>$long_max))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) (str_replace(array("__MIN__","__MAX__","__NB__"),array($long_min,$long_max,$longueur),ERREUR_POST_ANNONCE_LONG)));
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if($html_ok===false)
|
|
$this->annonce=strip_tags($annonce);
|
|
else
|
|
$this->annonce=$annonce;
|
|
return true;
|
|
}
|
|
}
|
|
/**
|
|
* Méthode permettant d'accepter le html pour le contenu de l'annonce
|
|
*
|
|
* @param le texte à contrôler (peut être vide si un lien est fourni)
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_annonce_html($annonce)
|
|
{
|
|
return $this->set_annonce($annonce,true);
|
|
}
|
|
/**
|
|
* Méthode testant la validité de la date de début de diffusion de l'annonce.
|
|
* et la transformant en timestamp unix si ok pour l'attribuer à l'objet
|
|
*
|
|
* @param la date au format JJ/MM/AAAA
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_time_diffusion($date_diffusion="")
|
|
{
|
|
if(empty($date_diffusion))
|
|
{
|
|
$this->time_diffusion=0;
|
|
return true;
|
|
}
|
|
if(preg_match(DATE_FORMAT_EREG,$date_diffusion)==0)
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_POST_DATE_DIFFUSION_FORMAT);
|
|
return false;
|
|
}
|
|
$tab_diffusion=explode("/",$date_diffusion);
|
|
$time_diffusion=mktime(0,0,0,$tab_diffusion[1],$tab_diffusion[0],$tab_diffusion[2]);
|
|
if($time_diffusion===false)
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_POST_DATE_DIFFUSION_FORMAT);
|
|
return false;
|
|
}
|
|
/*$timeS=time();
|
|
if($time_diffusion<=$timeS)
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_POST_DATE_DIFFUSION);
|
|
return false;
|
|
} --> je peux avoir besoin de modifier un post déjà diffusé sans vouloir le redifuser... */
|
|
$this->time_diffusion=$time_diffusion;
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode testant la validité de la date de fin d'expiration de l'annonce.
|
|
* et la transformant en timestamp unix si ok pour l'attribuer à l'objet
|
|
*
|
|
* @param la date au format JJ/MM/AAAA
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_time_expiration($date_expiration="")
|
|
{
|
|
if(empty($date_expiration))
|
|
{
|
|
$this->time_expiration=0;
|
|
return true;
|
|
}
|
|
if(preg_match(DATE_FORMAT_EREG,$date_expiration)==0)
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_POST_DATE_EXPIRATION_FORMAT);
|
|
return false;
|
|
}
|
|
$tab_expiration=explode("/",$date_expiration);
|
|
$time_expiration=mktime(0,0,0,$tab_expiration[1],$tab_expiration[0],$tab_expiration[2]);
|
|
if($time_expiration===false)
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_POST_DATE_EXPIRATION_FORMAT);
|
|
return false;
|
|
}
|
|
if(empty($this->time_diffusion))
|
|
$timeS=time()+7*24*3600;// annonce susceptible d'être diffusée pendant 7 jours.
|
|
else
|
|
$timeS=$this->time_diffusion+7*24*3600;
|
|
if($time_expiration<$timeS)
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_POST_DATE_EXPIRATION);
|
|
return false;
|
|
}
|
|
$this->time_expiration=$time_expiration;
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode testant la validité du fichier image illustrant l'annonce (nom, format, taille...)
|
|
* Si ok, une miniature est créée localement et son adresse affectée à l'objet.
|
|
* l'ancre de l'annonce doit être attribuée à l'objet avant car elle sert à nommer le fichier image.
|
|
*
|
|
* @param $fichier : les infos du fichier qui vient d'être téléchargé
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function set_illustration($fichier)
|
|
{
|
|
if(!empty($fichier))
|
|
{
|
|
$adresse_temp=$fichier["tmp_name"];
|
|
if(!file_exists($adresse_temp))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_EXISTE." >> ".htmlentities($adresse_temp,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
if(empty($this->ancre))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_POST_ANCRE_ABSENT));
|
|
return false;
|
|
}
|
|
$extension=strtolower(strrchr($fichier["name"],"."));
|
|
if (strpos(POST_ILLUS_EXTENSIONS,$extension)===false)
|
|
$messages[]=ERREUR_IMAGE_FORMAT;
|
|
$taille_max=min(intval(str_replace("M","000000",ini_get("upload_max_filesize"))),POST_ILLUS_MAX_TAILLE);
|
|
$taille_fichier=filesize($adresse_temp);
|
|
if($taille_fichier>$taille_max)
|
|
$messages[]=ERREUR_FICHIER_POIDS." (maximum : ".($taille_max/1000)." ko)";
|
|
if(empty($messages))
|
|
{
|
|
$ancre=get_chaine_debut(nettoye_chaine(strtolower($this->ancre)),50);
|
|
$adresse_illustration=POST_ILLUS_REP."/".$ancre[0]."/".$ancre.$extension;
|
|
$i=1;
|
|
while(file_exists($adresse_illustration))
|
|
{
|
|
$i++;
|
|
$adresse_illustration=POST_ILLUS_REP."/".$ancre[0]."/".$ancre.$i.$extension;
|
|
}
|
|
if(!file_exists(POST_ILLUS_REP."/".$ancre[0]."/"))
|
|
{
|
|
if(!mkdir(POST_ILLUS_REP."/".$ancre[0]."/",POST_ILLUS_REP_CHMOD,true))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_REP_CREA." >> ".POST_ILLUS_REP."/".$ancre[0]."/"));
|
|
return false;
|
|
}
|
|
}
|
|
if((import_image($adresse_temp,$adresse_illustration,0,POST_ILLUS_MAX_LARGEUR)===true))
|
|
{
|
|
$this->illustration=substr(strrchr($adresse_illustration,"/"),1);
|
|
return $this->sauve_illustration();
|
|
}
|
|
else
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_IMAGE_CREATION));
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,$messages);
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
$this->illustration=NULL;
|
|
}
|
|
/**
|
|
* Méthode enregistrant un changement concernant l'illustration de l'annonce qui peut aussi bien être ajoutée ou modifiée.
|
|
* On ne s'occupe pas du téléchargement, ni du contrôle du fichier.
|
|
*
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function sauve_illustration()
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if((empty($this->illustration))||(empty($this->id_post)))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT." >> ".intval($this->id_post)));
|
|
return false;
|
|
}
|
|
$post_infos=self::recherche($this->id_post,"illustration,annonce,time_validation");
|
|
if(empty($post_infos))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT." >> ".intval($this->id_post)));
|
|
return false;
|
|
}
|
|
if($this->illustration==$post_infos["illustration"])
|
|
return true;
|
|
$prepare=$Bd->prepare("UPDATE hub_post SET illustration=:illustration WHERE id_post=:id_post;");
|
|
$maj=$prepare->execute(array(':illustration'=>$this->illustration,':id_post'=>$this->id_post));
|
|
if((test_requete(__FILE__,__LINE__,$maj,$prepare)===false)) return false;
|
|
$prepare=null;
|
|
// suppression de l'ancien fichier si nécessaire
|
|
if(!empty($post_infos["illustration"]))
|
|
{
|
|
$fichier=$post_infos["illustration"];
|
|
$adresse_illustration=POST_ILLUS_REP."/".$fichier[0]."/".$fichier;
|
|
if((file_exists($adresse_illustration))&&(!unlink($adresse_illustration)))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_SUPPR." >> ".htmlentities($adresse_illustration,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
}
|
|
if((!empty($post_infos["annonce"]))&&(!empty($post_infos["time_validation"])))
|
|
$this->crea_cache();
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode supprimant l'illustration d'une annonce si elle existe (fichier + sql)
|
|
*
|
|
* @param
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function suppr_illustration()
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(empty($this->id_post))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$post_infos=self::recherche($this->id_post,"illustration,annonce,time_validation");
|
|
if(empty($post_infos))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT." >> ".intval($this->id_post)));
|
|
return false;
|
|
}
|
|
if(empty($post_infos["illustration"]))
|
|
return true;//bien que ne devant pas être possible...
|
|
// suppression du fichier
|
|
$fichier=$post_infos["illustration"];
|
|
$adresse_illustration=POST_ILLUS_REP."/".$fichier[0]."/".$fichier;
|
|
if(!file_exists($adresse_illustration))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_EXISTE." >> ".htmlentities($adresse_illustration,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
if(!unlink($adresse_illustration))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_SUPPR." >> ".htmlentities($adresse_illustration,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
$suppr=$Bd->query("UPDATE hub_post SET illustration=NULL WHERE id_post=".$this->id_post.";");
|
|
if((test_requete(__FILE__,__LINE__,$suppr)===false)) return false;
|
|
if((!empty($post_infos["annonce"]))&&(!empty($post_infos["time_validation"])))
|
|
$this->crea_cache();
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode cherchant une annonce dans la bd via son id_post.
|
|
*
|
|
* @param la valeur recherchée, les champs souhaités en sortie si trouvé.
|
|
* @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_sortie="*")
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
$prepare=$Bd->prepare("SELECT $champ_sortie FROM hub_post WHERE id_post=: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 posts dans le bd pour un (ou +sieurs) mots-clés.
|
|
*
|
|
* @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)."%";//qd espaces, cherchez plusieurs mots plutôt qu'une seule expression ???
|
|
$prepare=$Bd->prepare("SELECT $champ_sortie FROM hub_post WHERE id_post=:cherche_id OR ancre LIKE :recherche OR annonce LIKE :recherche OR url LIKE :recherche ORDER BY ancre ASC;");
|
|
$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 créant le fichier cache contenant les infos utiles d'un post
|
|
* id_post doit être connu
|
|
*
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function crea_cache()
|
|
{
|
|
if(empty($this->id_post))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$infos=self::recherche($this->id_post,"*");
|
|
if($infos===false)
|
|
//$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT.">>".intval($this->id_post)));->> pas un bug car on a peut-être juste voulu afficher un post supprimé
|
|
return false;
|
|
if((!empty($infos["time_validation"]))&&(!empty($infos["annonce"])))// fichier cache inutile pour les simples redirections.
|
|
{
|
|
$id=strval($this->id_post);
|
|
return crea_cache(CACHE_REP_POSTS."/".$id[0]."/$id.txt",$infos);
|
|
}
|
|
else
|
|
return false;
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode ouvrant le fichier cache contenant les infos d'un post
|
|
*
|
|
* @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 du post 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_post))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$id=strval($this->id_post);
|
|
$fichier=CACHE_REP."/".CACHE_REP_POSTS."/".$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;
|
|
if(!$this->crea_cache())
|
|
//{
|
|
//$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_CACHE_ECRITURE.">>".intval($this->id_post)));
|
|
return false;
|
|
//}
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
include($fichier);
|
|
if(empty($t))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_EXISTE.">>".htmlentities($fichier,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
foreach($t as $key => $value)
|
|
{
|
|
if(!is_array($value))
|
|
$infos[$key]=stripslashes($value);
|
|
}
|
|
}
|
|
if(empty($infos))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT.">>".intval($this->id_post)));
|
|
return false;
|
|
}
|
|
else
|
|
return $infos;
|
|
}
|
|
/**
|
|
* Méthode de suppression du fichier cache lié à un post
|
|
* id_post doit être connu
|
|
*
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function suppr_cache()
|
|
{
|
|
if(empty($this->id_post))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$id=strval($this->id_post);
|
|
$chemin=CACHE_REP."/".CACHE_REP_POSTS."/".$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 cherchant si il y a de nouveaux posts qu'un administrateur du site doit valider.
|
|
*
|
|
* @param
|
|
* @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_a_valider()
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
$get_posts=$Bd->query("SELECT id_post,ancre FROM hub_post WHERE ((time_validation=0) AND (((auteur_id IS NOT NULL)) OR ((auteur_id IS NULL) AND (flux_id IS NOT NULL))) AND (hub_id NOT IN (select DISTINCT id_hub FROM hub_admin))) ORDER BY time_crea");
|
|
if((test_requete(__FILE__,__LINE__,$get_posts)===false)) return false;
|
|
$resultats=$get_posts->fetchAll(PDO::FETCH_ASSOC);
|
|
if(empty($resultats))
|
|
return false;
|
|
else
|
|
return $resultats;
|
|
}
|
|
/**
|
|
* Méthode enregistrant un nouveau post individuellement.
|
|
* un post saisi par un utilisateur non connecté n'a pas d'auteur mais ses infos doivent être fournies en paramètre
|
|
* un message lui est envoyé pour valider son annonce
|
|
* si l'email est inconnu un compte utilisateur est créé qui sera validé en même temps que l'annonce
|
|
* un post sans auteur (ni flux) n'apparaît pas dans les messages à valider
|
|
* le cache n'est créé que si l'annnonce est validée et n'est pas une simple redirection
|
|
* il sera supprimé si non validé au-delà de la durée de validation d'un compte
|
|
*
|
|
* @param $auteur objet de type utilisateur contenant les infos de l'annonceur (email, pseudo)
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function ajout($auteur=null)
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(((empty($this->url))&&(empty($this->annonce)))||(empty($this->ancre))||(empty($this->hub))||((empty($this->auteur))&&(empty($this->flux))&&(empty($auteur))))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$timeS=time();
|
|
if((!empty($this->time_diffusion))&&($this->time_diffusion<=$timeS))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_POST_DATE_DIFFUSION);
|
|
return false;
|
|
}
|
|
if(!empty($auteur))
|
|
{
|
|
if((empty($auteur["email"]))||(empty($auteur["pseudo"])))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
//-- un utilisateur existe-t-il déjà pour cette adresse email ?
|
|
$existe=FclFlux_utilisateur::recherche($auteur["email"],"email","id_utilisateur,pseudo");
|
|
if(!empty($existe))
|
|
{
|
|
$auteur["id_utilisateur"]=$existe["id_utilisateur"];
|
|
$annonceur=new FclFlux_utilisateur($auteur);
|
|
if(!empty($annonceur->erreurs))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT." >> ".intval($existe["id_utilisateur"])));
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{ //on tente la création d'un nouveau compte
|
|
if(empty($auteur["origine"]))
|
|
$auteur["origine"]="annonces";
|
|
$annonceur=new FclFlux_utilisateur($auteur);
|
|
if(!empty($annonceur->erreurs))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
$crea=$annonceur->ajout(false,"ext");//si création ok, je récupère l'id_utilisateur + le ticket de validation utile plus loin
|
|
if($crea!==true)
|
|
{
|
|
if(!empty($annonceur->erreurs))
|
|
$this->erreurs=array_merge($this->erreurs,$annonceur->erreurs);// par exemple, problème sur le pseudo
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
$flux_id=NULL;$auteur_id=NULL;
|
|
if(!empty($this->flux))
|
|
$flux_id=$this->flux->id_flux;
|
|
if(!empty($this->auteur))
|
|
$auteur_id=$this->auteur->id_utilisateur;
|
|
$url=NULL;$annonce=NULL;$illustration=NULL;
|
|
if(!empty($this->url))
|
|
$url=$this->url;
|
|
if(!empty($this->annonce))
|
|
$annonce=$this->annonce;
|
|
if(!empty($this->illustration))//à priori l'illustration se télécharge dans un deuxième temps.
|
|
$illustration=$this->illustration;
|
|
$time_crea=time();
|
|
$time_flux=0;$time_diffusion=0;$time_expiration=0;
|
|
if(!empty($this->time_flux))
|
|
$time_flux=$this->time_flux;
|
|
if(!empty($this->time_diffusion))
|
|
$time_diffusion=$this->time_diffusion;
|
|
if(!empty($this->time_expiration))
|
|
$time_expiration=$this->time_expiration;
|
|
// annonce automatiquement validée si venant d'un flux ou d'un administrateur du hub (ou administrateur général).
|
|
$time_validation=0;
|
|
if(!empty($this->flux))
|
|
$time_validation=$time_crea;
|
|
elseif((!empty($this->auteur))&&(($this->hub->est_admin($this->auteur)===true)||($this->auteur->est_admin()===true)))
|
|
$time_validation=$time_crea;
|
|
$prepare=$Bd->prepare("INSERT INTO hub_post (hub_id,flux_id,auteur_id,ancre,url,annonce,time_crea,time_flux,time_validation,time_diffusion,time_expiration,illustration) VALUES (:hub_id,:flux_id,:auteur_id,:ancre,:url,:annonce,:time_crea,:time_flux,:time_validation,:time_diffusion,:time_expiration,:illustration)");
|
|
$ajout=$prepare->execute(array(':hub_id'=>$this->hub->id_hub,':flux_id'=>$flux_id,':auteur_id'=>$auteur_id,':ancre'=>$this->ancre,':url'=>$url,':annonce'=>$annonce,':time_crea'=>$time_crea,':time_flux'=>$time_flux,':time_validation'=>$time_validation,':time_diffusion'=>$time_diffusion,':time_expiration'=>$time_expiration,':illustration'=>$illustration));
|
|
if((test_requete(__FILE__,__LINE__,$ajout,$prepare)===false)) return false;
|
|
$this->id_post=$Bd->lastInsertId();
|
|
//$prepare=$Bd->prepare("INSERT INTO hub_post_svg (id_post,hub_id,flux_id,auteur_id,time_crea) VALUES (:id,:hub_id,:flux_id,:auteur_id,:time_crea)");
|
|
//$ajout=$prepare->execute(array(':id'=>$this->id_post,':hub_id'=>$this->hub->id_hub,':flux_id'=>$flux_id,':auteur_id'=>$auteur_id,':time_crea'=>$time_crea));
|
|
//if((test_requete(__FILE__,__LINE__,$ajout,$prepare)===false)) return false;
|
|
$prepare=null;
|
|
if($time_validation!=0)// création du cache du post + des dernières annonces du hub
|
|
{
|
|
if(!empty($annonce))
|
|
$this->crea_cache();
|
|
if(empty($time_diffusion))// un script lancé par crontab s'occupe des actus ayant une date de diffusion déterminée.
|
|
$this->hub->get_liste_posts(true);
|
|
if(!empty($this->auteur))
|
|
{
|
|
self::get_liste_posts_auteur($this->auteur,true);
|
|
self::get_liste_derniers_posts(true);
|
|
}
|
|
}
|
|
elseif(!empty($this->auteur))//annonce soumise par utilisateur connecté (mais non administrateur).
|
|
{
|
|
// il faut prévenir le(s) administrateur(s) du hub, si il y en a
|
|
$hub_admins=$this->hub->get_admins();
|
|
if(empty($hub_admins))// et sinon les administrateurs du site
|
|
$hub_admins=FclFlux_utilisateur::get_admins();
|
|
// nom du hub ?
|
|
$hub_infos=$this->hub->get_infos_cache(true);
|
|
if((empty($hub_infos))||(empty($hub_admins)))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT." > >".$this->id_post));
|
|
return false;
|
|
}
|
|
foreach($hub_admins as $admin_infos)
|
|
{
|
|
// connexion au serveur smtp si il y a lieu :
|
|
require(BASE_REP."../divers/phpmailer-initialise.php");
|
|
$Mail_expediteur_email=EMAIL_TRANSACTIONNEL_DE;
|
|
$Mail_expediteur_nom=SITE_NOM;
|
|
$Mail_destinataire_email=$admin_infos["email"];
|
|
$Mail_destinataire_nom=$admin_infos["pseudo"];
|
|
$Mail_sujet=NOUVEAU_POST_OBJET;
|
|
// message alternatif lorsque le html n'est pas lu :
|
|
$Mail_boby_txt=str_replace(array("__NOM_UTILISATEUR__","__NOM_HUB__","__ID__"),array($admin_infos["pseudo"],$hub_infos["nom"],$this->id_post),NOUVEAU_POST_CORPS);
|
|
//-- version html :
|
|
//entête avant logo :
|
|
$Mail_html_sujet="Une nouvelle annonce vient d'être postée dans le bureau de poste ".$hub_infos["nom"].".";
|
|
//texte du message, hors liste de liens :
|
|
$Mail_html_intro=str_replace(array("__NOM_UTILISATEUR__","__NOM_HUB__"),array($admin_infos["pseudo"],$hub_infos["nom"]),NOUVEAU_POST_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_MAJ_POSTS."?id_post=".$this->id_post."'>Traiter cette annonce.</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"]="alerte_admin_nouveau_post";
|
|
require(BASE_REP."../divers/phpmailer-envoi.php");
|
|
if(!$mail->Send())
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_EMAIL_ENVOI.$mail->ErrorInfo));
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//l'annonce a été postée par un utilisateur non connecté qui doit donc d'abord la valider via un lien.
|
|
require(BASE_REP."../divers/phpmailer-initialise.php");
|
|
$Mail_expediteur_email=EMAIL_TRANSACTIONNEL_DE;
|
|
$Mail_expediteur_nom=SITE_NOM;
|
|
$Mail_destinataire_email=$auteur["email"];
|
|
$Mail_destinataire_nom=$auteur["pseudo"];
|
|
$Mail_sujet=NOUVEAU_POST_VALIDATION_OBJET;
|
|
$ticket=$this->id_post."a".$annonceur->id_utilisateur."a".$time_crea;
|
|
if(!empty($annonceur->ticket))//compte venant d'être créé pour l'occasion.
|
|
$ticket.="/".$annonceur->ticket;
|
|
// message alternatif lorsque le html n'est pas lu :
|
|
$Mail_boby_txt=str_replace(array("__NOM_UTILISATEUR__","__ID__"),array($auteur["pseudo"],$ticket),NOUVEAU_POST_VALIDATION_CORPS);
|
|
//-- version html :
|
|
//entête avant logo :
|
|
$Mail_html_sujet=NOUVEAU_POST_VALIDATION_OBJET;
|
|
//texte du message, hors liste de liens :
|
|
$Mail_html_intro=str_replace("__NOM_UTILISATEUR__",$auteur["pseudo"],NOUVEAU_POST_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_POST.$ticket."'>Valider mon annonce.</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"]="envoi_lien_validation_post";
|
|
require(BASE_REP."../divers/phpmailer-envoi.php");
|
|
if(!$mail->Send())
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_EMAIL_ENVOI.$mail->ErrorInfo));
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode enregistrant la validation de son annonce par un utilisateur
|
|
* Elle reste ensuite encore à faire modérer par un administrateur (sauf si il l'est lui-même).
|
|
* C'est aussi lors de cette étape que l'on abonne l'utilisateur à certains hubs (news du site + actus ville).
|
|
*
|
|
* @ $time_crea timestramp de création de l'annonce à contrôler, @auteur objet utilisateur, $cle : ticket de validation si création du compte utilisateur
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function validation_auteur($time_crea=0,$auteur,$cle="")
|
|
{
|
|
global $Bd;global $hub_site;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if((empty($this->id_post))||(empty($auteur))||(empty($auteur->id_utilisateur))||(empty($time_crea)))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT." >> ".intval($this->id_post)));
|
|
return false;
|
|
}
|
|
//contrôle du timestamp de création
|
|
$post_infos=self::recherche($this->id_post,"hub_id,time_crea,time_validation,auteur_id");
|
|
if(empty($post_infos))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT." >> ".intval($this->id_post)));
|
|
return false;
|
|
}
|
|
if(($time_crea!=$post_infos["time_crea"])||(empty($post_infos["hub_id"])))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_AUTORISES." >> ".intval($this->id_post)));
|
|
return false;
|
|
}
|
|
if((!empty($post_infos["time_validation"]))||(!empty($post_infos["auteur_id"])))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_UTILISA_VALIDATION_POST_LIEN);
|
|
return false;
|
|
}
|
|
//si une clé est fournie, c'est que l'annonceur vient de créer son compte dont je teste la validation
|
|
if(!empty($cle))
|
|
{
|
|
$auteur=new FclFlux_utilisateur();
|
|
$valide_c=$auteur->valide($cle,true);
|
|
if(($valide_c!==true)||(empty($auteur->id_utilisateur)))
|
|
{
|
|
$this->erreurs=array_merge($this->erreurs,$auteur->erreurs);
|
|
return false;
|
|
}
|
|
// + je l'abonne aux actus de sa ville & co et au hub du site si déclaré
|
|
// pour ce faire, j'ai besoin de connaître l'insee de la rubrique du hub visé par l'annonce.
|
|
// l'insee peut avoir été enregistré dans un cookie
|
|
if(!isset($_SESSION))
|
|
{
|
|
session_save_path(SESSIONS_REP);
|
|
ini_set("session.use_only_cookies",1);
|
|
session_start();
|
|
}
|
|
if(!empty($_COOKIE["insee_post"]))
|
|
{
|
|
$test_cookie=get_villes($_COOKIE["insee_post"],"insee");
|
|
if(!empty($test_cookie))
|
|
{
|
|
$post_insee=$_COOKIE["insee_post"];
|
|
// j'en profite pour affecter le bon fuseau horaire si DOM TOM
|
|
global $DT_fuseau;
|
|
$num_depart=$test_cookie[0]["dep_num"];
|
|
if(isset($DT_fuseau["$num_depart"]))
|
|
{
|
|
$auteur->set_fuseau_horaire($DT_fuseau["$num_depart"]);
|
|
$svg=$auteur->actualise_fuseau_horaire();
|
|
if($svg!==true)
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_MAJ." >> ".intval($auteur->id_utilisateur)));
|
|
}
|
|
}
|
|
setcookie("insee_post",NULL,-1);
|
|
unset($_COOKIE['insee_post']);
|
|
unset($test_cookie);
|
|
}
|
|
if(empty($post_insee))//pas de cookie ou valeur non correcte
|
|
{
|
|
$recherche_insee=$Bd->query("SELECT R.insee FROM hub_rubriques as R,hub_classement_rubriques as C WHERE ((R.id_rubrique=C.id_rubrique) AND (C.id_hub=".$post_infos["hub_id"]."));");
|
|
if((test_requete(__FILE__,__LINE__,$recherche_insee)===false))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT." >> ".intval($post_infos["hub_id"])));
|
|
return false;
|
|
}
|
|
$resultats=$recherche_insee->fetchAll();// il peut en fait y avoir plusieurs insee si +sieurs villes partagent le même code postal.
|
|
if(empty($resultats))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT." >> ".intval($post_infos["hub_id"])));
|
|
return false;
|
|
}
|
|
$post_insee=$resultats[0]["insee"];
|
|
unset($resultats);
|
|
}
|
|
$abo_ville=new FclFlux_abonnement();
|
|
$crea_abo_ville=$abo_ville->abo_rapide_ville($auteur,$post_insee);
|
|
if($crea_abo_ville===false)//j'informe les admins mais ne bloque pas
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_AJOUT." >> ".intval($auteur->id_utilisateur)));
|
|
if(!empty($hub_site))
|
|
{// il peut y avoir un hub auxquel on est automatiquement abonné lorsque l'on créé un compte
|
|
$infos_abo["designation"]=$hub_site["nom"];
|
|
$infos_abo["proprietaire"]=$auteur;
|
|
$abo_news=new FclFlux_abonnement($infos_abo);
|
|
$crea_abo_news=$abo_news->ajout();
|
|
if($crea_abo_news!==false)
|
|
{
|
|
$hub=new FclFlux_hub();
|
|
$hub->id_hub=$hub_site["id"];
|
|
$abo_news->ajout_hubs(array($hub));
|
|
unset($hub);
|
|
}
|
|
}
|
|
unset($abo_news);
|
|
}
|
|
else
|
|
{// utilisateur déjà connu des services... j'en profite pour contrôler son identité et lui créer une session.
|
|
$auteur_infos=FclFlux_utilisateur::recherche($auteur->id_utilisateur,"id_utilisateur","pseudo,statut");
|
|
if(empty($auteur_infos))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT." >> ".intval($auteur->id_utilisateur)));
|
|
return false;
|
|
}
|
|
$auteur->set_pseudo($auteur_infos["pseudo"]);
|
|
$auteur->set_statut($auteur_infos["statut"]);
|
|
if(!empty($auteur->erreurs))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT." >> ".intval($auteur->id_utilisateur)));
|
|
return false;
|
|
}
|
|
if(!($auteur_infos["statut"]=="administrateur"))
|
|
$auteur->crea_session(false);
|
|
unset($auteur_infos);
|
|
}
|
|
//-- je peux enregistrer cet utilisateur comme auteur de l'annonce
|
|
$prepare=$Bd->prepare("UPDATE hub_post SET auteur_id=:id WHERE id_post=:id_post;");
|
|
$maj=$prepare->execute(array(':id'=>$auteur->id_utilisateur,':id_post'=>$this->id_post));
|
|
if((test_requete(__FILE__,__LINE__,$maj,$prepare)===false)) return false;
|
|
//$prepare=$Bd->prepare("UPDATE hub_post_svg SET auteur_id=:id WHERE id_post=:id_post;");
|
|
//$maj=$prepare->execute(array(':id'=>$auteur->id_utilisateur,':id_post'=>$this->id_post));
|
|
//if((test_requete(__FILE__,__LINE__,$maj,$prepare)===false)) return false;
|
|
$prepare=null;
|
|
//-- il faut prévenir le(s) administrateurs du hub si il y en a
|
|
$hub_annonce=new FclFlux_hub();
|
|
$hub_annonce->id_hub=$post_infos["hub_id"];
|
|
$hub_admins=$hub_annonce->get_admins();
|
|
if(empty($hub_admins))// et sinon les administrateurs du site
|
|
$hub_admins=FclFlux_utilisateur::get_admins();
|
|
// nom du hub ?
|
|
$hub_infos=$hub_annonce->get_infos_cache(true);
|
|
if((empty($hub_infos))||(empty($hub_admins)))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT." > >".$this->id_post));
|
|
return false;
|
|
}
|
|
foreach($hub_admins as $admin_infos)
|
|
{
|
|
require(BASE_REP."../divers/phpmailer-initialise.php");
|
|
$Mail_expediteur_email=EMAIL_TRANSACTIONNEL_DE;
|
|
$Mail_expediteur_nom=SITE_NOM;
|
|
$Mail_destinataire_email=$admin_infos["email"];
|
|
$Mail_destinataire_nom=$admin_infos["pseudo"];
|
|
$Mail_sujet=NOUVEAU_POST_OBJET;
|
|
// message alternatif lorsque le html n'est pas lu :
|
|
$Mail_boby_txt=str_replace(array("__NOM_UTILISATEUR__","__NOM_HUB__","__ID__"),array($admin_infos["pseudo"],$hub_infos["nom"],$this->id_post),NOUVEAU_POST_CORPS);
|
|
//-- version html :
|
|
//entête avant logo :
|
|
$Mail_html_sujet="Une nouvelle annonce vient d'être postée dans le bureau de poste ".$hub_infos["nom"].".";
|
|
//texte du message, hors liste de liens :
|
|
$Mail_html_intro=str_replace(array("__NOM_UTILISATEUR__","__NOM_HUB__"),array($admin_infos["pseudo"],$hub_infos["nom"]),NOUVEAU_POST_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_MAJ_POSTS."?id_post=".$this->id_post."'>Traiter cette annonce.</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"]="alerte_admin_nouveau_post";
|
|
require(BASE_REP."../divers/phpmailer-envoi.php");
|
|
if(!$mail->Send())
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_EMAIL_ENVOI.$mail->ErrorInfo));
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode modifiant les informations d'une annonce (peut permettre en même temps de la valider).
|
|
*
|
|
* @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->url))&&(empty($this->annonce)))||(empty($this->ancre))||(empty($this->id_post))||(empty($this->hub)))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT." >> ".intval($this->id_post)));
|
|
return false;
|
|
}
|
|
$post_infos=self::recherche($this->id_post,"hub_id,time_validation,auteur_id,time_diffusion,time_expiration");
|
|
if(empty($post_infos))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT." >> ".intval($this->id_post)));
|
|
return false;
|
|
}
|
|
$time_validation=$post_infos["time_validation"];
|
|
if(empty($time_validation))
|
|
{
|
|
// si l'utilisateur connecté est un des administrateurs du hub, il valide l'annonce en même temps.
|
|
if(empty($_SESSION["id_utilisateur"]))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_ACTION_NON_AUTORISEE." >> ".intval($this->id_post)));
|
|
return false;
|
|
}
|
|
$user=new FclFlux_utilisateur();
|
|
$user->id_utilisateur=intval($_SESSION["id_utilisateur"]);
|
|
$hub=$this->hub;
|
|
if(($this->hub->est_admin($user))||($user->est_admin()))
|
|
$time_validation=time();
|
|
unset($user);unset($hub);
|
|
}
|
|
if(!isset($this->time_diffusion))
|
|
$this->time_diffusion=$post_infos["time_diffusion"];
|
|
if(!isset($this->time_expiration))
|
|
$this->time_expiration=$post_infos["time_expiration"];
|
|
$prepare=$Bd->prepare("UPDATE hub_post SET ancre=:ancre,url=:url,annonce=:annonce,time_validation=:time_validation,time_diffusion=:time_diffusion,time_expiration=:time_expiration WHERE id_post=:id_post;");
|
|
$maj=$prepare->execute(array(':ancre'=>$this->ancre,':url'=>$this->url,':annonce'=>$this->annonce,':time_validation'=>$time_validation,':time_diffusion'=>$this->time_diffusion,':time_expiration'=>$this->time_expiration,':id_post'=>$this->id_post));
|
|
if((test_requete(__FILE__,__LINE__,$maj,$prepare)===false)) return false;
|
|
$prepare=null;
|
|
if($time_validation!=0)
|
|
{//cache du post + des dernières annonces du hub:
|
|
if(!empty($this->annonce))// pas de texte=annonce juste diffusée mais non publiée
|
|
$this->crea_cache();
|
|
if((empty($post_infos["time_diffusion"]))||(empty($this->time_diffusion)))// le cron s'occupe des actus dont la date de diffusion est définie.
|
|
$this->hub->get_liste_posts(true);
|
|
if(!empty($post_infos["auteur_id"]))
|
|
{
|
|
$auteur=new FclFlux_utilisateur();
|
|
$auteur->id_utilisateur=intval($post_infos["auteur_id"]);
|
|
self::get_liste_posts_auteur($auteur,true);
|
|
unset($auteur);
|
|
}
|
|
// j'actualise la liste des derniers posts.
|
|
self::get_liste_derniers_posts(true);
|
|
if((empty($post_infos["time_validation"]))&&(!empty($post_infos["auteur_id"])))//je peux aussi avoir à valider une annonce venant d'un partenaire.
|
|
{
|
|
//un administrateur vient de valider l'annonce. Je préviens l'utilisateur l'ayant postée.
|
|
$auteur_infos=FclFlux_utilisateur::recherche($post_infos["auteur_id"],"id_utilisateur","pseudo,email");
|
|
if(empty($auteur_infos))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_RECHERCHE." > >".intval($post_infos["auteur_id"])));
|
|
return false;
|
|
}
|
|
require(BASE_REP."../divers/phpmailer-initialise.php");
|
|
$Mail_expediteur_email=EMAIL_TRANSACTIONNEL_DE;
|
|
$Mail_expediteur_nom=SITE_NOM;
|
|
$Mail_destinataire_email=$auteur_infos["email"];
|
|
$Mail_destinataire_nom=$auteur_infos["pseudo"];
|
|
$Mail_sujet=POST_VALIDE_OK_OBJET;
|
|
// message alternatif lorsque le html n'est pas lu :
|
|
$Mail_boby_txt=str_replace(array("__NOM_UTILISATEUR__","__ID__"),array($auteur_infos["pseudo"],$this->id_post),POST_VALIDE_OK_CORPS);
|
|
//-- version html :
|
|
//entête avant logo :
|
|
$Mail_html_sujet="Votre annonce vient d'être validée par le facteur.";
|
|
//texte du message, hors liste de liens :
|
|
$Mail_html_intro=str_replace("__NOM_UTILISATEUR__",$auteur_infos["pseudo"],POST_VALIDE_OK_CORPS_HTML);
|
|
if(!empty($this->annonce))
|
|
$Mail_html_liens_action[0]="<a href='".PAGE_REPERTOIRE_POST_INFO.$this->id_post."/'>Voir mon annonce.</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"]="confirmation_validation_post";
|
|
require(BASE_REP."../divers/phpmailer-envoi.php");
|
|
if(!$mail->Send())
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_EMAIL_ENVOI.$mail->ErrorInfo));
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode modifiant le hub dans lequel est classé un post (mais ne le valide pas)
|
|
*
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function change_hub()
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if((empty($this->id_post))||(empty($this->hub)))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT." >> ".intval($this->id_post)));
|
|
return false;
|
|
}
|
|
$post_infos=self::recherche($this->id_post,"hub_id,time_validation,annonce,time_diffusion");
|
|
if(empty($post_infos))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT." >> ".intval($this->id_post)));
|
|
return false;
|
|
}
|
|
if($this->hub->id_hub===$post_infos["hub_id"])//rien ne bouge !
|
|
return true;
|
|
$prepare=$Bd->prepare("UPDATE hub_post SET hub_id=:hub_id WHERE id_post=:id_post;");
|
|
$maj=$prepare->execute(array(':hub_id'=>$this->hub->id_hub,':id_post'=>$this->id_post));
|
|
if((test_requete(__FILE__,__LINE__,$maj,$prepare)===false)) return false;
|
|
//$prepare=$Bd->prepare("UPDATE hub_post_svg SET hub_id=:hub_id WHERE id_post=:id_post;");
|
|
//$maj=$prepare->execute(array(':hub_id'=>$this->hub->id_hub,':id_post'=>$this->id_post));
|
|
//if((test_requete(__FILE__,__LINE__,$maj,$prepare)===false)) return false;
|
|
$prepare=null;
|
|
if(!empty($post_infos["time_validation"]))
|
|
{//cache du post + des dernières annonces du nouvel hub et de l'ancien :
|
|
if(!empty($post_infos["annonce"]))
|
|
$this->crea_cache();
|
|
self::get_liste_derniers_posts(true);
|
|
if(empty($post_infos["time_diffusion"]))
|
|
{
|
|
$this->hub->get_liste_posts(true);
|
|
$ancien_hub=new FclFlux_hub();
|
|
$ancien_hub->id_hub=$post_infos["hub_id"];
|
|
$ancien_hub->get_liste_posts(true);
|
|
unset($ancien_hub);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode modifiant l'auteur d'un post (mais ne le valide pas)
|
|
*
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function change_auteur()
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if((empty($this->id_post))||(empty($this->auteur)))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT." >> ".intval($this->id_post)));
|
|
return false;
|
|
}
|
|
$post_infos=self::recherche($this->id_post,"auteur_id,time_validation,annonce");
|
|
if(empty($post_infos))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT." >> ".intval($this->id_post)));
|
|
return false;
|
|
}
|
|
if($this->auteur->id_utilisateur===$post_infos["auteur_id"])//rien ne bouge !
|
|
return true;
|
|
$prepare=$Bd->prepare("UPDATE hub_post SET auteur_id=:auteur_id WHERE id_post=:id_post;");
|
|
$maj=$prepare->execute(array(':auteur_id'=>$this->auteur->id_utilisateur,':id_post'=>$this->id_post));
|
|
if((test_requete(__FILE__,__LINE__,$maj,$prepare)===false)) return false;
|
|
//$prepare=$Bd->prepare("UPDATE hub_post_svg SET auteur_id=:auteur_id WHERE id_post=:id_post;");
|
|
//$maj=$prepare->execute(array(':auteur_id'=>$this->auteur->id_utilisateur,':id_post'=>$this->id_post));
|
|
//if((test_requete(__FILE__,__LINE__,$maj,$prepare)===false)) return false;
|
|
$prepare=null;
|
|
if(!empty($post_infos["time_validation"]))
|
|
{//cache du post + des dernières annonces du nouvel auteur et de l'ancien (si non nul) :
|
|
if(!empty($post_infos["annonce"]))
|
|
$this->crea_cache();
|
|
self::get_liste_posts_auteur($this->auteur,true);
|
|
if(!empty($post_infos["auteur_id"]))
|
|
{
|
|
$auteur=new FclFlux_utilisateur();
|
|
$auteur->id_utilisateur=intval($post_infos["auteur_id"]);
|
|
self::get_liste_posts_auteur($auteur,true);
|
|
unset($auteur);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode supprimant l'enregistrement d'un post
|
|
*
|
|
* @param null
|
|
* @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_post))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
$post_infos=self::recherche($this->id_post,"hub_id,auteur_id,illustration");
|
|
if(empty($post_infos))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT." >> ".intval($this->id_post)));
|
|
return false;
|
|
}
|
|
$prepare=$Bd->prepare("DELETE FROM hub_post WHERE id_post=:id_post LIMIT 1;");
|
|
$suppr=$prepare->execute(array(':id_post'=>$this->id_post));
|
|
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_post)));
|
|
return false;
|
|
}
|
|
$this->suppr_cache();
|
|
if(!empty($post_infos["illustration"]))
|
|
{
|
|
$fichier=$post_infos["illustration"];
|
|
$adresse_illustration=POST_ILLUS_REP."/".$fichier[0]."/".$fichier;
|
|
if((file_exists($adresse_illustration))&&(!unlink($adresse_illustration)))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_SUPPR." >> ".htmlentities($adresse_illustration,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
}
|
|
if(empty($this->hub))
|
|
{
|
|
$hub=new FclFlux_hub();
|
|
$hub->id_hub=$post_infos["hub_id"];
|
|
$this->hub=$hub;
|
|
unset($hub);
|
|
}
|
|
$this->hub->get_liste_posts(true);
|
|
if(!empty($post_infos["auteur_id"]))
|
|
{
|
|
$auteur=new FclFlux_utilisateur();
|
|
$auteur->id_utilisateur=intval($post_infos["auteur_id"]);
|
|
self::get_liste_posts_auteur($auteur,true);
|
|
unset($auteur);
|
|
}
|
|
self::get_liste_derniers_posts(true);
|
|
return true;
|
|
}
|
|
/**
|
|
* Méthode actualisant un journal comptabilisant les clics du post
|
|
*
|
|
* @param utilisateur et abonnement concernés + action et contexte.
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function ajout_journal_clic($utilisateur,$abonnement,$contexte="email")
|
|
{
|
|
if(empty($this->id_post))
|
|
{
|
|
$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;
|
|
}
|
|
if(!($abonnement instanceof FclFlux_abonnement))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
if(empty($abonnement->id_abonnement))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
$repertoire_fichier=CACHE_REP."/".CACHE_REP_POSTS."/clics/";
|
|
$nom_fichier=strval(date('Y-m-d-H-i'));
|
|
$now=time();
|
|
$code="\$c[$now]['u_id']='".$utilisateur->id_utilisateur."';\$c[$now]['a_id']='".$abonnement->id_abonnement."';\$c[$now]['p_id']='".$this->id_post."';\$c[$now]['c']='".$contexte."';";
|
|
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 des utilisateurs
|
|
*
|
|
* @param null
|
|
* @return nombre de clics importés dans la base ou false si erreur
|
|
* @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_POSTS."/clics/";
|
|
if(!file_exists($repertoire_fichier))//aucune action enregistrée depuis l'installation
|
|
return 0;
|
|
$rep=opendir($repertoire_fichier);
|
|
$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_cherche_post=$Bd->prepare("SELECT flux_id,auteur_id from hub_post WHERE id_post=:post_id");//utile pour compteurs clics
|
|
$prepare_ajout_stat=$Bd->prepare("INSERT INTO stat_clics_posts (utilisateur_id,time_clic,contexte,abonnement_id) VALUES (:utilisateur_id,:time,:contexte,:abonnement_id)");
|
|
$prepare_ajout_clic_flux=$Bd->prepare("UPDATE flux SET nb_clics=nb_clics+1 WHERE id_flux=:flux_id");
|
|
$prepare_ajour_clic_auteur=$Bd->prepare("UPDATE utilisateurs SET nb_clics=nb_clics+1 WHERE id_utilisateur=:auteur_id");
|
|
foreach ($clics as $time_clic=>$infos)
|
|
{
|
|
$recherche_post_infos=$prepare_cherche_post->execute(array(":post_id"=>$infos["p_id"]));
|
|
if((test_requete(__FILE__,__LINE__,$recherche_post_infos,$prepare_cherche_post)===false)) return false;
|
|
$post_infos=$prepare_cherche_post->fetch(PDO::FETCH_ASSOC);
|
|
if(!empty($post_infos))
|
|
{
|
|
$ajout_stat=$prepare_ajout_stat->execute(array(':utilisateur_id'=>$infos["u_id"],':time'=>$time_clic,':contexte'=>$infos["c"],':abonnement_id'=>$infos["a_id"]));
|
|
if((test_requete(__FILE__,__LINE__,$ajout_stat,$prepare_ajout_stat)===false)) return false;
|
|
$nb_import++;
|
|
if(!empty($post_infos["flux_id"]))
|
|
$ajout_clic_flux=$prepare_ajout_clic_flux->execute(array(":flux_id"=>$post_infos["flux_id"]));// en s'en fout si ça bug...
|
|
elseif(!empty($post_infos["auteur_id"]))
|
|
$ajout_clic_auteur=$prepare_ajout_clic_auteur->execute(array(":auteur_id"=>$post_infos["auteur_id"]));// idem
|
|
}
|
|
}
|
|
$prepare_cherche_post=null;$prepare_ajout_stat=null;$prepare_ajout_clic_flux=null;$prepare_ajour_clic_auteur=null;
|
|
}
|
|
return $nb_import;
|
|
}
|
|
/**
|
|
* Méthode listant les annonces postées par un utilisateur (qu'elles soient validées ou non)
|
|
* permet aussi de créer le cache si souhaité
|
|
*
|
|
* @param l'utilisateur concerné + booléen pour savoir si il faut enregistrer le résultat dans des fichiers + champs souhaités en sortie
|
|
* @return liste des annonces dans un tableau si trouvé (peut être vide), false en cas d'erreur
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
static function get_liste_posts_auteur($auteur,$crea_cache=false,$champs="id_post,ancre,url,time_validation")
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(empty($auteur))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
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;
|
|
}
|
|
$id=strval($auteur->id_utilisateur);
|
|
$prepare=$Bd->prepare("SELECT $champs FROM hub_post WHERE auteur_id=:valeur ORDER BY time_validation DESC");
|
|
$recherche=$prepare->execute(array(":valeur"=>$id));
|
|
if((test_requete(__FILE__,__LINE__,$recherche,$prepare)===false)) return false;
|
|
$posts=$prepare->fetchAll(PDO::FETCH_ASSOC);
|
|
$prepare=null;
|
|
if($crea_cache)
|
|
$cache=crea_cache(CACHE_REP_POSTS."/auteurs/".$id[0]."/$id.txt",$posts);
|
|
return $posts;
|
|
}
|
|
/**
|
|
* Méthode ouvrant le fichier cache des annonces postées par un utilisateur
|
|
*
|
|
* @param l'utilisateur qui nous intéresse, crea_cache : booléen à true si il faut lancer la création du fichier en cas d'absence,
|
|
* @return tableau contenant les infos des posts telles que fournies par le fichier (peut être vide), false en cas d'erreur
|
|
* @author Fabrice PENHOËT
|
|
* */
|
|
static function get_liste_posts_auteur_cache($auteur,$crea_cache=false)
|
|
{
|
|
global $Bd;
|
|
if(empty($auteur))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
|
|
return false;
|
|
}
|
|
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;
|
|
}
|
|
$id=strval($auteur->id_utilisateur);
|
|
$fichier=CACHE_REP."/".CACHE_REP_POSTS."/auteurs/".$id[0]."/$id.txt";
|
|
if(!file_exists($fichier))
|
|
{
|
|
if($crea_cache)
|
|
{
|
|
if(empty($GLOBALS['Bd']))
|
|
require("connexion-bd.php");
|
|
if(empty($GLOBALS['Bd'])) return false;
|
|
if(self::get_liste_posts_auteur($auteur,true)===false)
|
|
return false;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
if(!file_exists($fichier))//ne devrait pas être possible mais...
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_EXISTE." >> ".$fichier));
|
|
return false;
|
|
}
|
|
include($fichier);//le fichier peut être vide si aucune annonce postée par cet utilisateur, mais peut aussi contenir des annonces non validées à filtrer à l'affichage.
|
|
if(empty($t))
|
|
return false;
|
|
else
|
|
return $t;
|
|
}
|
|
/**
|
|
* Méthode listant les dernières annonces postées par un utilisateur et qui ont été validées,
|
|
* y compris les annonces qui ne sont pas encore à diffuser.
|
|
*
|
|
* @param booléen pour savoir si il faut enregistrer le résultat dans un fichier, champs souhaités en sortie, nombre max d'actualités listées.
|
|
* @return liste des annonces dans un tableau si trouvé (peut être vide), false en cas d'erreur
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
static function get_liste_derniers_posts($crea_cache=false,$champs="id_post,ancre,url,time_validation,time_diffusion,hub_id,auteur_id",$nb_max=30)
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
$get_posts=$Bd->query("SELECT $champs FROM hub_post WHERE auteur_id IS NOT NULL AND time_validation!=0 AND annonce IS NOT NULL AND annonce!='' ORDER BY time_validation DESC LIMIT 0,$nb_max");
|
|
if((test_requete(__FILE__,__LINE__,$get_posts)===false)) return false;
|
|
$posts=$get_posts->fetchAll(PDO::FETCH_ASSOC);
|
|
if($crea_cache)
|
|
$cache=crea_cache(CACHE_REP_POSTS."/derniers.txt",$posts);
|
|
return $posts;
|
|
}
|
|
/**
|
|
* Méthode ouvrant le fichier cache des dernières annonces postées par des utilisateurs
|
|
*
|
|
* @param crea_cache : booléen à true si il faut lancer la création du fichier en cas d'absence,
|
|
* @return tableau contenant les infos des posts telles que fournies par le fichier (peut être vide), false en cas d'erreur
|
|
* @author Fabrice PENHOËT
|
|
* */
|
|
static function get_liste_derniers_posts_cache($crea_cache=false)
|
|
{
|
|
global $Bd;
|
|
$fichier=CACHE_REP."/".CACHE_REP_POSTS."/derniers.txt";
|
|
if(!file_exists($fichier))
|
|
{
|
|
if($crea_cache)
|
|
{
|
|
if(empty($GLOBALS['Bd']))
|
|
require("connexion-bd.php");
|
|
if(empty($GLOBALS['Bd'])) return false;
|
|
if(self::get_liste_derniers_posts(true)===false)
|
|
return false;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
if(!file_exists($fichier))//ne devrait pas être possible mais...
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FICHIER_EXISTE." >> ".$fichier));
|
|
return false;
|
|
}
|
|
include($fichier);
|
|
if(empty($t))
|
|
return false;
|
|
else
|
|
return $t;
|
|
}
|
|
/**
|
|
* Méthode supprimant les anciens posts de la base de données
|
|
* Le cas des liens venant des flux est traité dans FclFlux_flux->import_liens()
|
|
* J'en profite pour supprimer les clics les plus anciens dans stat_clics_posts
|
|
*
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
static function supprime_anciens_posts()
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
$now=time();
|
|
$sql_time_limite="((time_expiration!=0 AND time_expiration<$now) OR (time_expiration=0 AND time_diffusion=0 AND time_crea+(".POSTS_MAX_JOURS."*24*3600)<$now) OR (time_expiration=0 AND time_diffusion!=0 AND time_diffusion+(".POSTS_MAX_JOURS."*24*3600)<$now))";
|
|
// on traite 1 par 1 les posts ayant un auteur car dans ce cas il peut y avoir un fichier cache et ou une image à supprimer
|
|
$get_posts_auteur=$Bd->query("SELECT id_post FROM hub_post WHERE ($sql_time_limite AND (auteur_id IS NOT NULL));");
|
|
if((test_requete(__FILE__,__LINE__,$get_posts_auteur)===false)) return false;
|
|
$posts_auteur=$get_posts_auteur->fetchAll(PDO::FETCH_ASSOC);
|
|
foreach($posts_auteur as $post_infos)
|
|
{
|
|
$post_suppr=new FclFlux_post();
|
|
$post_suppr->id_post=$post_infos["id_post"];
|
|
$post_suppr->supprime();//--> actualise le cache des diverses listes de posts concernées
|
|
}
|
|
unset($post_suppr);
|
|
// suppression de tous les clics enregistrés dont on plus besoin
|
|
// c'est-à-dire les clics des utilisateurs n'ayant plus d'abonnement actif.
|
|
$suppr_clics=$Bd->query("DELETE FROM stat_clics_posts WHERE ((utilisateur_id NOT IN(SELECT DISTINCT auteur_id FROM `abonnements` where jours_alerte!='')));");
|
|
if((test_requete(__FILE__,__LINE__,$suppr_clics)===false)) return false;
|
|
unset($suppr_clics);
|
|
// la suppression des clics obsolètes des abonnements toujours actifs se fait dans FclFlux_abonnement::desactivation()
|
|
// + suppression des annonces qui n'ont jamais été validées par leur auteur.
|
|
$time_limite=time()-COMPTE_VALIDATION_MAX_DUREE*24*3600;
|
|
$suppr=$Bd->query("DELETE FROM hub_post WHERE ((time_crea<$time_limite) AND (flux_id=NULL) AND (auteur_id=NULL));");
|
|
if((test_requete(__FILE__,__LINE__,$suppr)===false)) return false;
|
|
unset($suppr);
|
|
return true;
|
|
}
|
|
/**
|
|
* Affichage par défaut d'un objet
|
|
*
|
|
* @return chaîne de caractères listant la valeur de chaque attribut
|
|
* @author Fabrice PENHOËT
|
|
**/
|
|
public function __toString()
|
|
{
|
|
$texte="<h3>".__CLASS__."</h3>";
|
|
foreach($this as $key => $value)
|
|
{
|
|
if(is_array($value))
|
|
$value=affiche_tableau($value,"<li>#valeur</li>","<ul>","</ul>");
|
|
$texte.="$key : $value\n";
|
|
}
|
|
return $texte;
|
|
}
|
|
}//fin de la classe
|
|
|
|
/**
|
|
* Méthode listant les posts ayant reçus le + d'actions (=clics) / utilisateur sur une période
|
|
*
|
|
* @param $action=action recherchée, les dates de début et de fin de la période concernée, $nb_max le nombre de résultats
|
|
* @return liste des des messages dans un tableau si trouvé (peut être vide), false en cas d'erreur
|
|
* @author Fabrice PENHOËT
|
|
*
|
|
static function get_top_posts_action($action="clic",$date_debut,$date_fin,$nb_max=30)
|
|
{
|
|
global $Bd;
|
|
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
|
|
if(empty($date_fin))
|
|
$date_fin=date("d/m/Y");
|
|
$actions_ok=explode("|",LIEN_ACTIONS);
|
|
if(!in_array($action,$actions_ok))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_AUTORISES." >> ".htmlentities($action,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
if(!is_int($nb_max))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
if(preg_match(DATE_FORMAT_EREG,$date_debut)==0)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_DATE_FORMAT));
|
|
return false;
|
|
}
|
|
if(preg_match(DATE_FORMAT_EREG,$date_fin)==0)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_DATE_FORMAT));
|
|
return false;
|
|
}
|
|
$dates_debut=explode("/",$date_debut);
|
|
$dates_fin=explode("/",$date_fin);
|
|
if(!checkdate($dates_debut[1],$dates_debut[0],$dates_debut[2]))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_DATE_VALIDE));
|
|
return false;
|
|
}
|
|
if(!checkdate($dates_fin[1],$dates_fin[0],$dates_fin[2]))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_DATE_VALIDE));
|
|
return false;
|
|
}
|
|
if(IntervalDates($date_debut,$date_fin)<=0)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_DATE_INTERVAL));
|
|
return false;
|
|
}
|
|
$time_debut=mktime(0,0,0,$dates_debut[1],$dates_debut[0],$dates_debut[2]);
|
|
$time_fin=mktime(0,0,0,$dates_fin[1],$dates_fin[0],$dates_fin[2]);
|
|
$prepare=$Bd->prepare("SELECT DISTINCT ancre,url,flux_id,auteur_id,count(id_action) AS Cpt FROM hub_post AS P,hub_post_actions AS A WHERE ((P.id_post=A.post_id) AND (time_action >=:time_debut) AND (time_action <:time_fin) AND (action=:action)) GROUP BY post_id ORDER BY count(id_action) DESC LIMIT 0,$nb_max;");
|
|
$recherche=$prepare->execute(array(":time_debut"=>$time_debut,":time_fin"=>$time_fin,":action"=>$action));
|
|
if((test_requete(__FILE__,__LINE__,$recherche,$prepare)===false)) return false;
|
|
$resultat=$prepare->fetchAll(PDO::FETCH_ASSOC);
|
|
$prepare=null;
|
|
return $resultat;
|
|
}
|
|
/**
|
|
* Méthode de création du cache des annonces les + cliqués/partagés sur une période donnée
|
|
*
|
|
* @param $action=action recherchée, $periode la périodicité, la date de fin de la période, $nb_max le nombre de résultats
|
|
* @return booléen suivant succès
|
|
* @author Fabrice PENHOËT
|
|
*
|
|
static function crea_cache_top_posts_action($periode="jour",$action="clic",$date_fin="",$nb_max=30)
|
|
{
|
|
$actions_ok=explode("|",LIEN_ACTIONS);
|
|
if (!in_array($action,$actions_ok))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_AUTORISES." >> ".htmlentities($action,ENT_QUOTES)));
|
|
return false;
|
|
}
|
|
if(!is_int($nb_max))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
|
|
return false;
|
|
}
|
|
if(empty($date_fin))
|
|
$date_fin=date("d/m/Y");
|
|
if(preg_match(DATE_FORMAT_EREG,$date_fin)==0)
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_DATE_FORMAT));
|
|
return false;
|
|
}
|
|
$dates_fin=explode("/",$date_fin);
|
|
if(!checkdate($dates_fin[1],$dates_fin[0],$dates_fin[2]))
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_DATE_VALIDE));
|
|
return false;
|
|
}
|
|
$time_fin=mktime(0,0,0,$dates_fin[1],$dates_fin[0],$dates_fin[2]);
|
|
if($periode=="jour")
|
|
{//à lancer après minuit pour stats de la veille
|
|
$time_debut=$time_fin-3600*24;
|
|
$date_debut=date("d/m/Y",$time_debut);
|
|
$dates_debut=explode("/",$date_debut);
|
|
$adresse_fichier=CACHE_REP_LIENS."/stats-".$action."/".$periode."/".$dates_debut[2]."-".$dates_debut[1]."-".$dates_debut[0];
|
|
}
|
|
else if($periode=="hebdo")
|
|
{//à lancer la lundi pour stats de la semaine précédente
|
|
$time_debut=$time_fin-3600*24*7;
|
|
$date_debut=date("d/m/Y",$time_debut);
|
|
$dates_debut=explode("/",$date_debut);
|
|
$num_semaine=date("W",$time_debut);
|
|
$adresse_fichier=CACHE_REP_LIENS."/stats-".$action."/".$periode."/".$dates_debut[2]."-".$num_semaine;
|
|
}
|
|
else if($periode=="mois")
|
|
{//à lancer le 1er du mois pour les stats du mois précédent
|
|
if($dates_fin[1]=="01")
|
|
{
|
|
$annee_debut=$dates_fin[2]-1;
|
|
$mois_debut="12";
|
|
}
|
|
else
|
|
{
|
|
$annee_debut=$dates_fin[2];
|
|
$mois_debut=$dates_fin[1]-1;
|
|
if(strlen($mois_debut)==1)
|
|
$mois_debut="0".$mois_debut;
|
|
}
|
|
$date_debut="01/$mois_debut/$annee_debut";
|
|
$adresse_fichier=CACHE_REP_LIENS."/stats-".$action."/".$periode."/".$annee_debut."-".$mois_debut;
|
|
}
|
|
else
|
|
{
|
|
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_AUTORISES));
|
|
return false;
|
|
}
|
|
$stats=self::get_top_posts_action($action,$date_debut,$date_fin,$nb_max);
|
|
return crea_cache($adresse_fichier,$stats);
|
|
}*/ |