Fab_Blab/hellofacteurV1
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
master
hellofacteurV1/modele/FclFlux_flux.php

1080 lines
39 KiB
PHP
Executable File
Raw Permalink Blame History

<?php
/**
* classe dérivée de la classe Flux
* on va spécifier ici tout ce qui est propre à cette application :
* manipulation base de données, cache, attributs supplémentaires...
* on a besoin de la classe FclFlux_utilisateur pour définir les utilisateurs ayant enregistré les flux
* + FclFlux_source pour le classement
* + FclFlux_post & FclFlux_hub pour l'importation du contenu des flux
*
* @author Fabrice PENHOËT
**/
require_once("flux.php");
require_once("FclFlux_utilisateur.php");
require_once("FclFlux_source.php");
require_once("FclFlux_post.php");
require_once("FclFlux_hub.php");
require_once("FclFlux_abonnement.php");
class FclFlux_flux extends Flux
{
public $id_flux;
private $auteur; // objet de type FclFlux_utilisateur ou null (si utilisateur supprimé)
private $source; // objet de type FclFlux_source
protected $description;
private $langue; // langue principale du flux
private $frequence_maj; // à quelle fréquence ce flux est-il actualisé ?
private $time_crea; // timestamp d'enregistrement du flux
private $time_maj; // timestamp de la dernière mise à jour des infos du flux
private $time_lecture; // timestamp de la dernière tentative d'importation du flux
private $memo; // mémo interne, non destiné à être publié.
/**
* 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 est bien une source existante
* et lui attribuant l'origine du flux 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_source($source)
{
if(!empty($source))
{
if(!($source instanceof FclFlux_source))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
return false;
}
if(empty($source->id_source))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
return false;
}
$existe=FclFlux_source::recherche($source->id_source,"id_source");
if(empty($existe))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT));
return false;
}
}
else
$source="";
$this->source=$source;
return true;
}
/**
* Méthode vérifiant que le paramètre fourni est bien un utilisateur existant
* et lui attribuant l'origine du flux 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." >> ".intval($auteur->id_utilisateur)));
return false;
}
$this->auteur=$auteur;
return true;
}
/**
* Méthode vérifiant le texte de description fourni
*
* @param la description à contôler
* @return booléen suivant succès
* @author Fabrice PENHOËT
*/
public function set_description($description)
{
if(empty($this->limites["description_long_max"]))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
return false;
}
$long_max=$this->limites["description_long_max"];
if(!is_int($long_max))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
return false;
}
$description=strip_tags(strval(trim($description)));
if(empty($description))
$this->description=null;
else
$this->description=get_chaine_debut($description,$long_max," (...)");
return true;
}
/**
* Méthode vérifiant que le paramètre fourni fait partie des valeurs possibles
* et lui attribuant la fréquence de lecture du flux 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_frequence_maj($frequence_maj)
{
$valeurs_ok=explode("|",FLUX_FREQUENCES);
if(empty($valeurs_ok))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
return false;
}
if (!in_array($frequence_maj,$valeurs_ok))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_AUTORISES." >> ".htmlentities($frequence_maj,ENT_QUOTES)));
return false;
}
$this->frequence_maj=$frequence_maj;
return true;
}
/**
* Méthode vérifiant que le paramètre fourni fait partie des valeurs possibles
* et lui attribuant la langue principale du flux 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_langue($langue)
{
$valeurs_ok=explode("|",FLUX_LANGUES);
if(empty($valeurs_ok))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
return false;
}
if (!in_array($langue,$valeurs_ok))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_AUTORISES." >> ".htmlentities($langue,ENT_QUOTES)));
return false;
}
$this->langue=$langue;
return true;
}
/**
* Méthode testant la validité du mémo saisi pour un flux
* 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_memo($memo)
{
$long_min=(!empty($this->limites["memo_long_min"]))?$this->limites["memo_long_min"]:0;
if(empty($this->limites["memo_long_max"]))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
return false;
}
$long_max=$this->limites["memo_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;
}
$memo=strip_tags(strval(trim($memo)));
$longueur=strlen($memo);
if(($longueur<$long_min)||($longueur>$long_max))
{
$this->erreurs=array_merge($this->erreurs,(array) (str_replace("__MAX__",$long_max,ERREUR_FLUX_MEMO_LONG)));
return false;
}
else
{
$this->memo=$memo;
return true;
}
}
/**
* Méthode testant l'existence d'un flux dans le bd via son id_flux ou son url (seuls champs 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_recherche="id_flux",$champ_sortie="*")
{
global $Bd;
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
if(strpos("id_flux,url",$champ_recherche)===false)
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_CHAMP_RECHERCHE." >> ".htmlentities($champ_recherche,ENT_QUOTES)));
return false;
}
$prepare=$Bd->prepare("SELECT $champ_sortie FROM flux WHERE $champ_recherche=:valeur");
$recherche=$prepare->execute(array(":valeur"=>$valeur));
if((test_requete(__FILE__,__LINE__,$recherche,$prepare)===false)) return false;
$resultat=$prepare->fetch(PDO::FETCH_ASSOC);
$prepare=null;
if(empty($resultat))
return false;
else
return $resultat;
}
/**
* Méthode de recherche des flux 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 flux WHERE id_flux=:cherche_id OR nom LIKE :recherche OR url LIKE :recherche OR description LIKE :recherche ORDER BY nom 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;
}
/**
* Test si une valeur donnée pour un champ est déjà utilisée pour un autre flux
*
* @return true si valeur non trouvée
* @author Fabrice PENHOËT
**/
public function est_libre($champ="url")
{
global $Bd;
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
if(empty($this->id_flux))//nouveau flux non encore enregistré
{
$prepare=$Bd->prepare("SELECT id_flux FROM flux WHERE $champ=:$champ");
$recherche=$prepare->execute(array(":$champ"=>$this->$champ));
}
else
{
$prepare=$Bd->prepare("SELECT id_flux FROM flux WHERE ($champ=:$champ and id_flux!=:id)");
$recherche=$prepare->execute(array(":$champ"=>$this->$champ,":id"=>$this->id_flux));
}
if((test_requete(__FILE__,__LINE__,$recherche,$prepare)===false)) return false;
$resultat=$prepare->fetch();
$prepare=null;
if(empty($resultat))//pas de doublon
return true;
else
return false;
}
/**
* Méthode enregistrant un nouveau flux
*
* @param $hub dans lequel classé ce flux si on le connait.
* @return booléen suivant succès
* @author Fabrice PENHOËT
**/
public function ajout($hub=null)
{
global $Bd;
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
if((empty($this->designation))||(empty($this->url))||(empty($this->auteur)))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
return false;
}
if(!($this->est_libre()))
{
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_FLUX_DOUBLON);
return false;
}
if(empty($this->langue))
$this->langue="fr";
if(empty($this->frequence_maj))
$this->frequence_maj="J";
$this->time_crea=time();
// cas particulier de GG News
$gg_news_ok=false;
if((strpos($this->url,"https://news.google.com")!==false)&&(defined("SOURCE_GG_NEWS_ID")))
{
$gg_news=new FclFlux_source();
$gg_news->id_source=SOURCE_GG_NEWS_ID;
$this->set_source($gg_news);
unset($gg_news);
$gg_news_ok=true;
}
//le flux est-il à valider par un administrateur ?
$est_admin=$this->auteur->est_admin();
if(($est_admin)||($gg_news_ok))
$this->time_maj=$this->time_crea;
else
$this->time_maj=0;//reste à valider
if(empty($this->source))
{//si je n'ai pas de source fournie, j'en créé une, basée sur les infos du flux.
$source=new FclFlux_source();
$max["url_long_max"]=SOURCE_MAX_URL;
$max["designation_long_min"]=SOURCE_MIN_NOM;
$max["designation_long_max"]=SOURCE_MAX_NOM;
$max["description_long_max"]=SOURCE_MAX_DESCRIPTION;
$source->limites=$max;
if(!empty($this->source_url))
$source->set_url(get_chaine_debut($this->source_url,SOURCE_MAX_URL));
else
$source->set_url(get_chaine_debut($this->url,SOURCE_MAX_URL));
$source->set_designation(get_chaine_debut($this->designation,SOURCE_MAX_NOM));
$source->set_description(get_chaine_debut($this->description,SOURCE_MAX_DESCRIPTION));
$source->set_auteur($this->auteur);
$source->ajout();
if(empty($source->id_source))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_AJOUT." >> ".intval($this->auteur->id_utilisateur)." >> ".intval($flux->id_flux)));
return false;
}
else
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,"Un nouveau source vient d'être créée par un utilisateur (".strval($this->auteur->id_utilisateur).") >> ".strval($source->id_source)));
$this->source=$source;
}
}
if(empty($this->description))
$this->description=null;
$prepare=$Bd->prepare("INSERT INTO flux (nom,url,description,auteur_id,langue,frequence_maj,time_crea,time_maj,memo) VALUES (:nom,:url,:description,:auteur_id,:langue,:frequence_maj,:time_crea,:time_maj,:memo)");
$ajout=$prepare->execute(array(':nom'=>$this->designation,':url'=>$this->url,':description'=>$this->description,':auteur_id'=>$this->auteur->id_utilisateur,':langue'=>$this->langue,':frequence_maj'=>$this->frequence_maj,':time_crea'=>$this->time_crea,':time_maj'=>$this->time_maj,':memo'=>$this->memo));
if((test_requete(__FILE__,__LINE__,$ajout,$prepare)===false)) return false;
$this->id_flux=$Bd->lastInsertId();
$prepare=null;
$this->crea_cache();
$this->actualise_source();
// classement du flux dans son hub
if(!empty($hub))
$this->ajout_hub($hub);//fait tous les tests nécessaires...
elseif($est_admin===false)
{//création d'un hub temporaire calqué sur le flux pour permette à l'utilisateur de s'y abonner.
$hub=new FclFlux_hub();
$max["nom_long_min"]=HUB_MIN_NOM;
$max["nom_long_max"]=HUB_MAX_NOM;
$max["description_long_max"]=HUB_MAX_DESCRIPTION;
$hub->limites=$max;
$hub->set_nom(get_chaine_debut($this->designation,HUB_MAX_NOM));
$hub->set_description(get_chaine_debut($this->description,HUB_MAX_DESCRIPTION));
$hub->set_auteur($this->auteur);
$hub->set_langue($this->langue);
$hub->ajout();
if(empty($hub->id_hub))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_AJOUT." >> ".intval($this->auteur->id_utilisateur)." >> ".intval($flux->id_flux)));
return false;
}
else
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,MSG_HUB_AJOUT." >> ".intval($this->auteur->id_utilisateur)." >> ".intval($hub->id_hub)));
$this->ajout_hub($hub);
unset($hub);
}
}
return true;
}
/**
* Méthode enregistrant une mise à jour des infos principales d'un flux
*
* @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->designation))||(empty($this->url))||(empty($this->id_flux)))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
return false;
}
if(!($this->est_libre()))
{
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_FLUX_DOUBLON);
return false;
}
$a_flux=self::recherche($this->id_flux,"id_flux","description,langue,frequence_maj,memo");
if(empty($a_flux))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT.">>".intval($this->id_flux)));
return false;
}
if(!isset($this->description))
$this->description=$a_flux["description"];
if(!isset($this->langue))
$this->langue=$a_flux["langue"];
if(!isset($this->frequence_maj))
$this->frequence_maj=$a_flux["frequence_maj"];
if(!isset($this->memo))
$this->memo=$a_flux["memo"];
$prepare=$Bd->prepare("UPDATE flux SET nom=:nom,url=:url,description=:description,langue=:langue,frequence_maj=:frequence_maj,time_maj=:date_actuelle,memo=:memo WHERE id_flux=:id_flux;");
$maj=$prepare->execute(array(':nom'=>$this->designation,':url'=>$this->url,':description'=>$this->description,':langue'=>$this->langue,':frequence_maj'=>$this->frequence_maj,':date_actuelle'=>time(),':memo'=>$this->memo,':id_flux'=>$this->id_flux));
if((test_requete(__FILE__,__LINE__,$maj,$prepare)===false)) return false;
$prepare=null;
$this->crea_cache();
$this->actualise_source();
return true;
}
/**
* Méthode enregistrant l'association d'une source au flux
*
* @return booléen suivant succès
* @author Fabrice PENHOËT
**/
public function actualise_source()
{
global $Bd;
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
if((empty($this->source))||(empty($this->id_flux)))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
return false;
}
$nouvelle_source=$this->source->id_source;
$a_flux=self::recherche($this->id_flux,"id_flux","source_id");
if(empty($a_flux))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT.">>".intval($this->id_flux)));
return false;
}
$a_source=$a_flux["source_id"];
if($a_source==$nouvelle_source)
return true;//rien ne change...
$prepare=$Bd->prepare("UPDATE flux SET source_id=:source_id WHERE id_flux=:id_flux;");
$maj=$prepare->execute(array(':source_id'=>$nouvelle_source,':id_flux'=>$this->id_flux));
if((test_requete(__FILE__,__LINE__,$maj,$prepare)===false)) return false;
$prepare=null;
$this->crea_cache();
return true;
}
/**
* Méthode testant l'existence d'un lien entre un flux et un hub.
*
* @param le hub à contrôler
* @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_hub($hub)
{
global $Bd;
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
if(empty($this->id_flux))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
return false;
}
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;
}
$prepare=$Bd->prepare("SELECT * FROM hub_flux WHERE (id_hub=:id_hub AND id_flux=:id_flux)");
$recherche=$prepare->execute(array(":id_hub"=>$hub->id_hub,":id_flux"=>$this->id_flux));
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 lien entre un flux et un hub.
*
* @param le $hub (objet)
* @return booléen suivant succès
* @author Fabrice PENHOËT
**/
public function ajout_hub($hub=null)
{
global $Bd;
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
if(empty($this->id_flux))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
return false;
}
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;
}
$existe=FclFlux_hub::recherche($hub->id_hub,"id_hub");
if(empty($existe))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT." >> ".intval($hub->id_hub)));
return false;
}
$classement=$this->est_dans_hub($hub);
if($classement)
{
$this->erreurs=array_merge($this->erreurs,(array) (ERREUR_SQL_DOUBLON." >> ".intval($this->id_flux)." >> ".intval($hub->id_hub)));
return false;
}
$prepare=$Bd->prepare("INSERT INTO hub_flux(id_flux,id_hub) VALUES (:id_flux,:id_hub)");
$classement=$prepare->execute(array(':id_flux'=>$this->id_flux,':id_hub'=>$hub->id_hub));
if((test_requete(__FILE__,__LINE__,$classement,$prepare)===false)) return false;
$prepare=null;
$this->crea_cache();
return true;
}
/**
* Méthode supprimant du lien entre un flux et un hub
*
* @param le $hub (objet)
* @return booléen suivant succès
* @author Fabrice PENHOËT
**/
public function suppr_hub($hub=null)
{
global $Bd;
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
if(empty($this->id_flux))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
return false;
}
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;
}
$classement=$this->est_dans_hub($hub);
if(!$classement)
return false;
$prepare=$Bd->prepare("DELETE FROM hub_flux WHERE (id_hub=:id_hub AND id_flux=:id_flux) LIMIT 1;");
$classement=$prepare->execute(array(':id_flux'=>$this->id_flux,':id_hub'=>$hub->id_hub));
if((test_requete(__FILE__,__LINE__,$classement,$prepare)===false)) return false;
$prepare=null;
$this->crea_cache();
return true;
}
/**
* Méthode cherchant si il y a des flux qu'un administrateur doit valider.
*
* @param null
* @return les données de la table dans un tableau si trouvé, false si pas trouvé ou en cas d'erreur
* @author Fabrice PENHOËT
**/
static function get_a_valider()
{
global $Bd;
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
$get_flux=$Bd->query("SELECT id_flux,nom FROM flux WHERE time_maj=0");
if((test_requete(__FILE__,__LINE__,$get_flux)===false)) return false;
$resultat=$get_flux->fetchAll(PDO::FETCH_ASSOC);
$prepare=null;
if(empty($resultat))
return false;
else
return $resultat;
}
/**
* Méthode listant les hubs auxquels est lié un flux
*
* @return liste des id_hub dans un tableau si trouvé (peut être vide), false en cas d'erreur
* @author Fabrice PENHOËT
**/
public function get_hubs()
{
global $Bd;
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
if(empty($this->id_flux))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
return false;
}
$prepare=$Bd->prepare("SELECT id_hub FROM hub_flux WHERE id_flux=:valeur");
$recherche=$prepare->execute(array(":valeur"=>$this->id_flux));
if((test_requete(__FILE__,__LINE__,$recherche,$prepare)===false)) return false;
$resultat=$prepare->fetchAll(PDO::FETCH_ASSOC);
$prepare=null;
return $resultat;
}
/**
* Méthode retournant la liste des abonnés actifs d'un flux (et donc leur nombre)
*
* @return les données dans un tableau php, false en cas d'erreur
* @author Fabrice PENHOËT
**/
public function get_liste_abonnes()
{
global $Bd;
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
if(empty($this->id_flux))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
return false;
}
$stats=array();
$get_actifs=$Bd->query("SELECT DISTINCT auteur_id FROM abonnements as A,abonnements_hub as H,hub_flux as F WHERE ((H.id_abonnement=A.id_abonnement) AND (H.id_hub=F.id_hub) AND (F.id_flux=".$this->id_flux.") AND (A.jours_alerte!='') AND (A.actif_ok=1));");
if((test_requete(__FILE__,__LINE__,$get_actifs)===false)) return false;
$stats["actifs"]=$get_actifs->fetchAll();
unset($get_actifs);
$get_inactifs=$Bd->query("SELECT DISTINCT auteur_id FROM abonnements as A,abonnements_hub as H,hub_flux as F WHERE ((H.id_abonnement=A.id_abonnement) AND (H.id_hub=F.id_hub) AND (F.id_flux=".$this->id_flux.") AND (A.jours_alerte=''));");
if((test_requete(__FILE__,__LINE__,$get_inactifs)===false)) return false;
$stats["inactifs"]=$get_inactifs->fetchAll();
unset($get_inactifs);
$get_en_pause=$Bd->query("SELECT DISTINCT auteur_id FROM abonnements as A,abonnements_hub as H,hub_flux as F WHERE ((H.id_abonnement=A.id_abonnement) AND (H.id_hub=F.id_hub) AND (F.id_flux=".$this->id_flux.") AND (A.jours_alerte!='') AND (A.actif_ok=0));");
if((test_requete(__FILE__,__LINE__,$get_en_pause)===false)) return false;
$stats["en_pause"]=$get_en_pause->fetchAll();
unset($get_en_pause);
return $stats;
}
/**
* Méthode créant le fichier cache contenant les infos utiles d'un flux
*
* @return booléen suivant succès
* @author Fabrice PENHOËT
**/
public function crea_cache()
{
if(empty($this->id_flux))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
return false;
}
$infos=self::recherche($this->id_flux,"id_flux","nom,url,source_id,description,langue");
if($infos===false)
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT." >> ".intval($this->id_flux)));
return false;
}
$hubs=$this->get_hubs();
if(!empty($hubs))
$infos=array_merge($infos,$hubs);
$id=strval($this->id_flux);
return crea_cache(CACHE_REP_FLUX."/".$id[0]."/$id.txt",$infos);
}
/**
* Méthode ouvrant le fichier cache contenant les infos d'un flux
*
* @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 flux 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_flux))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
return false;
}
$id=strval($this->id_flux);
$fichier=CACHE_REP."/".CACHE_REP_FLUX."/".$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())
return false;
}
else
return false;
}
include($fichier);
if(empty($t))
return false;
else
{
foreach($t as $key => $value)
{
if(!is_array($value)) //cela doit être l'id d'un des hubs liés au flux.
$infos[$key]=stripslashes($value);
}
//+infos de la source
if(!empty($t['source_id']))
{
$source=new FclFlux_source();
$source->id_source=$t['source_id'];
$source_infos=$source->get_infos_cache($crea_cache);
if(!empty($source_infos))
$infos["source"]=$source_infos;
unset($source);
}
}
if(empty($infos))
return false;
else
return $infos;
}
/**
* Méthode de suppression du fichier cache lié à un flux
* id_flux doit être connu
*
* @return booléen suivant succès
* @author Fabrice PENHOËT
**/
public function suppr_cache()
{
if(empty($this->id_flux))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
return false;
}
$id=strval($this->id_flux);
$chemin=CACHE_REP."/".CACHE_REP_FLUX."/".$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 vérifiant qu'un lien venant d'un flux donné n'a pas déjà été importé dans un hub.
* raison : un même lien peut apparaître dans différents flux d'un même site ayant des abonnés différents
* et les liens d'un même flux peuvent être importés dans plusieurs flux différents.
* seuls les abonnés du premier flux importé (ou hub) verraient alors le lien
* les doublons possibles sont à gérer à l'affichage de l'abonnement
*
* @param l'url du lien et les identifiants du flux et du hub à tester. Si un titre est fourni il est aussi testé.
* @return booléen suivant si il s'agit d'un doublon ou pas
* @author Fabrice PENHOËT
**/
static function test_lien_doublon($url,$id_flux,$id_hub,$titre="")
{
global $Bd;
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
if((empty($url))||(empty($id_flux))||(empty($id_hub)))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
return false;
}
if(empty($titre))
{
$prepare=$Bd->prepare("SELECT id_post FROM hub_post WHERE ((url=:url) AND (flux_id=:id_flux) AND (hub_id=:id_hub))");
$recherche=$prepare->execute(array(":url"=>$url,":id_flux"=>$id_flux,":id_hub"=>$id_hub));
}
else
{
$prepare=$Bd->prepare("SELECT id_post FROM hub_post WHERE ((url=:url OR ancre=:titre) AND (flux_id=:id_flux) AND (hub_id=:id_hub))");
$recherche=$prepare->execute(array(":url"=>$url,":titre"=>$titre,":id_flux"=>$id_flux,":id_hub"=>$id_hub));
}
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 true;
}
/**
* Méthode enregistrant les nouveaux liens trouvés lors de la lecture d'un flux
* Chaque nouveau lien est enregistré dans le(s) hub(s) associés à ce flux
* C'est aussi ici que je supprime les anciens liens provenant du flux dans le cas où il ne fournit pas dates pour ses items.
*
* @param $nb_max de liens à récupérés
* @return nombre de nouveaux liens importés, false en cas d'erreur rencontrée
* @author Fabrice PENHOËT
**/
public function import_liens($nb_max=50)
{
global $Bd;
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
if(empty($this->id_flux))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
return false;
}
if(empty($this->url))
{
$cherche_url=SELF::recherche($this->id_flux,"id_flux","url");
if(empty($cherche_url))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT." >> ".$this->id_flux));
return false;
}
$this->url=$cherche_url["url"];
unset($cherche_url);
}
// même si la lecture se déroule pas bien, le flux est enregistré comme ayant été traité pour ne pas bloquer les autres...
$date_actuelle=time();
$prepare_maj=$Bd->prepare("UPDATE flux SET time_lecture=:date_actuelle WHERE id_flux=:id");
$maj_flux=$prepare_maj->execute(array(":date_actuelle"=>$date_actuelle,":id"=>$this->id_flux));
if((test_requete(__FILE__,__LINE__,$maj_flux,$prepare_maj)===false)) return false;
unset($prepare_maj);
$liens=$this->lecture($nb_max);
if($liens===false)
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FLUX_LECTURE." >> ".htmlspecialchars($this->url)));
return false;
}
elseif($liens==null)
{
//$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_FLUX_VIDE." >> ".htmlspecialchars($this->url)));
return false;
}
$hubs=$this->get_hubs();
if(empty($hubs))
{
if($hubs===false)
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT." >> ".$this->id_flux));
else
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_SQL_ENREG_ABSENT." >> ".$this->id_flux));
return false;
}
$nb_liens=0;
if(!empty($liens))
{
$timeS_limite=time()-3600*24*LIEN_IMPORT_MAX_JOURS;//je n'importe pas les liens trop anciens
//je n'utilise pas la méthode ajout() de la classe FclFlux_post pouvoir optimiser sql en utilisant +sieurs fois les mêmes requêtes
$prepare=$Bd->prepare("INSERT INTO hub_post (hub_id,flux_id,ancre,url,time_crea,time_flux,time_validation) VALUES (:hub_id,:flux_id,:ancre,:url,:date_actuelle,:time_flux,:date_actuelle)");
//$prepare_svg=$Bd->prepare("INSERT INTO hub_post_svg (id_post,hub_id,flux_id,time_crea) VALUES (:id,:hub_id,:flux_id,:date_actuelle)");
foreach ($liens as $infos_lien)
{
if((empty($infos_lien["designation"]))||(empty($infos_lien["url"])))
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,"Lien non conforme dans le flux :".htmlentities($this->url,ENT_QUOTES)));
elseif((empty($infos_lien["timeS"]))||($infos_lien["timeS"]>=$timeS_limite))
{
$infos_lien["limites"]["url_long_max"]=POST_MAX_URL;
$infos_lien["limites"]["ancre_long_min"]=POST_MIN_ANCRE;
$infos_lien["limites"]["ancre_long_max"]=POST_MAX_ANCRE;
$infos_lien["ancre"]=get_chaine_debut(affiche_utf8(strip_tags($infos_lien["designation"]),UTF8_OK),255," (...)");
unset($infos_lien["designation"]);//sinon bug dans classe Lien ...
$post=new FclFlux_post($infos_lien);
if(empty($post->erreurs))
{
$lien_import=false;
foreach($hubs as $hub_infos)
{
$doublon=self::test_lien_doublon($infos_lien["url"],$this->id_flux,$hub_infos["id_hub"],$infos_lien["ancre"]);
if($doublon===false)
{
$time_flux=0;
if(!empty($infos_lien["timeS"]))
$time_flux=$infos_lien["timeS"];
$ajout=$prepare->execute(array(':hub_id'=>$hub_infos["id_hub"],':flux_id'=>$this->id_flux,':ancre'=>$infos_lien["ancre"],':url'=>$infos_lien["url"],':date_actuelle'=>$date_actuelle,':time_flux'=>$time_flux));
if((test_requete(__FILE__,__LINE__,$ajout,$prepare)===false)) return false;
$lien_import=true;//j'ai enregistré au moins une fois le lien trouvé
}
}
if($lien_import)
$nb_liens++;
}
unset($post);
}
if(!empty($infos_lien["url"]))
$urls_flux[]=$infos_lien["url"];//utile pour suppression + bas.
}
if(!empty($nb_liens))
{
// il y a du nouveau donc je peux supprimer les liens obsolètes concernant ce flux.
// il faut veiller à ne pas supprimer de liens toujours présents dans le flux pour éviter de les réimporter par la suite (si pas de date fournie).
// la suppression dans stat_clics_posts se fait dans FclFlux_post->supprime_anciens_posts()
$sql_in="'".implode("','",$urls_flux)."'";
if(!empty($sql_in))
$suppr=$Bd->query("DELETE FROM hub_post WHERE time_crea+(".POSTS_MAX_JOURS."*24*3600)<".$date_actuelle." AND flux_id=".$this->id_flux." AND url NOT IN($sql_in);");// je continue même si ça bug
else
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
unset($suppr);
foreach($hubs as $hub_infos)
{ // je mets à jour la liste des derniers posts de chaque hub recevant les liens de ce flux
$hub_cache=new FclFlux_hub();
$hub_cache->id_hub=$hub_infos["id_hub"];
$crea_cache=$hub_cache->get_liste_posts(true);
unset($hub_cache);
}
}
}
$prepare=null;$prepare_svg=null;
$prepare_maj=null;
return $nb_liens;
}
/**
* Méthode supprimant l'enregistrement d'un flux
* Le cache listant les flux de ses rubriques sera impacté + cache listant les flux de sa source
*
* @param si sauve_abo vaut true, je ne peux supprimer un flux ayant des abonnés (via les hubs)
* sinon et si ce flux est l'unique source d'information d'un hub qui n'est pas ouvert aux publications, le hub et ses abonnements sont supprimés.
* @return booléen suivant succès
* @author Fabrice PENHOËT
**/
public function supprime($sauve_abo=true)
{
global $Bd;
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
if(empty($this->id_flux))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_MANQUANT));
return false;
}
$prepare=$Bd->prepare("SELECT DISTINCT id_abonnement FROM abonnements_hub as A,hub_flux as F WHERE ((A.id_hub=F.id_hub) AND (F.id_flux=:id));");
$recherche=$prepare->execute(array(':id'=>$this->id_flux));
if((test_requete(__FILE__,__LINE__,$recherche,$prepare)===false)) return false;
$abonnements=$prepare->fetchAll(PDO::FETCH_ASSOC);
$prepare=null;
if((!empty($abonnements))&&($sauve_abo))
{
$this->erreurs=array_merge($this->erreurs,(array) ERREUR_FLUX_SUPPR_ABO);
unset($abonnements);
return false;
}
// hubs dans lesquels le contenu de ce flux était importé
$hubs=$this->get_hubs();
$prepare=$Bd->prepare("DELETE FROM flux WHERE id_flux=:id LIMIT 1;");
$suppr=$prepare->execute(array(':id'=>$this->id_flux));
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_flux)));
return false;
}
$this->suppr_cache();
if(!empty($hubs))
{
foreach($hubs as $hud_id)
{
// est-ce qu'il s'agissait du seul flux de ce hub ?
// est si oui ce hub est-il ouvert à la publication
$hub_test=new FclFlux_hub();
$hub_test->id_hub=$hud_id["id_hub"];
$flux_hub=$hub_test->get_flux();
$hub_infos=$hub_test->get_infos_cache(true);
if((count($flux_hub)==1)&&($hub_infos["publication_ok"]===false))
$hub_test->supprime(false);//supprime en même temps les abonnements
unset($hub_test);unset($hub_infos);
}
}
return true;
}
/**
* 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;
}
/**
* Méthode effectuant périodiquement l'importation de nouveaux liens en provenance des flux
* Seuls les flux importés dans un hub ayant au moins 1 abonné actif sont traités
* On actualise le cache si aucun bug est rencontré
*
* @param $nb_flux : nombre limite de flux à importés, $periode : périodicité des flux concernés
* @return nombre de flux importés avec succès. false en cas d'erreur.
* @author Fabrice PENHOËT
**/
static function importation($nb_flux=10,$periode="H")
{
global $Bd;
if((isset_connexion(__FILE__,__LINE__)===false)) return false;
if(!is_int($nb_flux))
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_FORMAT));
return false;
}
if($periode=="H")
$time_limite=time()-3600;//toutes les heures
elseif($periode=="J")
$time_limite=time()-3600*12;//2 fois / jours
else
{
$ajout_journal=new journal_erreurs(array(__FILE__,__LINE__,ERREUR_PARAM_AUTORISES));
return false;
}
$prepare=$Bd->prepare("SELECT DISTINCT F.id_flux,F.url,F.time_lecture FROM flux AS F,hub_flux AS H,abonnements_hub AS AH,abonnements AS Abo WHERE ((F.id_flux=H.id_flux) AND (H.id_hub=AH.id_hub) AND (AH.id_abonnement=Abo.id_abonnement) AND ((F.frequence_maj=:periode) AND (F.time_lecture<=:limite) AND (Abo.jours_alerte!=''))) ORDER BY F.time_lecture ASC LIMIT 0,$nb_flux");
$recherche=$prepare->execute(array(":periode"=>$periode,":limite"=>$time_limite));
if((test_requete(__FILE__,__LINE__,$recherche,$prepare)===false)) return false;
$flux=$prepare->fetchAll(PDO::FETCH_ASSOC);
$prepare=null;
$nb_import=0;
if(!empty($flux))
{
$date_actuelle=time();
foreach ($flux as $flux_infos)
{
$flux_infos["limites"]["url_long_max"]=FLUX_MAX_URL;
$flux_import=new FclFlux_flux($flux_infos);
if(empty($flux_import->erreurs))
{
$retour=$flux_import->import_liens();
if($retour!==false)
$nb_import++;
}
unset($flux_import);
}
}
return $nb_import;
}
}//fin de la classe
Reference in New Issue View Git Blame Copy Permalink