Context Navigation

source: spip-zone/_plugins_/spip-listes/spip-listes_1_9_3/inc/spiplistes_api.php @ 48255

Visit:

Last change on this file since 48255 was 48255, checked in by paladin@…, 10 years ago
documentaiton code + optimisation + ajout textes manquant dans lang
Property svn:keywords set to `LastChangedBy LastChangedDate LastChangedRevision`
File size: 47.3 KB

Line
1	<?php
2	/**
3	* @package spiplistes
4	*/
5	// $LastChangedRevision: 48255 $
6	// $LastChangedBy: paladin@quesaco.org $
7	// $LastChangedDate: 2011-05-29 08:34:27 +0000 (Sun, 29 May 2011) $
8
9	/******************************************************************************************/
10	/* SPIP-Listes est un systeme de gestion de listes d'abonnes et d'envoi d'information */
11	/* par email pour SPIP. http://bloog.net/spip-listes */
12	/* Copyright (C) 2004 Vincent CARON v.caron<at>laposte.net */
13	/* */
14	/* Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes */
15	/* de la Licence Publique Generale GNU publiee par la Free Software Foundation */
16	/* (version 2). */
17	/* */
18	/* Ce programme est distribue car potentiellement utile, mais SANS AUCUNE GARANTIE, */
19	/* ni explicite ni implicite, y compris les garanties de commercialisation ou */
20	/* d'adaptation dans un but specifique. Reportez-vous a la Licence Publique Generale GNU */
21	/* pour plus de details. */
22	/* */
23	/* Vous devez avoir recu une copie de la Licence Publique Generale GNU */
24	/* en meme temps que ce programme ; si ce n'est pas le cas, ecrivez a la */
25	/* Free Software Foundation, */
26	/* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, Etats-Unis. */
27	/******************************************************************************************/
28
29	if(!defined('_ECRIRE_INC_VERSION')) return;
30
31	include_spip ("inc/utils");
32	include_spip ("inc/filtres"); /* email_valide() */
33	include_spip ("inc/acces"); /* creer_uniqid() */
34	include_spip('inc/charsets');
35
36	include_spip('base/abstract_sql');
37
38	include_spip('inc/spiplistes_api_abstract_sql');
39	include_spip('inc/spiplistes_api_globales');
40
41	/**
42	* Fonction de compatibilite de php4 / php5 pour http_build_query
43	*
44	* @return un query string a passer a une url
45	* @param object $data un array de contexte
46	* @param object $prefix[optional]
47	* @param object $sep[optional]
48	* @param object $key[optional]
49	*/
50	function spiplistes_http_build_query($data,$prefix=null,$sep='',$key='')
51	{
52	if(!function_exists('http_build_query')) {
53	function http_build_query($data,$prefix=null,$sep='',$key='') {
54	$ret = array();
55	foreach((array)$data as $k => $v) {
56	$k = urlencode($k);
57	if(is_int($k) && $prefix != null) {
58	$k = $prefix.$k;
59	};
60	if(!empty($key)) {
61	$k = $key."[".$k."]";
62	};
63
64	if(is_array($v) \|\| is_object($v)) {
65	array_push($ret,http_build_query($v,"",$sep,$k));
66	}
67	else {
68	array_push($ret,$k."=".urlencode($v));
69	};
70	};
71
72	if(empty($sep)) {
73	$sep = ini_get("arg_separator.output");
74	};
75	return implode($sep, $ret);
76	};
77	};
78	return http_build_query($data);
79	}
80
81	/**
82	* function privee
83	* multi_queries mysql n'est pas en mesure de le faire en natif :-(
84	* A tranformer le jour ou mysql gerera correctement le multi_query
85	* Et a transformer en transanction quand spip utilisera innodb ou autre table transactionnelle
86	* @param $queries : requetes separees par des ';'
87	*/
88	function __exec_multi_queries($queries) {
89	$queries = trim($queries);
90	if (substr($queries, -1, 1) == ';') {
91	$queries = substr($queries, 0, strlen($queries)-1);
92	}
93	$_queries = explode(';', $queries);
94	while( list(,$val) = each($_queries)) {
95	$res = spip_query($val);
96	}
97	return $res;
98	}
99
100	/**
101	* @version CP-20080508
102	* renvoie OK ou ERR entre crochet
103	* sert principalement pour les log
104	* @return string
105	*/
106	function spiplistes_str_ok_error ($statut) {
107	return("[".(($statut != false) ? "OK" : "ERR")."]");
108	}
109
110	//
111	function spiplistes_singulier_pluriel_str_get ($var, $str_sing, $str_plur, $returnvar = true) {
112	$result = "";
113	if($var) {
114	$result = (($returnvar) ? $var : "") . " " . (($var > 1) ? $str_plur : $str_sing);
115	}
116	return($result);
117	}
118
119	/**
120	* @version CP-20080508
121	* @return int
122	*/
123	function spiplistes_sql_compter ($table, $sql_whereq) {
124	$sql_result = intval(sql_countsel($table, $sql_whereq));
125	return($sql_result);
126	}
127
128	/**
129	* @version CP-20080511
130	*/
131	function spiplistes_courriers_statut_compter ($statut='tous') {
132	$sql_where = spiplistes_listes_sql_where_or(
133	($statut == 'tous')
134	? _SPIPLISTES_COURRIERS_STATUTS
135	: $statut
136	);
137	return(spiplistes_sql_compter('spip_courriers', $sql_where));
138	}
139
140
141	/**
142	* Date/time du serveur SQL
143	* CP-20091207
144	* @return string\|bool
145	*/
146	function spiplistes_sql_now ()
147	{
148	if($result = sql_fetsel('NOW() as maintenant'))
149	{
150	$result = $result['maintenant'];
151	}
152	return($result);
153	}
154
155	/**
156	* @version CP-20080510
157	*/
158	function spiplistes_courriers_casier_premier ($sql_select, $sql_whereq) {
159	return(sql_select(
160	$sql_select, "spip_courriers", $sql_whereq." LIMIT 1"
161	)
162	);
163	}
164
165	/**
166	******************************************************************************
167	Les fonctions spiplistes_abonnements_*() concernent les abonnements
168
169	Table cible : spip_auteurs_listes
170
171	******************************************************************************
172	*/
173
174
175	/**
176	* Abonner un id_auteur a une id_liste
177	* ou une liste de listes ($id_liste est un tableau de (id)listes)
178	* avec la date d'inscription
179	* @version CP-20110505
180	* @param int $id_auteur
181	* @param int\|array $id_liste
182	* @return array id_listes ajoutees
183	*/
184	function spiplistes_abonnements_ajouter ($id_auteur, $id_liste) {
185
186	spiplistes_debug_log('SUBSCRIBE auteur #'.$id_auteur.' TO liste #'.$id_liste);
187
188	$r_id_listes = false;
189
190	if(($id_auteur = intval($id_auteur)) > 0) {
191	$sql_table = 'spip_auteurs_listes';
192	$sql_noms = '(id_auteur,id_liste,date_inscription)';
193
194	$curr_abos_auteur = spiplistes_abonnements_listes_auteur($id_auteur);
195	$r_id_listes = array();
196
197	if(is_array($id_liste)) {
198	// si une seule liste demandee
199	$sql_valeurs = array();
200	$msg = array();
201	foreach($id_liste as $id) {
202	if(
203	(($id = intval($id)) > 0)
204	// si pas encore abonne'
205	&& !in_array($id, $curr_abos_auteur)
206	)
207	{
208	$sql_valeurs[] = "($id_auteur,$id,NOW())";
209	$msg[] = $id;
210	}
211	}
212	if(count($sql_valeurs)) {
213	$sql_valeurs = implode(",", $sql_valeurs);
214	}
215	}
216	else if(
217	// si une seule liste demandee, et si pas encore abonne'
218	(($id_liste = intval($id_liste)) > 0)
219	&& (!$curr_abos \|\| !in_array($id_liste, $curr_abos))
220	)
221	{
222	$sql_valeurs = " ($id_auteur,$id_liste,NOW())";
223	$msg = array($id_liste);
224	$r_id_listes[] = $id_liste;
225	}
226	if($sql_valeurs) {
227	$msg = "#" . implode(",#", $msg);
228	if(sql_insert($sql_table, $sql_noms, $sql_valeurs) === false) {
229	spiplistes_sqlerror_log ("spiplistes_abonnements_ajouter()");
230	}
231	else {
232	spiplistes_log_api("subscribe id_auteur #$id_auteur to id_liste $msg");
233	}
234	}
235	}
236	return($r_id_listes);
237	} // spiplistes_abonnements_ajouter()
238
239	/**
240	* desabonner des listes
241	* @version CP-20071016
242	*/
243	function spiplistes_abonnements_desabonner_statut ($id_auteur, $listes_statuts) {
244	if(($id_auteur = intval($id_auteur)) && count($listes_statuts)) {
245	$sql_where = "statut=".implode(" OR statut=", array_map("sql_quote", $listes_statuts));
246	$sql_result = sql_select("id_liste", "spip_listes", $sql_where);
247	$listes = array();
248	while($row = sql_fetch($sql_result)) {
249	$listes[] = intval($row['id_liste']);
250	}
251	if(count($listes)) {
252	$sql_where = " id_auteur=".sql_quote($id_auteur)." AND id_liste IN (" . implode(",", $listes) . ")";
253	sql_delete("spip_auteurs_listes", $sql_where);
254	}
255	return(spiplistes_format_abo_modifier($id_auteur));
256	}
257	return(false);
258	}
259
260
261	/**
262	* supprimer des abonnes de la table des abonnements
263	* @version CP-20080512
264	*/
265	function spiplistes_abonnements_auteurs_supprimer ($auteur_statut) {
266	$auteur_statut = "statut=".sql_quote($auteur_statut);
267	if(spiplistes_spip_est_inferieur_193()) {
268	$result = sql_delete("spip_auteurs_listes",
269	"id_auteur IN (SELECT id_auteur FROM spip_auteurs WHERE $auteur_statut)");
270	} else {
271	// Sur les precieux conseils de MM :
272	// passer la requete en 2 etapes pour assurer portabilite sql
273	$selection =
274	sql_select("id_auteur", "spip_auteurs", $auteur_statut,'','','','','',false);
275	$sql_result = sql_delete("spip_auteurs_listes", "id_auteur IN ($selection)");
276	if ($sql_result === false) {
277	spiplistes_sqlerror_log("abonnements_auteurs_supprimer");
278	}
279	}
280	return($result);
281	}
282
283	/**
284	* renvoie la liste des abonnements pour id_auteur
285	* @version CP-20080330
286	* @param int $id_auteur
287	* @param bool $avec_titre
288	* @return tableau d'id_listes. La valeur est titre si $avec_titre true, sinon id_liste
289	*/
290	function spiplistes_abonnements_listes_auteur ($id_auteur, $avec_titre = false) {
291	$result = array();
292	$sql_select = array("abo.id_liste");
293	$sql_from = array("spip_auteurs_listes AS abo");
294	$sql_where = array();
295	if($avec_titre) {
296	$sql_select[] = "list.titre";
297	$sql_from[] = "spip_listes AS list";
298	$sql_where[] = "abo.id_liste=list.id_liste";
299	}
300	$sql_where[] = "abo.id_auteur=".sql_quote($id_auteur);
301	$sql_result = sql_select (
302	$sql_select
303	, $sql_from
304	, $sql_where
305	);
306	if ($sql_result === false) {
307	spiplistes_sqlerror_log("spiplistes_abonnements_listes_auteur");
308	}
309	else {
310	while ($row = sql_fetch($sql_result)) {
311	$result[$row['id_liste']] = ($avec_titre ? $row['titre'] : $row['id_liste']);
312	}
313	}
314	return($result);
315	}
316
317	/**
318	* desabonner un id_auteur d'une id_liste
319	* ou de toutes les listes si $id_liste = 'toutes'
320	* ou tous les abonnes si id_auteur == 'tous'
321	* ou une serie si array
322	* @version CP-20090410
323	*/
324	function spiplistes_abonnements_auteur_desabonner ($id_auteur, $id_liste = false)
325	{
326	//spiplistes_debug_log("spiplistes_abonnements_auteur_desabonner ($id_auteur, $id_liste)");
327
328	$result = false;
329	$msg1 = $msg2 = '';
330	$sql_where = array();
331	if($id_auteur == 'tous') {
332	$sql_where[] = 'id_auteur>0';
333	$msg1 = $id_auteur;
334	}
335	else if(is_array($id_auteur)) {
336	$ii = implode(',', $id_auteur);
337	$sql_where[] = 'id_auteur IN ('.$ii.')';
338	$msg1 = 'id_auteur #'.$ii;
339	}
340	else if(($id_auteur = intval($id_auteur)) > 0) {
341	$sql_where[] = 'id_auteur='.sql_quote($id_auteur);
342	$msg1 = 'id_auteur #'.$id_auteur;
343	}
344	if(count($sql_where) && $id_liste)
345	{
346	$sql_table = 'spip_auteurs_listes';
347
348	if($id_liste == 'toutes')
349	{
350	$msg2 = ' des listes';
351	}
352	else if(($id_liste = intval($id_liste)) > 0)
353	{
354	$sql_where[] = 'id_liste='.$id_liste;
355	$msg2 = ' de la liste #'.$id_liste;
356	}
357	if(($result = sql_delete($sql_table, $sql_where)) === false)
358	{
359	spiplistes_debug_log ('ERR sql_delete: abonnements_auteur_desabonner()');
360	}
361	else {
362	spiplistes_log_api('desabonne '.$msg1.' '.$msg2);
363	}
364	}
365	return ($result);
366	}
367
368	/**
369	* supprimer des abonnements
370	* @version CP-20080512
371	*/
372	function spiplistes_abonnements_supprimer ($sql_whereq) {
373	return(sql_delete('spip_auteurs_listes', $sql_whereq));
374	}
375
376	/**
377	* dans la table des abonnements
378	* @version CP-20080508
379	* @return int
380	*/
381	function spiplistes_abonnements_compter ($sql_whereq = "") {
382	return(spiplistes_sql_compter("spip_auteurs_listes", $sql_whereq));
383	}
384
385	/**
386	* Compter les abonnements qui n'ont plus d'abonnes
387	* @return array id_auteur
388	*/
389	function spiplistes_abonnements_zombies () {
390	// SELECT id_auteur FROM spip_auteurs_listes WHERE id_auteur
391	// IN (SELECT id_auteur FROM spip_auteurs WHERE statut='5poubelle')
392	$sql_select = "id_auteur";
393	$sql_from = "spip_auteurs";
394	$sql_where = "statut=".sql_quote('5poubelle');
395	$selection =
396	(spiplistes_spip_est_inferieur_193())
397	? "SELECT $sql_select FROM $sql_from WHERE $sql_where"
398	: sql_select($sql_select, $sql_from, $sql_where,'','','','','',false)
399	;
400	$sql_from = "spip_auteurs_listes";
401	$sql_result = sql_select(
402	$sql_select
403	, $sql_from
404	, "$sql_select IN (".$selection.")"
405	);
406	if($sql_result === false) {
407	spiplistes_sqlerror_log("spiplistes_abonnements_zombies");
408	}
409	$result = array();
410	while($row = sql_fetch($sql_result)) {
411	$result[] = $row[$sql_select];
412	}
413	return($result);
414
415	}
416
417	/**
418	* Donne le nombre d'abonnés (pour une liste)
419	* qui ont un vrai format de réception (html ou texte)
420	* et une adresse mail valide
421	* @version CP-20081228
422	* @return int
423	*/
424	function spiplistes_abonnements_vrais_compter ($id_liste) {
425	if($id_liste = intval($id_liste)) {
426	// SELECT COUNT(l.id_auteur) AS nb
427	// FROM spip_auteurs_listes AS l, spip_auteurs_elargis AS f, spip_auteurs AS a
428	// WHERE l.id_liste=$id_liste
429	// AND l.id_auteur=f.id_auteur
430	// AND (l.id_auteur=a.id_auteur AND LENGTH(a.email) > 3)
431	// AND (f.`spip_listes_format`='html' OR f.`spip_listes_format`='texte')
432	$sql_select = array('COUNT(l.id_auteur) AS nb');
433	$sql_from = array('spip_auteurs_listes AS l', 'spip_auteurs_elargis AS f', 'spip_auteurs AS a');
434	$sql_where = array(
435	"l.id_liste=$id_liste"
436	, "l.id_auteur=f.id_auteur"
437	, "(l.id_auteur=a.id_auteur AND LENGTH(a.email) > 3)"
438	, "(f.`spip_listes_format`='html' OR f.`spip_listes_format`='texte')"
439	);
440	$sql_result = sql_select($sql_select, $sql_from, $sql_where);
441	if($sql_result === false) {
442	spiplistes_sqlerror_log("spiplistes_abonnements_vrais_compter()");
443	}
444	if($row = sql_fetch($sql_result)) {
445	$result = $row['nb'];
446	}
447	}
448	return($result);
449	}
450
451	/**
452	* Inventaire des abonnements.
453	* Tableau dont l'index est l'ID de la liste
454	* et la valeur un tableau des ID abonnés
455	* @param string\|array $sql_where
456	* @version CP-20110510
457	* @return array\|bool
458	*/
459	function spiplistes_abonnements_lister ($sql_where = '') {
460
461	if(($sql_result = sql_select('id_auteur,id_liste'
462	, 'spip_auteurs_listes'
463	, $sql_where
464	)
465	) !== FALSE)
466	{
467	$listes = array();
468
469	while($row = sql_fetch($sql_result))
470	{
471	$ii = $row['id_liste'];
472
473	if(!isset($listes[$ii]))
474	{
475	$listes[$ii] = array();
476	}
477	$listes[$ii][] = $row['id_auteur'];
478	}
479	return ($listes);
480	}
481	else {
482	spiplistes_sqlerror_log('spiplistes_abonnements_lister ()');
483	}
484	return (FALSE);
485	}
486
487	/**
488	******************************************************************************
489	Les fonctions spiplistes_listes_*() concernent les listes
490
491	Table cible : spip_listes
492
493	******************************************************************************
494	*/
495
496	/**
497	* dans la table des listes
498	* @version CP-20080508
499	*/
500	function spiplistes_listes_compter ($sql_whereq = "") {
501	return(spiplistes_sql_compter("spip_listes", $sql_whereq));
502	}
503
504	/**
505	* @version CP-20080501
506	*/
507	function spiplistes_listes_liste_modifier ($id_liste, $array_set) {
508	return(
509	sql_update(
510	'spip_listes'
511	, $array_set
512	, "id_liste=".sql_quote($id_liste)." LIMIT 1"
513	)
514	);
515	}
516
517	/**
518	* @version CP-20080501
519	*/
520	function spiplistes_listes_liste_supprimer ($id_liste) {
521	$sql_where = "id_liste=".sql_quote(intval($id_liste));
522	return(
523	sql_delete('spip_listes', $sql_where." LIMIT 1")
524	&& spiplistes_mod_listes_supprimer("tous", $id_liste)
525	&& sql_delete('spip_auteurs_listes', $sql_where)
526	);
527	}
528
529	/**
530	* @version CP-20080512
531	*/
532	function spiplistes_listes_liste_creer ($statut, $lang, $titre, $texte, $pied_page) {
533	global $connect_id_auteur;
534
535	if($id_liste = sql_insertq('spip_listes', array(
536	'statut' => $statut
537	, 'lang' => $lang
538	, 'titre' => $titre
539	, 'texte' => $texte
540	, 'pied_page' => $pied_page
541	)
542	)
543	) {
544	$id_liste = intval($id_liste);
545	$id_auteur = intval($connect_id_auteur);
546	spiplistes_mod_listes_supprimer("tous", $id_liste);
547	spiplistes_mod_listes_ajouter($id_auteur, $id_liste);
548	spiplistes_abonnements_auteur_desabonner("tous", $id_liste);
549	spiplistes_abonnements_ajouter($id_auteur, $id_liste);
550	return($id_liste);
551	}
552	return(false);
553	}
554
555	/**
556	* renvoie tableau de id_auteurs abonnes a une liste
557	* @version CP-20080602
558	*/
559	function spiplistes_listes_liste_abo_ids ($id_liste) {
560	$sql_result = sql_select('id_auteur', 'spip_auteurs_listes', "id_liste=".sql_quote($id_liste), '', array('id_auteur'));
561	$ids_abos = array();
562	while($row = sql_fetch($sql_result)) {
563	$ids_abos[] = intval($row['id_auteur']);
564	}
565	return($ids_abos);
566	}
567
568	/**
569	* Compter les abonnes.
570	* @param $id_liste int. Si > 0, abonnes a cette liste,
571	* sinon, nombre total d'abonnements (nb lignes dans la table)
572	* @param $preciser. Si true, renvoie tableau total et formats
573	* @return int\|array
574	*/
575	function spiplistes_listes_nb_abonnes_compter ($id_liste = 0, $preciser = false)
576	{
577	$id_liste = intval($id_liste);
578	$sql_whereq = (
579	($id_liste > 0)
580	? 'id_liste='.sql_quote($id_liste)
581	: ''
582	);
583	$total = spiplistes_sql_compter('spip_auteurs_listes', $sql_whereq);
584
585	if($preciser)
586	{
587	$selection =
588	(spiplistes_spip_est_inferieur_193())
589	? 'SELECT id_auteur FROM spip_auteurs_listes '
590	. (!empty($sql_whereq) ? 'WHERE '.$sql_whereq : '')
591	: sql_select('id_auteur', 'spip_auteurs_listes', $sql_whereq,'','','','','',false)
592	;
593	$sql_result = sql_select(
594	"`spip_listes_format` AS f, COUNT(*) AS n"
595	, 'spip_auteurs_elargis'
596	, 'id_auteur IN ('.$selection.')'
597	, "`spip_listes_format`"
598	);
599	if($sql_result === false)
600	{
601	spiplistes_sqlerror_log('listes_nb_abonnes_compter');
602	}
603	$formats = array('html' => 0, 'texte' => 0);
604	$keys = array_keys($formats);
605	while($row = sql_fetch($sql_result))
606	{
607	if(in_array($row['f'], $keys)) {
608	$formats[$row['f']] += $row['n'];
609	}
610	}
611	return(array($total, $formats['html'], $formats['texte']));
612	}
613	return($total);
614	}
615
616	/**
617	* renvoie email emetteur d'une liste
618	* @version CP-20080509
619	*/
620	function spiplistes_listes_email_emetteur ($id_liste = 0) {
621	$id_liste = intval($id_liste);
622	if($id_liste > 0) {
623	$result =
624	sql_getfetsel(
625	"email_envoi"
626	, "spip_listes"
627	, "id_liste=".sql_quote($id_liste)." LIMIT 1"
628	);
629	if($result === false) {
630	spiplistes_sqlerror_log("listes_email_emetteur");
631	}
632	}
633	// si pas d'adresse moderateur, va chercher adresse par defaut
634	if(!$result \|\| empty($result)) {
635	$result = spiplistes_email_from_default();
636	}
637	return($result);
638	}
639
640	/**
641	* @version CP-20080511
642	*/
643	function spiplistes_listes_liste_fetsel ($id_liste, $keys = "*") {
644	$id_liste = intval($id_liste);
645	return(sql_fetsel($keys, "spip_listes", "id_liste=".sql_quote($id_liste)." LIMIT 1"));
646	}
647
648	/**
649	* @version CP-20081116
650	*/
651	function spiplistes_listes_liste_statut ($id_liste) {
652	return(spiplistes_listes_liste_fetsel($id_liste, 'statut'));
653	}
654
655	/**
656	* renvoie array sql_where des listes publiees
657	* @version CP-20080505
658	*/
659	function spiplistes_listes_sql_where_or ($listes) {
660	return("statut=".implode(" OR statut=", array_map("sql_quote", explode(";", $listes))));
661	}
662
663	/**
664	* taille d'une chaine sans saut de lignes ni espaces ni punct
665	*/
666	function spiplistes_strlen($out){
667	$out = preg_replace("/([[:space:]]\|[[:punct:]])+/", "", $out);
668	return (strlen($out));
669	}
670
671	/**
672	* dans la queue d'envoi des courriers
673	* @version CP-20080508
674	*/
675	function spiplistes_courriers_en_queue_compter ($sql_whereq = "") {
676	// demande le nombre de courriers dans la queue
677	// avec etat vide (si etat non vide,
678	// c'est que la meleuse est en train de l'envoyer)
679	return(spiplistes_sql_compter("spip_auteurs_courriers", $sql_whereq));
680	}
681
682	/**
683	* @version CP-20080510
684	*/
685	function spiplistes_courriers_en_queue_modifier ($array_set, $sql_whereq) {
686	return(
687	sql_update(
688	'spip_auteurs_courriers'
689	, $array_set
690	, $sql_whereq
691	)
692	);
693	}
694
695
696	/**
697	* @version CP-20080510
698	*/
699	function spiplistes_courriers_en_queue_supprimer ($sql_whereq) {
700	if(($result = sql_delete('spip_auteurs_courriers', $sql_whereq)) === false) {
701	spiplistes_sqlerror_log("courriers_en_queue_supprimer");
702	}
703	return($result);
704	}
705
706	/**
707	*l a premiere etiquette sur le tas
708	* @version CP-20080621
709	*/
710	function spiplistes_courriers_en_queue_premier ($select, $where) {
711	return(
712	sql_getfetsel(
713	$select
714	, 'spip_auteurs_courriers'
715	, $where
716	, '', '', 1
717	)
718	);
719	}
720
721
722	/**
723	******************************************************************************
724	Les fonctions spiplistes_format_abo_*() concernent les
725	formats de reception des abos
726
727	Table cible : spip_auteurs_elargis
728
729	Table historique utilisee par d'autres plugins.
730
731	Cette table contient le format par defaut de l'abonne'.
732	Le format final, reel, est dans le champ 'format' de
733	la table des abonnements (spip_auteurs_listes).
734
735	Ce format est attache' a l'abonnement. Ainsi, un abonne'
736	peut s'inscrire au format HTML a' la liste 1
737	et au format TEXTE a la liste 2.
738
739	******************************************************************************
740	*/
741
742
743	/**
744	* suspend les abonnements d'un compte
745	*/
746	function spiplistes_format_abo_suspendre ($id_auteur) {
747	return(spiplistes_format_abo_modifier($id_auteur));
748	}
749
750	/**
751	* compter les formats (les abonnes ayant de'fini un format)
752	* @version CP-20110529
753	* @return int
754	*/
755	function spiplistes_formats_compter ($sql_where) {
756
757	$result = sql_fetsel('COUNT(id_auteur) as n', 'spip_auteurs_elargis', $sql_where);
758	if ($result) {
759	$result = $result['n'];
760	}
761	return ($result);
762	}
763
764	/**
765	* supprimer le format d'un id_auteur
766	* si $id_auteur == 'tous', supprimer tous les formats
767	* @version CP-20090111
768	*/
769	function spiplistes_format_abo_supprimer ($id_auteur) {
770	$sql_table = "spip_auteurs_elargis";
771	if(($id_auteur = intval($id_auteur)) > 0) {
772	$sql_where = "id_auteur=$id_auteur";
773	$msg = "id_auteur #$id_auteur";
774	}
775	else if ($id_auteur == 'tous') {
776	$sql_where = "id_auteur>0";
777	$msg = "ALL";
778	}
779	if($sql_where) {
780	if(($result = sql_delete("spip_auteurs_elargis", $sql_where)) === false) {
781	spiplistes_sqlerror_log("format_abo_supprimer()");
782	}
783	else {
784	spiplistes_log_api("delete format for $msg");
785	}
786	}
787	return($result);
788	}
789
790	/**
791	* modifier le format abonne
792	* si id_auteur, celui-ci uniquement
793	* sinon, 'tous' pour modifier globalement (uniquement ceux ayant deja un format)
794	*/
795	function spiplistes_format_abo_modifier ($id_auteur, $format = 'non') {
796
797	if($format = spiplistes_format_valide($format)) {
798	$sql_table = "spip_auteurs_elargis";
799	$sql_champs = array('`spip_listes_format`' => sql_quote($format));
800	if($id_auteur == 'tous') {
801	// appliquer le meme format a tous les abos
802	$sql_result = sql_update($sql_table, $sql_champs, 1);
803	$action = "update";
804	}
805	else if(($id_auteur = intval($id_auteur)) > 0) {
806	if(($cur_format = spiplistes_format_abo_demande($id_auteur)) !== false) {
807	// si pas d'erreur sql
808	if(!$cur_format) {
809	// si inexistant faire un insert
810	$sql_champs = array(
811	'id_auteur' => $id_auteur
812	, '`spip_listes_format`' => $format
813	);
814	$sql_result = sql_insertq($sql_table, $sql_champs);
815	$action = "insert";
816	} else {
817	// sinon update
818	$sql_where = "id_auteur=".sql_quote($id_auteur)." LIMIT 1";
819	$sql_result = sql_update($sql_table, $sql_champs, $sql_where);
820	$action = "update";
821	}
822	}
823	}
824	if($sql_result === false) {
825	spiplistes_sqlerror_log("spiplistes_format_abo_modifier() $action $id_auteur");
826	}
827	else {
828	$id_auteur = ($id_auteur == 'tous') ? "ALL" : "id_auteur #$id_auteur";
829	spiplistes_log_api("$action format to '$format' for $id_auteur");
830	}
831	}
832	return($sql_result);
833	}
834
835	/**
836	* renvoie le format d'abonnement d'un auteur
837	* @param int $id_auteur
838	* @return string
839	*/
840	function spiplistes_format_abo_demande ($id_auteur) {
841	$id_auteur = intval($id_auteur);
842	$result = false;
843	$sql_where = "id_auteur=".sql_quote($id_auteur);
844	if($id_auteur > 0) {
845	if(!spiplistes_spip_est_inferieur_193()) {
846	$result = sql_getfetsel("`spip_listes_format`", "spip_auteurs_elargis", $sql_where, '', '', 1);
847	} else {
848	/*
849	$result = sql_fetsel("`spip_listes_format` AS format", "spip_auteurs_elargis", $sql_where);
850	$result = $result['format'];
851	*/
852	if(($sql_result = sql_select("`spip_listes_format` AS format", "spip_auteurs_elargis", $sql_where, '', '', 1)) !== false) {
853	$row = sql_fetch($sql_result);
854	$result = $row['format'];
855	spiplistes_log_api("current format for id_auteur #$id_auteur = $result ($sql_where)");
856	}
857	else {
858	spiplistes_sqlerror_log("spiplistes_format_abo_demande()");
859	}
860	}
861	/* Code a valider. Si ok, supprimer ci-dessus.
862	$GLOBALS['mysql_rappel_nom_base'] = false;
863	$result = sql_getfetsel("spip_listes_format", "spip_auteurs_elargis", "id_auteur=".sql_quote($id_auteur));
864	$result = spiplistes_format_valide($result);
865	/**/
866	}
867	return($result);
868	}
869
870	/**
871	* liste des formats autorises
872	* ($idx == 'array') array (index et sa valeur identique)
873	* ($idx == 'quoted') la valeur est sql_quote'
874	* ($idx == 'sql_where') string ligne sql_where formatee avec OR
875	* @version CP-20090111
876	* @param $idx string[optional]
877	* @return string\|array
878	*/
879	function spiplistes_formats_autorises ($idx = 'array') {
880	static $formats;
881	if(!$formats) {
882	$ii = explode(";", _SPIPLISTES_FORMATS_ALLOWED);
883	$formats = array('array' => array_combine($ii, $ii));
884	$formats['quoted'] = array_map("sql_quote", $formats['array']);
885	$formats['sql_where'] = "(`spip_listes_format`=" . implode(" OR `spip_listes_format`=", $formats['quoted']).")";
886	}
887	return($formats[$idx]);
888	}
889
890	/**
891	* Donne le format de reception par defaut
892	*
893	* Le format de réception de courrier est définissable
894	* par la page de configuration du plugin.
895	* @version CP-20110508
896	* @return string
897	*/
898	function spiplistes_formats_abo_default () {
899	$defaut = spiplistes_pref_lire('opt_format_courrier_defaut');
900	if (
901	($defaut != 'html')
902	&& ($defaut != 'texte')
903	) {
904	$defaut = _SPIPLISTES_FORMAT_DEFAULT;
905	}
906	return ($defaut);
907	}
908
909	/**
910	* Inventaire des formats de réception par défaut.
911	*
912	* Tableau dont l'index est l'ID de l'auteur
913	* et la valeur le format de réception par défaut.
914	*
915	* @param string\|array $sql_where
916	* @version CP-20110510
917	* @return array\|bool
918	*/
919	function spiplistes_formats_defaut_lister ($sql_where = '') {
920
921	if(
922	($sql_result = sql_select('id_auteur,`spip_listes_format` AS format'
923	, 'spip_auteurs_elargis'
924	, $sql_where
925	)
926	) !== FALSE )
927	{
928	$auteurs = array();
929
930	while($row = sql_fetch($sql_result)) {
931	$auteurs[$row['id_auteur']] = $row['format'];
932	}
933	return ($auteurs);
934	}
935	else {
936	spiplistes_sqlerror_log('spiplistes_formats_defaut_lister ()');
937	}
938	return (FALSE);
939	}
940
941	/**
942	******************************************************************************
943	Les fonctions spiplistes_mod_listes_*() concernent les moderateurs
944
945	Table cible : spip_auteurs_mod_listes
946
947	******************************************************************************
948	*/
949
950	/**
951	* renvoie ID du moderateur de la liste
952	* ou de toutes les listes si $id_liste = 'toutes'
953	* -> result du style: array[id_liste] => array(id_auteur, ...)
954	* @version CP-20080608
955	*/
956	function spiplistes_mod_listes_get_id_auteur ($id_liste) {
957	$sql_from = 'spip_auteurs_mod_listes';
958	$sql_where =
959	($id_liste == "toutes")
960	? ""
961	: "id_liste=".sql_quote(intval($id_liste))
962	;
963	if($sql_result = sql_select("*", $sql_from, $sql_where)) {
964	$result = array();
965	while($row = sql_fetch($sql_result)) {
966	$ii = $row['id_liste'];
967	if(!isset($result[$ii])) {
968	$result[$ii] = array();
969	}
970	$result[$ii][] = $row['id_auteur'];
971	}
972	return($result);
973	}
974	return(false);
975	}
976
977	/**
978	* supprime un ou + moderateurs d'une liste
979	* ou tous les moderateurs si $id_auteur == 'tous'
980	* @version CP-20090111
981	*/
982	function spiplistes_mod_listes_supprimer ($id_auteur, $id_liste) {
983	if(($id_auteur = intval($id_auteur)) > 0) {
984	$sql_where = array("id_auteur=$id_auteur");
985	$msg = "id_auteur #$id_auteur";
986	} else if($id_auteur == "tous") {
987	$sql_where = array("id_auteur>0");
988	$msg = "ALL";
989	}
990	if($sql_where && (($id_liste = intval($id_liste)) > 0)) {
991	$sql_where[] = "id_liste=$id_liste";
992	if(($result = sql_delete('spip_auteurs_mod_listes', $sql_where)) !== false) {
993	spiplistes_log_api("delete moderator #$id_auteur from id_liste #$id_liste");
994	}
995	else {
996	spiplistes_sqlerror_log("mod_listes_supprimer()");
997	}
998	}
999	return($result);
1000	}
1001
1002	/**
1003	* @version CP-20080512
1004	*/
1005	function spiplistes_mod_listes_ajouter ($id_auteur, $id_liste) {
1006	if(($id_liste = intval($id_liste)) > 0) {
1007	$result =
1008	sql_insertq('spip_auteurs_mod_listes'
1009	, array(
1010	'id_auteur' => $id_auteur
1011	, 'id_liste' => $id_liste
1012	)
1013	);
1014	if($result !== false) {
1015	spiplistes_log_api("insert moderator id_auteur #$id_auteur to id_liste #$id_liste");
1016	}
1017	else {
1018	spiplistes_sqlerror_log("mod_listes_ajouter");
1019	}
1020	}
1021	return($result);
1022	}
1023
1024	/**
1025	* @version CP-20080610
1026	*/
1027	function spiplistes_mod_listes_compter ($id_liste) {
1028	$n = sql_fetch(sql_select("COUNT(*) AS n", "spip_auteurs_mod_listes", "id_liste=".sql_quote($id_liste)));
1029	return(($n && $n['n']) ? $n['n'] : false);
1030	}
1031
1032	/**
1033	* renvoie tableau id_liste des listes moderees par l'auteur
1034	* @version CP-20080620
1035	* @return bool\|array
1036	*/
1037	function spiplistes_mod_listes_id_auteur ($id_auteur) {
1038	$result = false;
1039	if($sql_result = sql_select('id_liste', 'spip_auteurs_mod_listes', 'id_auteur='.sql_quote($id_auteur))) {
1040	$result = array();
1041	while($row = sql_fetch($sql_result)) {
1042	$result[] = $row['id_liste'];
1043	}
1044	}
1045	else if($sql_result === false) {
1046	spiplistes_sqlerror_log("mod_listes_id_auteur");
1047	}
1048	return($result);
1049	}
1050
1051	/**
1052	* passe propre() sur un texte puis nettoie les trucs rajoutes par spip sur du html
1053	* @return string
1054	* Remplace spiplistes_courrier_propre() qui est a supprimer apres verif.
1055	*/
1056	function spiplistes_texte_propre ($texte) {
1057	spiplistes_debug_log ('spiplistes_texte_propre()');
1058	static $adresse_site;
1059	if (!$adresse_site) { $adresse_site = $GLOBALS['meta']['adresse_site']; }
1060	static $style_rev = '__STYLE__';
1061
1062	if (preg_match ('@<style[^>]>[^<]</style>@'
1063	, $texte
1064	, $style_reg
1065	)
1066	> 0
1067	) {
1068	$style_str = $style_reg[0];
1069	}
1070	else {
1071	$style_str = '';
1072	}
1073	$texte = preg_replace ('@<style[^>]>[^<]</style>@', $style_rev, $texte);
1074
1075	//passer propre si y'a pas de html (balises fermantes)
1076	if( !preg_match(',</?('._BALISES_BLOCS.')[>[:space:]],iS', $texte) )
1077	$texte = propre($texte); // pb: enleve aussi <style>...
1078
1079	// Corrections complementaires
1080	$patterns = array();
1081	$replacements = array();
1082	// html
1083	$patterns[] = '#<br>#i';
1084	$replacements[] = '<br />';
1085	$patterns[] = '#<b>([^<]*)</b>#i';
1086	$replacements[] = '<strong>\\1</strong>';
1087	$patterns[] = '#<i>([^<]*)</i>#i';
1088	$replacements[] = '<em>\\1</em>';
1089	// spip class
1090	$patterns[] = '# class="spip"#';
1091	$replacements[] = '';
1092
1093	$texte = preg_replace($patterns, $replacements, $texte);
1094
1095	// remettre en place les styles
1096	$texte = str_replace ($style_rev, $style_str, $texte);
1097
1098	//les liens avec double debut #URL_SITE_SPIP/#URL_ARTICLE
1099	$texte = preg_replace (
1100	'@'
1101	. $adresse_site
1102	. '/'
1103	. $adresse_site
1104	. '@'
1105	, $adresse_site
1106	, $texte
1107	);
1108	$texte = spiplistes_liens_absolus ($texte);
1109
1110	return ($texte);
1111	}
1112
1113	function spiplistes_titre_propre($titre){
1114	$titre = spiplistes_texte_propre($titre);
1115	$titre = substr($titre, 0, 128); // Au cas ou copie/colle
1116	return($titre);
1117	}
1118
1119	/**
1120	* Recherche les différentes versions de patron possibles
1121	* <patron>._texte.en patron texte anglais
1122	* <patron>._texte patron texte generique
1123	* <patron>.en patron anglais
1124	* <patron> patron generique
1125	* @version CP-20081128
1126	* @param $path_patron string
1127	* @param $lang string
1128	* @param $chercher_texte bool si TRUE, chercher la version texte du patron
1129	* @return string le chemin du patron si patron trouve' ou FALSE si non trouve'
1130	* @todo verifier presence de lang dans les appels a cette fonction
1131	*/
1132	function spiplistes_patron_find_in_path ($path_patron, $lang, $chercher_texte = false) {
1133	static $t = "_texte", $h = ".html";
1134
1135	if(!$lang) {
1136	$lang = $GLOBALS['spip_lang'];
1137	}
1138
1139	if(
1140	$chercher_texte
1141	&& (find_in_path($path_patron . $t . "." . $lang . $h) \|\| find_in_path($path_patron . $t . $h))
1142	) {
1143	return($path_patron . $t);
1144	}
1145	else if(find_in_path($path_patron . "." . $lang . $h) \|\| find_in_path($path_patron . $h)) {
1146	return($path_patron);
1147
1148	}
1149	return(false);
1150	}
1151
1152	/**
1153	* Incruster les styles inline
1154	*
1155	* @version CP-20110510
1156	* @param string $texte_html
1157	* @return string
1158	*/
1159	function spiplistes_html_styles_inline ($texte_html) {
1160
1161	if (strpos($texte_html, 'spip_documents_center') !== FALSE)
1162	{
1163	$pattern = array(
1164	"{<span class='spip_document_\d* spip_documents spip_documents_center'>}m"
1165	);
1166	$replacement = array(
1167	'<span style="display:block;text-align:center">'
1168	);
1169	$texte_html = preg_replace ($pattern, $replacement, $texte_html);
1170	}
1171	return ($texte_html);
1172	}
1173
1174	/**
1175	* Assembler/calculer un patron
1176	* @version CP-20090427
1177	* @param $patron string nom du patron
1178	* @param $contexte array
1179	* @return array le resultat html et texte seul dans un tableau
1180	*/
1181	function spiplistes_assembler_patron ($path_patron, $contexte) {
1182
1183	include_spip('inc/distant');
1184
1185	// Pour recuperer_fond()
1186	// qui est passé en inc/utils en SPIP 2
1187	if (spiplistes_spip_est_inferieur_193()) {
1188	include_spip('public/assembler');
1189	}
1190
1191	$patron_html = spiplistes_patron_find_in_path($path_patron, $contexte['lang'], false);
1192	$contexte['patron_html'] = $patron_html;
1193
1194	$result_html =
1195	($patron_html && find_in_path('patron_switch.html'))
1196	? recuperer_fond('patron_switch', $contexte)
1197	: ''
1198	;
1199
1200	/**
1201	* Calculer le contenu texte à partir
1202	* du {patron}_texte s'il existe
1203	*/
1204	$patron_texte = spiplistes_patron_find_in_path($path_patron, $contexte['lang'], true);
1205	unset($contexte['patron_html']);
1206	$contexte['patron_texte'] = $patron_texte;
1207	$result_texte = '';
1208	$texte_ok = false;
1209	if ($patron_texte && ($patron_texte != $patron_html))
1210	{
1211	spiplistes_debug_log('CREATE text version USING '.$patron_texte);
1212
1213	if (find_in_path('patron_switch.html')) {
1214	if($result_texte = recuperer_fond('patron_switch', $contexte))
1215	{
1216	$result_texte = spiplistes_courrier_version_texte($result_texte);
1217	}
1218	$texte_ok = true;
1219	}
1220	}
1221	/**
1222	* si {patron}_texte manque, ou vide,
1223	* calculer a partir de la version html
1224	*/
1225	if (!$texte_ok) {
1226	$result_texte = spiplistes_courrier_version_texte($result_html);
1227	}
1228	// eliminer les espaces pour un vrai calcul de poids
1229	$result_html = trim($result_html);
1230	$result_texte = trim($result_texte);
1231	$result = array ($result_html, $result_texte);
1232
1233	return($result);
1234	}
1235
1236	/**
1237	* donne contenu tampon au format html (CP-20071013) et texte
1238	* @return array (string $html, string $texte)
1239	*/
1240	function spiplistes_tampon_assembler_patron () {
1241	//spiplistes_log_api("calculer tampon");
1242	$contexte = array();
1243	$path_patron = spiplistes_pref_lire('tampon_patron');
1244	//spiplistes_log_api($path_patron);
1245	if(!empty($path_patron))
1246	{
1247	foreach(explode(",", _SPIPLISTES_TAMPON_CLES) as $key) {
1248	$s = spiplistes_pref_lire($key);
1249	$contexte[$key] = (!empty($s) && ($s != 'non')) ? $s : '';
1250	}
1251	$result = spiplistes_assembler_patron(_SPIPLISTES_PATRONS_TAMPON_DIR . $path_patron, $contexte);
1252	}
1253	else {
1254	$result = array("", "");
1255	}
1256	return($result);
1257	}
1258
1259	function spiplistes_pied_page_assembler_patron ($id_liste, $lang = false) {
1260
1261	$result = array("", "");
1262
1263	if(($id_liste = intval($id_liste)) > 0)
1264	{
1265	$pied_patron = sql_getfetsel('pied_page', 'spip_listes', "id_liste=".sql_quote($id_liste), '','',1);
1266
1267	$pied_patron =
1268	(!$pied_patron)
1269	// si patron vide (ancienne version de SPIP-Listes ?), appliquer le patron par defaut
1270	? _SPIPLISTES_PATRONS_PIED_DEFAUT
1271	: $pied_patron
1272	;
1273	if(strlen($pied_patron) > _SPIPLISTES_PATRON_FILENAMEMAX)
1274	{
1275	// probablement le contenu du pied (SPIP-Listes <= 1.9.2 ?)
1276	// rester compatible avec les anciennes version de SPIP-Listes
1277	// qui stoquaient le patron assemble' en base
1278	$pied_texte = spiplistes_courrier_version_texte($pied_html = $pied_patron);
1279	$result = array($pied_html, $pied_texte);
1280	}
1281	else if(strlen($pied_patron) && ($pied_patron != _SPIPLISTES_PATRON_PIED_IGNORE)) {
1282
1283	if(!$lang) {
1284	$lang = spiplistes_listes_langue($id_liste) \|\| $GLOBALS['spip_lang'];
1285	}
1286	$contexte = array('lang' => $lang);
1287	$result = spiplistes_assembler_patron (
1288	_SPIPLISTES_PATRONS_PIED_DIR . $pied_patron
1289	, $contexte
1290	);
1291	}
1292	}
1293	return ($result);
1294	}
1295
1296	function spiplistes_format_valide ($format) {
1297	return(in_array($format, array("non", "texte", "html")) ? $format : false);
1298	}
1299
1300	/**
1301	******************************************************************************
1302	Les fonctions spiplistes_auteurs_*() concernent les auteurs
1303
1304	Table cible : spip_auteurs
1305
1306	******************************************************************************
1307	*/
1308
1309	/**
1310	* @version CP-20080503
1311	* soit update cookie du cookie transmis
1312	* soit update cookie de l'email transmis
1313	*/
1314	function spiplistes_auteurs_cookie_oubli_updateq ($cookie_oubli, $where, $where_is_cookie = false) {
1315	if(is_string($where)) {
1316	$where = (($where_is_cookie) ? "cookie_oubli" : "email")
1317	. "=" . sql_quote($where) . " LIMIT 1";
1318	}
1319	return(sql_update('spip_auteurs', array('cookie_oubli' => sql_quote($cookie_oubli)), $where));
1320	}
1321
1322	/**
1323	* @version CP-20080629
1324	* soit update cookie du cookie transmis
1325	* soit update cookie de l'email transmis
1326	*/
1327	function spiplistes_date_heure_valide ($date_heure) {
1328	$date_array = recup_date($date_heure);
1329	if($date_array) {
1330	list($annee, $mois, $jour) = $date_array;
1331	list($heures, $minutes, $secondes) = recup_heure($date_heure);
1332	return(array($annee, $mois, $jour, $heures, $minutes, $secondes));
1333	}
1334	return(false);
1335	}
1336
1337	/**
1338	* Nombre total d'auteurs (ou visiteur, ou perso) elligibles
1339	* Nota: un compte 'nouveau' est un compte visiteur (inscription) qui ne s'est pas encore connecté
1340	* Nota2: un compte créé via l'espace privé mais pas encore connecté
1341	* n'a pas le statut 'nouveau' mais celui de son groupe
1342	* @version CP-200080519
1343	*/
1344	function spiplistes_auteurs_elligibles_compter ()
1345	{
1346	static $nb;
1347	if(!$nb)
1348	{
1349	$sql_where = array(
1350	'statut!='.sql_quote('5poubelle')
1351	, 'statut!='.sql_quote('nouveau')
1352	);
1353	$nb = sql_countsel('spip_auteurs', $sql_where);
1354	}
1355	return($nb);
1356	}
1357
1358	/**
1359	* Total des auteurs qui ne sont pas abonnes a une liste
1360	* @version CP-200080519
1361	*/
1362	function spiplistes_auteurs_non_abonnes_compter ()
1363	{
1364	static $nb;
1365	if($nb === null)
1366	{
1367	$selection =
1368	(spiplistes_spip_est_inferieur_193())
1369	? 'SELECT id_auteur FROM spip_auteurs_listes GROUP BY id_auteur'
1370	: sql_select('id_auteur', 'spip_auteurs_listes', '','id_auteur','','','','',false)
1371	;
1372	$sql_where = array(
1373	'statut!='.sql_quote('5poubelle')
1374	, 'statut!='.sql_quote('nouveau')
1375	, 'id_auteur NOT IN ('.$selection.')'
1376	);
1377	$nb = sql_countsel('spip_auteurs', $sql_where);
1378	}
1379	return($nb);
1380	}
1381
1382	/**
1383	* CP-20080511 20110315
1384	* Renvoie la selection pour un seul auteur
1385	* @return array OR false
1386	*/
1387	function spiplistes_auteurs_auteur_select ($select, $where = array())
1388	{
1389	//$result = sql_select($select, 'spip_auteurs', $where, '', '', 1);
1390	$auteur = sql_fetsel($select, 'spip_auteurs', $where, '', '', 1);
1391	return($auteur);
1392	}
1393
1394	/**
1395	* CP-20080511
1396	*/
1397	function spiplistes_auteurs_auteur_delete ($sql_where) {
1398	// détruire ou mettre à la poubelle ?
1399	// SPIP ne détruit pas lui !
1400	// dans le doute...
1401	// if(($result = sql_delete('spip_auteurs', $sql_where." LIMIT 1")) === false) {
1402	if(($result = sql_update(
1403	"spip_auteurs"
1404	, array('statut' => sql_quote('5poubelle'))
1405	, $sql_where . " LIMIT 1"
1406	)) === false) {
1407	spiplistes_sqlerror_log("auteurs_auteur_delete");
1408	}
1409	return($result);
1410	}
1411
1412	/**
1413	* CP-20080511
1414	* @return int\|bool
1415	*/
1416	function spiplistes_auteurs_auteur_insertq ($champs_array) {
1417	$id_auteur = sql_insertq('spip_auteurs', $champs_array);
1418	return($id_auteur);
1419	}
1420
1421	/**
1422	* CP-20090409
1423	*/
1424	function spiplistes_auteurs_auteur_valider ($id_auteur, $as_redact = false) {
1425	if($id_auteur = intval($id_auteur)) {
1426	if(($result = sql_update(
1427	"spip_auteurs_listes"
1428	, array('statut' => sql_quote('valide'))
1429	, "id_auteur=$id_auteur LIMIT 1"
1430	)) === false) {
1431	spiplistes_sqlerror_log("auteurs_auteur_valider");
1432	}
1433	else {
1434
1435	}
1436	}
1437	return($result);
1438	}
1439
1440	/**
1441	* CP-20110315
1442	* @return bool
1443	*/
1444	function spiplistes_auteurs_auteur_statut_modifier ($id_auteur, $statut)
1445	{
1446	spiplistes_debug_log ('modification status for auteur #'.$id_auteur);
1447	$result = sql_update(
1448	'spip_auteurs'
1449	, array('statut' => sql_quote($statut))
1450	, 'id_auteur='.$id_auteur.' LIMIT 1'
1451	);
1452	return ($result);
1453	}
1454
1455	/**
1456	* CP-20110321
1457	* Retourne une version texte pure du nom du site
1458	* @return string
1459	*/
1460	function spiplistes_nom_site_texte ($lang = '') {
1461
1462	static $nom_site;
1463	$lang = trim ($lang);
1464	if (empty($lang)) {
1465	$lang = $GLOBALS['meta']['langue_site'];
1466	}
1467
1468	if ($nom_site === null)
1469	{
1470	$nom_site = array();
1471	}
1472	if (!isset($nom_site[$lang]))
1473	{
1474	$n = strip_tags(html_entity_decode(extraire_multi($GLOBALS['meta']['nom_site'])));
1475
1476	// incorrect avec utf-8. Abime les diacritiques
1477	//$n = preg_replace ('@\s*@', ' ', $n);
1478
1479	$nom_site[$lang] = trim($n);
1480	}
1481	return ($nom_site[$lang]);
1482	}
1483
1484	/**
1485	* @version CP-20110321
1486	* @return string
1487	*/
1488	function spiplistes_texte_2_charset ($texte, $charset) {
1489	if ($charset && ($charset != $GLOBALS['meta']['charset'])) {
1490	include_spip('inc/charsets');
1491	$texte = unicode2charset(charset2unicode($texte), $charset);
1492	}
1493	return ($texte);
1494	}
1495
1496	/**
1497	* utiliser l'api pour pouvoir envoyer par smtp si besoin
1498	* @version CP-20090111
1499	*/
1500	function spiplistes_envoyer_mail ($to, $subject, $message, $from = false, $headers = '', $format = 'texte') {
1501
1502	static $opt_simuler_envoi;
1503
1504	// si desabo, plus de format ! donc forcer a texte
1505	$format = ($format == 'html') ? $format : 'texte';
1506
1507	$charset = $GLOBALS['meta']['spiplistes_charset_envoi'];
1508	if(!$opt_simuler_envoi) {
1509	$opt_simuler_envoi = spiplistes_pref_lire('opt_simuler_envoi');
1510	}
1511	if (!$from)
1512	{
1513	$from = spiplistes_email_from_default();
1514	}
1515	if(strpos($from, '<') === false) {
1516	$fromname = spiplistes_nom_site_texte();
1517
1518	if ($charset != $GLOBALS['meta']['charset']){
1519	include_spip('inc/charsets');
1520	$fromname = unicode2charset(charset2unicode($fromname),$charset);
1521	}
1522	}
1523	// @TODO: voir email_reply_to ?
1524	$reply_to = 'no-reply'.preg_replace("\|.*(@[a-z.]+)\|i", "$1", email_valide($from));
1525
1526	if($opt_simuler_envoi == 'oui') {
1527	spiplistes_log("!!! MAIL SIMULATION MODE !!!");
1528	$result = true;
1529	}
1530	else {
1531	include_once(_DIR_PLUGIN_SPIPLISTES.'inc/spiplistes_mail.inc.php');
1532
1533	$email_a_envoyer = array();
1534
1535	$return_path = spiplistes_return_path($from);
1536
1537	if(is_array($message))
1538	{
1539	if($format=='html' && isset($message[$format])) {
1540	$email_a_envoyer['html'] = new phpMail($to, $subject, $message['html'], $message['texte'], $charset);
1541	$email_a_envoyer['html']->From = $from ;
1542	if($fromname) $email_a_envoyer['html']->FromName = $fromname ;
1543	$email_a_envoyer['html']->AddCustomHeader("Errors-To: ".$return_path);
1544	$email_a_envoyer['html']->AddCustomHeader("Reply-To: ".$from);
1545	$email_a_envoyer['html']->AddCustomHeader("Return-Path: ".$return_path);
1546	$email_a_envoyer['html']->SMTPKeepAlive = true;
1547	$email_a_envoyer['html']->Body = $message['html']->Body;
1548	$email_a_envoyer['html']->AltBody = $message['html']->AltBody;
1549	}
1550	$message = $message['texte']->Body;
1551	}
1552	//$message = spiplistes_html_entity_decode ($message, $charset);
1553	$message = spiplistes_translate_2_charset ($message, $charset, true);
1554
1555	//$email_a_envoyer['texte'] = new phpMail($to, $subject, '', html_entity_decode($message), $charset);
1556	$email_a_envoyer['texte'] = new phpMail($to, $subject, '', $message, $charset);
1557	$email_a_envoyer['texte']->From = $from ;
1558	if($fromname) $email_a_envoyer['html']->FromName = $fromname ;
1559	$email_a_envoyer['texte']->AddCustomHeader('Errors-To: '.$return_path);
1560	$email_a_envoyer['texte']->AddCustomHeader('Reply-To: '.$reply_to);
1561	$email_a_envoyer['texte']->AddCustomHeader('Return-Path: '.$return_path);
1562	$email_a_envoyer['texte']->SMTPKeepAlive = true;
1563
1564	$result = $email_a_envoyer[$format]->send();
1565
1566	$msg = "email from $from to $to";
1567	spiplistes_log(!$result ? "error: $msg not sent" : "$msg sent");
1568	}
1569	return($result);
1570	}
1571
1572	function spiplistes_listes_statuts_periodiques () {
1573	static $s;
1574	if($s === null) {
1575	$s = explode(';', _SPIPLISTES_LISTES_STATUTS_PERIODIQUES);
1576	}
1577	return ($s);
1578	}
1579
1580	/**
1581	* Creation du login a partir de l email donne'
1582	* @return string or false if error
1583	* @param $mail string
1584	*/
1585	function spiplistes_login_from_email ($mail) {
1586
1587	$result = false;
1588
1589	if($mail = email_valide($mail)) {
1590
1591	// partie gauche du mail
1592	$left = substr($mail, 0, strpos($mail, "@"));
1593
1594	// demande la liste des logins pour assurer unicite
1595	$sql_result = sql_select('login', 'spip_auteurs');
1596	$logins_base = array();
1597	while($row = sql_fetch($sql_result)) {
1598	$logins_base[] = $row['login'];
1599	}
1600	// creation du login
1601	for ($ii = 0; $ii < _SPIPLISTES_MAX_LOGIN_NN; $ii++) {
1602	$login = $left . (($ii > 0) ? $ii : "");
1603	if(!in_array($login, $logins_base))
1604	{
1605	$result = $login;
1606	break;
1607	}
1608	}
1609	}
1610	return($result);
1611	}
1612
1613	/**
1614	* Donne la langue de la liste
1615	*/
1616	function spiplistes_listes_langue ($id_liste) {
1617	if(($id_liste = intval($id_liste)) > 0) {
1618	return(
1619	sql_getfetsel(
1620	'lang'
1621	, "spip_listes"
1622	, "id_liste=".sql_quote($id_liste)." LIMIT 1"
1623	)
1624	);
1625	}
1626	return(false);
1627	}
1628
1629	/*
1630	*/
1631	function spiplistes_return_path ($from) {
1632	return(spiplistes_pref_lire_defaut ('email_return_path_defaut', $from));
1633	}
1634
1635	/**
1636	* Lire la valeur de $key dans les prefs (meta)
1637	* Si erreur (manquante) appliquer $defaut
1638	*/
1639	function spiplistes_pref_lire_defaut ($key, $default)
1640	{
1641	$value = spiplistes_pref_lire($key);
1642	if(!$value) {
1643	$value = $default;
1644	}
1645	return($value);
1646	}
1647
1648	function spiplistes_str_auteurs ($nb)
1649	{
1650	$result =
1651	($nb > 0)
1652	? _T('spiplistes:' . (($nb > 1) ? '_n_auteurs_' : '_1_auteur_'), array('n' => $nb))
1653	: 'erreur param'
1654	;
1655	return($result);
1656	}
1657
1658	function spiplistes_str_abonnes ($nb)
1659	{
1660	$result =
1661	($nb > 0)
1662	? _T('spiplistes:' . (($nb > 1) ? '_n_abonnes_' : '1_abonne'), array('n' => $nb))
1663	: _T('spiplistes:aucun_abo')
1664	;
1665	return($result);
1666	}
1667
1668	function spiplistes_str_abonnements ($nb)
1669	{
1670	$result =
1671	($nb > 0)
1672	? _T('spiplistes:' . (($nb > 1) ? '_n_abos_' : '_1_abo_'), array('n' => $nb))
1673	: _T('spiplistes:aucun_abonmt')
1674	;
1675	return($result);
1676	}
1677
1678
1679	function spiplistes_str_listes ($nb)
1680	{
1681	$result =
1682	($nb > 0)
1683	? _T('spiplistes:' . (($nb > 1) ? 'n_listes' : '1_liste'), array('n' => $nb))
1684	: 'erreur param'
1685	;
1686	return($result);
1687	}
1688
1689	/******************************************************************************************/
1690	/* SPIP-Listes est un systeme de gestion de listes d'abonnes et d'envoi d'information */
1691	/* par email pour SPIP. http://bloog.net/spip-listes */
1692	/* Copyright (C) 2004 Vincent CARON v.caron<at>laposte.net */
1693	/* */
1694	/* Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes */
1695	/* de la Licence Publique Generale GNU publiee par la Free Software Foundation */
1696	/* (version 2). */
1697	/* */
1698	/* Ce programme est distribue car potentiellement utile, mais SANS AUCUNE GARANTIE, */
1699	/* ni explicite ni implicite, y compris les garanties de commercialisation ou */
1700	/* d'adaptation dans un but specifique. Reportez-vous a la Licence Publique Generale GNU */
1701	/* pour plus de details. */
1702	/* */
1703	/* Vous devez avoir recu une copie de la Licence Publique Generale GNU */
1704	/* en meme temps que ce programme ; si ce n'est pas le cas, ecrivez a la */
1705	/* Free Software Foundation, */
1706	/* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, Etats-Unis. */
1707	/******************************************************************************************/

Note: See TracBrowser for help on using the repository browser.

Download in other formats: