SpipLab:NotificationDesPenseBete

<h1>Notifications : les pense-bêtes (comme le reste)</h1>

{{les fichiers indispensables :}} [->http://lab.spip.net/cvs/spip_notifs/]
_ {{la doc technique :}} [->http://lab.spip.net/spikini/FonctionnementTechniqueDesNotifications]
_ {{l'exemple de mise en place pour les brèves :}} [->http://lab.spip.net/spikini/NotificationDesBreves]

<h2>1. Déclarer la class Evt_Pense_bete</h2>
_ Le premier fichier rajouté, "pense_bete.php", n’est qu’une déclinaison des fichiers fournis dans le dossier evenement . Il est fortement conseillé de commencer par "éplucher" ces derniers pour mieux comprendre comment l’ensemble fonctionne. Vous devrez placer ce fichier dans le dossier "ecrire/evenements". Une fois placé au bon endroit, les auteurs peuvent s’abonner au service de notification par email des pense-bête

<cadre>
<?php

// Classe utilisee en cas de pense-bête

// Penser a respecter la nomenclature (correspondance fichier <-> classe <-> notif) :
// - nom du fichier : "ma_notification.php"
// - nom de la classe : "Evt_Ma_Notification"
// - code interne : "ma_notification"

class Evt_Pense_Bete {
	// Version de l'API (pour gerer d'eventuelles evolutions)
	function api() {
		return 1.0;
	}
	function actif() {
		return true;
	}

// Classes d'abonnements acceptees
	function types_abos() {
		return array(
			'global' => false,
			'admins' => false,
			'auteurs' => _L("avertir de vos pense-b&ecirc;tes"),
			'redacs' => false,
			'public' => false
		);
	}

// Types de contextes geres
	function types_contextes() {
		return array(
			'article' => false,
			'rubrique' => false
		);
	}

// Proprietes pour l'interface de config
	function label_court() {
		return _L("email de vos pense-b&ecirc;tes");
	}
	function label_long() {
		return _L("Rappeler par email vos pense-b&ecirc;tes");
	}
	function icone($taille = 24) {
		return "forum-interne-24.gif";
	}
	function labels_config_auteur() {
		return array(
			'auteur' => _L("vos propres pense-b&ecirc;tes")
		);
	}

/*
	 * Ici les fonctions utilisees lors du declenchement de l'evenement proprement dit
	 */

var $id_message;
	var $row;

// Initialisation a partir d'un contexte
	function init($contexte) {
		$this->id_message = $contexte['id_message'];
		$query = "SELECT * FROM spip_messages WHERE id_message=".$this->id_message;
		$this->row = spip_fetch_array(spip_query($query));
	}
	// Fonction a fournir si abonnement "auteurs" autorise
	function auteurs() {
		$query = "SELECT * FROM spip_messages WHERE id_message=".$this->id_message;
			list($id_auteur) = spip_fetch_array(spip_query($query));
			if ($id_auteur) {
				return array($id_auteur);
				}else{
				return array();
				}
	}
	// Fonction a fournir pour gerer l'acces dynamique a la ressource selon le contexte :
	// ne rien renvoyer (acces par defaut) ou renvoyer un tableau contenant
	// les classes autorisees (par ex. array('admin' => true))
	function acces_dynamique() {
	}

//
	// Fonctions retournant le contenu formate
	//
	function decompte($n) {
		if ($n == 1)
			return _L("1 pense-b&ecirc;te &agrave l'ordre du jour");
		return _L($n." pense-b&ecirc;tes dans votre agenda");
	}
	function sujet() {
		$titre = $this->row['titre'];
		$sujet = _L("PENSE-BÊTE :")." ".textebrut(typo($titre));
		return $sujet;
	}
	function resume() {
		$titre = $this->row['titre'];
		$nom_auteur = typo($this->row['auteur']);
		$resume = _L("Le pense-b&ecirc;te \"".$titre."\" arrive &agrave &eacute;ch&eacute;ance.");
		$resume = textebrut($resume);
		return $resume;
	}
	function detail() {
		$titre = $this->row['titre'];
		$texte = $this->row['texte'];
		$nom_auteur = typo($this->row['auteur']);
		$date = $this->row['date_heure'];
		$extrait = "** $titre **\n";
		return $extrait;
	}
	function url() {
		$url = "";
		return $url;
	}

} // fin class
?>
</cadre>

<h2>2. Rassembler les éléments pour l'envoi des pense bête</h2>
{{Le second fichier rajouté, "envoi_pense_bete.php3", construit peu à peu la situation}} qui nous permettra de savoir si, oui ou non, on doit envoyer une notification pour un pense-bête ; il rassemble les éléments nécessaires à cet envoi (email, id du pense-bête etc...). Son installation consiste simplement à le copier dans le répertoire /ecrire. C'est tout.

{{- le fichier envoi_pense_bete.php3 est paramétrable :}}
-* $verbose permet l'affichage  à l'écran des informations recueillies et traitées ; "true" ça s'affiche, "false" -le mode de fonctionnement normal-, ça ne s'affiche pas.
-* $prenotif = 3; permet de mettre en place une pré-notification ; les abonnés seront prévenus 3 jours avant la date du pense-bête ; ils recevront une seconde notification le jour même du début du pense-bête.
-* la pré-notification (ainsi que le reste du fichier d'ailleurs), est encore en travaux. Elle est opérationnelle 'en l'état', mais n'enverra pas d'email les 3 premiers jours du mois. Elle sera maéliorée dès que possible, avec votre concours je l'espère.

{{- le point névralgique, à commenter pour suspendre tout envoi, est consitué par deux lignes :}}

<cadre>
declencher_evenement('pense_bete', array('id_message' => $id_message));
$var = envoyer_mail($email, $titre, $texte, $from, $headers = "");
</cadre>

<cadre>
<?php
$verbose = false;
$prenotif = 3;

include_ecrire ("inc_filtres.php3");
include_ecrire ("inc_mail.php3");
include_ecrire ("inc_notifs.php3");

// récupération de la date du jour et découpage en unités simples
// on s'en servira pour savoir si aujourd'hui est la date d'un pense bête
$today=getdate(time());
	$jour = $today["mday"];
	$mois=$today["mon"];
	$annee=$today["year"];
	$now = date("w",mktime(1,1,1,$mois,$jour,$annee));

if ($verbose) {
		echo "Nous sommes aujourd'hui le : ";
		echo $jour;
		echo " - ";
		echo $mois;
		echo " - ";
		echo $annee;
		echo " ";
	}

// dans spip_evenement on récupère le numéro de l'id_evenement de type pense-bête
$requeteA = "SELECT * FROM `spip_evenements` WHERE type = 'pense_bete' ";
$resultA = spip_query($requeteA);
	if ($colonne = spip_fetch_array($resultA)) {
		$id_evenement = $colonne['id_evenement'];
		$type = $colonne['type'];
		$classe = $colonne['classe'];
		$maj = $colonne['maj'];

if ($verbose) {
			echo " ";
			echo "Dans la table spip_evenement, ";
			echo "notre pense-bête porte le numéro id :";
			echo $id_evenement;
			echo " ";
		}
	}

// dans spip abos on récupère les flux qui correspondent à l'événement pense_bête
$requeteB = "SELECT * FROM `spip_abos` WHERE id_evenement = $id_evenement ";
$resultB = spip_query($requeteB);
while ($colonne = spip_fetch_array($resultB)) {
		$id_abo = $colonne['id_abo'];
		$id_flux = $colonne['id_flux'];
		$id_evenement = $colonne['id_evenement'];
		$classe = $colonne['classe'];
		$abonne = $colonne['abonne'];
		$id_rubrique = $colonne['id_rubrique'];
		$maj = $colonne['maj'];

if ($verbose) {
			echo " ";
			echo "le Flux a pour id : ";
			echo "";
			echo $id_flux;
			echo "";
		}
		
		// dans les flux sélectionnés ont récupère l'id de l'auteur		
		$requeteC = "SELECT * FROM `spip_flux` WHERE id_flux = $id_flux ";
		$resultC = spip_query($requeteC);
		if ($colonne = spip_fetch_array($resultC)) {
			$id_flux = $colonne['id_flux'];
			$id_auteur = $colonne['id_auteur'];
			$action = $colonne['action'];
			$params_action  = $colonne['params_action'];
			$actif = $colonne['actif'];
			$maj  = $colonne['maj'];
			if ($verbose) {
				echo " et notre id auteur est : ";
				echo "";
				echo $id_auteur;
				echo "";
			}
		}
		// maintenant que nous avons l'id de l'auteur on peut piocher son nom et son email
		$requeteD = "SELECT * FROM `spip_auteurs` WHERE id_auteur = $id_auteur ";
		$resultD = spip_query($requeteD);
			if ($colonne = spip_fetch_array($resultD)) {
				$nom = $colonne['nom'];
				$email = $colonne['email'];
				$from = $colonne['email'];
			if ($verbose) {
					echo " c'est donc le fameux : ";
					echo "";
					echo $nom;
					echo "";
					echo " ";
			}
		}
		
		// on va donc piocher tous les messages de type 'pb' (pense-bête)
		// dont l'auteur est abonné à cet événement particulier défini dans 'pense_bete.php'
		$requeteE = "SELECT * FROM `spip_messages` WHERE type = 'pb' AND id_auteur = $id_auteur ";
		$resultE = spip_query($requeteE);
		while ($colonne = spip_fetch_array($resultE)) {
			$id_message = $colonne['id_message'];
			$titre = $colonne['titre'];
			$texte = $colonne['texte'];
			$type = $colonne['type'];
			$date_heure = $colonne['date_heure'];
			$date_fin = $colonne['date_fin'];
			$rv = $colonne['rv'];
			$statut = $colonne['statut'];
			$id_auteur = $colonne['id_auteur'];
			$maj = $colonne['maj'];

if (ereg("([0-9]{4})-([0-9]{2})-([0-9]{2})",$date_heure,$regs)){
		        $mois_echeance = $regs[2];
		        $jour_echeance = $regs[3];
		        $jour_pre_notification = $jour_echeance - $prenotif;
		        $annee_echeance = $regs[1];
			}			
			
	    	if (ereg("([0-9]{4})([0-9]{2})([0-9]{2})",$maj,$regs)){
		        $mois_maj = $regs[2];
		        $jour_maj = $regs[3];
		        $annee_maj = $regs[1];
			}

if ($verbose) {
				echo " son pense-bête numéro : ";
				echo "";
				echo $id_message;
				echo "";
				echo " qui arrive à échéance le ";
				echo "";
				echo $jour_echeance;
				echo " - ";
				echo $mois_echeance;
				echo " - ";
				echo $annee_echeance;			
				echo "";
				echo " et qui sera pré-notifié le : ";
				echo $jour_pre_notification;
				echo " qui a pour titre ' ";
				echo $titre;
				echo " ' et qui a été mis à jour le ";
				echo $jour_maj;
				echo " - ";
				echo $mois_maj;
				echo " - ";
				echo $annee_maj;			
				echo " ";
				}

// si on est le même jour, le même mois, la même année que le pense-bête on notifie
				if ($annee == $annee_echeance) {
					if ($mois == $mois_echeance) {
						if ($jour == $jour_echeance) {
							// si la date de maj est à 0000-00-00, ce qui signifie que ça a déjà été fait
							if ($annee_maj == '0000') {
								if ($mois_maj == '00') {
									if ($jour_maj == '00') {
										if ($verbose) echo " a déjà été notifié par email aujourd'hui ";
									}
								}
							} 
							else	{
								$oldTitre =$titre;
								$titre = "Pense-bête aujourd'hui : ".$oldTitre;
							
								// si la date de maj n'est pas à 0000-00-00, on ré-expédie une notification
								// en effet, c'est soit la bonne date, soit que le pense-bête a été modifié ou bien encore qu'il n'a jamais été notifié
								declencher_evenement('pense_bete', array('id_message' => $id_message));
								$var = envoyer_mail($email, $titre, $texte, $from, $headers = "");
								// log très indiscret à virer quand ça tourne
								spip_log("notification de pense-bete du jour a $email");

// et on met la date de maj à zéro pour indiquer que la notification a été faite
								spip_query("UPDATE spip_messages SET maj='00000000000000' WHERE id_message=$id_message");

if ($verbose) echo " sera notifié par email aujourd'hui ";
								if ($verbose) echo "sous le titre :";
								if ($verbose) echo $titre;
								if ($verbose) echo " ";
							}
						}
						else {
								// dans tous les autres cas, ce est pas le même jour, ni le même mois, ni la même année 
								// donc on ne notifie pas
								if ($verbose) echo " ne sera pas notifié par email ";
	
								// à moins que l'on ne soit pile-poil à x jours de l'échéance du pense-bête
								// dans ce cas, on fait une pré-notification
								if ($jour == $jour_pre_notification) {
									if ($jour_maj == '00') {
										// là encore, si la date de maj est à 0000-00-00, ce qui signifie que ça a déjà été fait
										if ($verbose) echo "mais a déjà été pré-notifié par email aujourd'hui ";
									}
									else {
										$oldTitre =$titre;
										$titre = "Pense-bête Carep dans ";
										$titre .= $prenotif;
										$titre .= " jours : ".$oldTitre;
										declencher_evenement('pense_bete', array('id_message' => $id_message));
										$var = envoyer_mail($email, $titre, $texte, $from, $headers = "");
										// log très indiscret à virer quand ça tourne
										spip_log("pre - notification de pense-bete du jour a $email");
										spip_query("UPDATE spip_messages SET maj='00000000000000' WHERE id_message=$id_message");
										if ($verbose) echo "mais sera pré-notifié aujourd'hui par email ";
										if ($verbose) echo "sous le titre :";
										if ($verbose) echo $titre;
										if ($verbose) echo " ";
									}
								}
						}
					}
					if ($verbose) echo " ";
				} 
			}
		}
?>
</cadre>

<hr>

<h2>3. Automatiser l'appel aux notifications : le CRON</h2>

{{Le fichier ecrire/inc_cron.php3}}
<cadre>
	// indexation
	if (lire_meta("activer_moteur") == "oui") 
		$taches_generales[]= 'index';

// notif des pense bête
	$taches_generales[]= 'envoi_pense_bete';

return $taches_generales;
}

// Definit le temps minimal, en secondes, entre deux memes taches 
// NE PAS METTRE UNE VALEUR INFERIEURE A 30 (cf ci-dessus)
// ca entrainerait plusieurs execution en parallele de la meme tache
// Ces valeurs sont destinees a devenir des "metas" accessibles dans
// le panneau de configuration, comme l'est deja la premiere

global $frequence_taches;
$frequence_taches = array(
			  'mail' => 3600 * 24 * lire_meta('jours_neuf'),
			  'visites' => 3600 * 24,
			  'statistiques' => 3600,
			  'invalideur' => 3600,
			  'rubriques' => 3600,
			  'popularites' => 1800,
			  'sites' => 90,
			  'index' => 60,
			  'optimiser' => 3600 * 7,
			  'envoi_pense_bete' =>3600 // une fois par heure, cron déclanchera un appel pour vérifier s'il ne doit pas notifier un pense-bête
);

// Fonctions effectivement appelees.
// Elles sont destinees a migrer dans leur fichier homonyme.
function cron_envoi_pense_bete($t) {
	include_ecrire("envoi_pense_bete.php3");
	return 1;
}
</cadre>

<hr>
{{- le fichier spip_background.php3 :}}
_ en modifiant un chouillat spip_background.php3 on évite au moins une floppée de warmind php "can't modify headers"... already sent...
<cadre>
<?php
// Du cote de la page HTML, utiliser un background-image en feuille de style
// plutot qu'un <img>, c'est plus discret notamment sous navigateur texte
$image = pack("H*", "47494638396118001800800000ffffff00000021f90401000000002c0000000018001800000216848fa9cbed0fa39cb4da8bb3debcfb0f86e248965301003b");
$size = strlen($image);
echo $image;
flush();
include('ecrire/inc_version.php3');
cron(1); // acces gourmand (on veut bosser, nous, pas comme inc-public.php3 !)
?></cadre>