Dotclear

source: plugins/newsletter/trunk/inc/class.newsletter.core.php @ 1447

Revision 1447, 42.3 KB checked in by kwon, 14 years ago (diff)

Plugin newsletter

  • closes #218,#227
  • mise à jour de l'aide en ligne
  • Property svn:executable set to *
Line 
1<?php
2# -- BEGIN LICENSE BLOCK ----------------------------------
3# This file is part of Newsletter, a plugin for Dotclear.
4#
5# Copyright (c) 2009 Benoit de Marne
6# benoit.de.marne@gmail.com
7#
8# Licensed under the GPL version 2.0 license.
9# A copy of this license is available in LICENSE file or at
10# http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
11# -- END LICENSE BLOCK ------------------------------------
12
13// chargement des librairies
14require dirname(__FILE__).'/class.template.php';
15require dirname(__FILE__).'/class.newsletter.mailing.php';
16
17// le plugin
18class newsletterCore
19{
20     // Définition des variables
21     protected $blog;
22     protected $con;
23     protected $table;
24     protected $blogid;
25     protected $errors;
26
27     /**
28     Fonction d'init
29     */   
30     public function __construct(&$core)
31     {
32          $this->core =& $core;
33          $this->blog =& $core->blog;
34          $this->con =& $this->blog->con;
35          $this->blogid = $con->escape((string)$blog->id);
36     }
37     
38     /* ==================================================
39          fonction techniques
40     ================================================== */
41
42     /**
43     * est-ce que la version de Dotclear est installée
44     */
45     public static function isAllowed()
46     {
47          //if (newsletterPlugin::isRelease() || newsletterPlugin::isBeta('7'))
48          if (newsletterPlugin::isRelease()) 
49               return true;
50          else 
51               return false;
52     }
53
54     /**
55     * est-ce que le plugin est installé
56     */
57     public static function isInstalled() 
58     { 
59          return newsletterPlugin::isInstalled(); 
60     }
61
62     /**
63     * retourne le contenu total de la table sous forme de tableau de données brutes
64     * (tout blog confondu)
65     */
66     public static function getRawDatas($onlyblog = false)
67     {
68          global $core;
69          try
70          {
71               $blog = &$core->blog;
72               $con = &$core->con;
73               $blogid = (string)$blog->id;
74
75               // requète sur les données et renvoi null si erreur
76               $strReq =
77                    'SELECT *'.
78                    ' FROM '.$core->prefix.newsletterPlugin::pname();
79                   
80               if($onlyblog) {
81                    $strReq .= ' WHERE blog_id=\''.$blogid.'\''; 
82               }
83
84               $rs = $con->select($strReq);
85               if ($rs->isEmpty())
86                    return null;
87               else 
88                    return $rs;
89          }
90         catch (Exception $e) { $core->error->add($e->getMessage()); }
91     }
92
93     /**
94     * retourne le prochain id de la table
95     */
96     public static function nextId()
97     {
98          global $core;
99          try {
100               $blog = &$core->blog;
101               $con = &$core->con;
102               $blogid = (string)$blog->id;
103
104               // requète sur les données et renvoi un entier
105               /*
106               $strReq =
107                    'SELECT max(subscriber_id)'.
108                    ' FROM '.$core->prefix.newsletterPlugin::pname().
109                    ' WHERE blog_id=\''.$blogid.'\'';
110               //*/
111               $strReq =
112                    'SELECT max(subscriber_id)'.
113                    ' FROM '.$core->prefix.newsletterPlugin::pname();
114
115               $rs = $con->select($strReq);
116               if ($rs->isEmpty()) 
117                    return 0;
118               else 
119                    return ((integer)$rs->f(0)) +1;
120          } catch (Exception $e) { 
121               $core->error->add($e->getMessage()); 
122          }
123     }
124
125     /**
126     * renvoi un id pris au hasard dans la table
127     */
128     public static function randomId()
129     {
130          global $core;
131          try {
132               $blog = &$core->blog;
133               $con = &$core->con;
134               $blogid = (string)$blog->id;
135
136               // requète sur les données et renvoi un entier
137               $strReq =
138               'SELECT min(subscriber_id), max(subscriber_id)'.
139               ' FROM '.$core->prefix.newsletterPlugin::pname().
140               ' WHERE blog_id=\''.$blogid.'\'';
141
142               $rs = $con->select($strReq);
143               if ($rs->isEmpty()) 
144                    return 0;
145               else 
146                    return rand($rs->f(0), $rs->f(1));
147          } catch (Exception $e) { 
148               $core->error->add($e->getMessage()); 
149          }
150     }
151
152     /**
153     * test l'existence d'un abonné par son id
154     */
155     public static function exist($id = -1) 
156     {
157          if (!is_numeric($id)) { // test sur l'id qui doit être numérique
158               return null;
159          } else if ($id < 0) {    // test sur la valeur de l'id qui doit être positive ou null
160               return null;
161          } else {                 // récupère l'abonné
162               global $core;
163               try {
164                    $blog = &$core->blog;
165                    $con = &$core->con;
166                    $blogid = (string)$blog->id;
167
168                    // requète sur les données et renvoi null si erreur
169                    $strReq =
170                    'SELECT subscriber_id'.
171                    ' FROM '.$core->prefix.newsletterPlugin::pname().
172                    ' WHERE blog_id=\''.$blogid.'\' AND subscriber_id='.$id;
173
174                    $rs = $con->select($strReq);
175                    if ($rs->isEmpty()) 
176                         return false;
177                    else 
178                         return true;
179               } catch (Exception $e) { 
180                    $core->error->add($e->getMessage()); 
181               }
182          }
183     }
184
185     /**
186     * récupère un abonné par son email
187     */
188     public static function getEmail($_email = null)
189     {
190          // test sur l'email qui doit être renseigné
191          if ($_email == null) {
192               return null;
193          } else { // récupère l'abonné
194
195               global $core;
196               try {
197                    $blog = &$core->blog;
198                    $con = &$core->con;
199                    $blogid = (string)$blog->id;
200
201                    // nettoyage et sécurisation des données saisies
202                    $email = $con->escape(html::escapeHTML(html::clean($_email)));
203
204                    // requète sur les données et renvoi null si erreur
205                    $strReq =
206                    'SELECT subscriber_id'.
207                    ' FROM '.$core->prefix.newsletterPlugin::pname().
208                    ' WHERE blog_id=\''.$blogid.'\' AND email=\''.$email.'\'';
209
210                    $rs = $con->select($strReq);
211                    if ($rs->isEmpty()) 
212                         return null;
213                    else 
214                         return self::get($rs->f('subscriber_id'));
215               } catch (Exception $e) { 
216                    $core->error->add($e->getMessage()); 
217               }
218          }
219     }
220
221
222     /**
223     * récupère des abonnés par leur id
224     */
225     public static function get($id = -1)
226     {
227          // test sur la valeur de l'id qui doit être positive ou null
228          if ($id < 0) return null;
229
230          // récupère les abonnés
231          else
232          {
233               global $core;
234               try {
235                    $blog = &$core->blog;
236                    $con = &$core->con;
237                    $blogid = (string)$blog->id;
238
239                    // mise en forme du tableau d'id
240                    if (is_array($id)) 
241                         $ids = implode(", ", $id);
242                    else 
243                         $ids = $id;
244
245                    // requète sur les données et renvoi null si erreur
246                    $strReq =
247                    'SELECT subscriber_id,email,regcode,state,subscribed,lastsent,modesend' .
248                    ' FROM '.$core->prefix.newsletterPlugin::pname().
249                    ' WHERE blog_id=\''.$blogid.'\' AND subscriber_id IN('.$ids.')';
250
251                    $rs = $con->select($strReq);
252                    if ($rs->isEmpty()) 
253                         return null;
254                    else 
255                         return $rs;
256               } catch (Exception $e) { 
257                    $core->error->add($e->getMessage()); 
258               }
259          }
260     }
261
262     /**
263     * ajoute un abonné
264     */
265     public static function add($_email = null, $_blogid = null, $_regcode = null, $_modesend = null)
266     {
267          // test des paramètres
268          if ($_email == null) {
269               return null;
270          } else {
271               
272               global $core;
273               try {
274                    $blog = &$core->blog;
275                    $con = &$core->con;
276                    $blogid = $con->escape((string)$blog->id);
277
278                    if (newsletterCore::getEmail($_email)) {
279                         return false;
280                    }
281
282                    // génération des informations manquantes
283                    if ($_regcode == null) {
284                         $_regcode = newsletterTools::regcode();
285                    }
286
287                    if ($_modesend == null) {
288                         $_modesend = newsletterPlugin::getSendMode();
289                    }
290
291                    if ($_blogid == null) {
292                         $_blogid = $blogid;
293                    }
294                   
295                    // génération de la requète
296                    $cur = $con->openCursor($core->prefix.newsletterPlugin::pname());
297                    $cur->subscriber_id = self::nextId();
298                    $cur->blog_id = $_blogid;
299                    $cur->email = $con->escape(html::escapeHTML(html::clean($_email)));
300                    $cur->regcode = $con->escape(html::escapeHTML(html::clean($_regcode)));
301                    $cur->state = 'pending';
302                    $cur->lastsent = $cur->subscribed = date('Y-m-d H:i:s');
303                    $cur->modesend = $con->escape(html::escapeHTML(html::clean($_modesend)));
304
305                    // requète sur les données et retourne un booléen
306                    $cur->insert();
307                    return true;
308               } catch (Exception $e) { 
309                    $core->error->add($e->getMessage()); 
310               }
311          }
312     }
313     
314     /**
315     * met à jour un abonné par son id
316     */
317     public static function update($id = -1, 
318                                   $_email = null, 
319                                   $_state = null, 
320                                   $_regcode = null, 
321                                   $_subscribed = null, 
322                                   $_lastsent = null, 
323                                   $_modesend = null)
324     {
325          // test des paramètres
326          if (!self::exist($id)) {
327               return null;
328          } else { // met à jour l'abonné
329               global $core;
330               try {
331                    $blog = &$core->blog;
332                    $con = &$core->con;
333                    $blogid = $con->escape((string)$blog->id);
334
335                    // génération de la requète
336                    $cur = $con->openCursor($core->prefix.newsletterPlugin::pname());
337
338                    $cur->subscriber_id = $id;
339                    $cur->blog_id = $blogid;
340
341                    if ($_email != null) 
342                         $cur->email = $con->escape(html::escapeHTML(html::clean($_email)));
343                   
344                    if ($_state != null) 
345                         $cur->state = $con->escape(html::escapeHTML(html::clean($_state)));
346                   
347                    if ($_regcode != null) 
348                         $cur->regcode = $con->escape(html::escapeHTML(html::clean($_regcode)));
349                   
350                    if ($_subscribed != null) 
351                         $cur->subscribed = $con->escape(html::escapeHTML(html::clean($_subscribed)));
352                   
353                    if ($_lastsent != null) 
354                         $cur->lastsent = $con->escape(html::escapeHTML(html::clean($_lastsent)));
355                   
356                    if ($_modesend != null) 
357                         $cur->modesend = $con->escape(html::escapeHTML(html::clean($_modesend)));
358
359                    $cur->update('WHERE blog_id=\''.$con->escape($blogid).'\' AND subscriber_id='.$id);
360                   
361                    return true;
362               } catch (Exception $e) { 
363                    $core->error->add($e->getMessage()); 
364               }
365          }
366     }
367
368     /**
369     * supprime un abonné par son id
370     */
371     public static function delete($id = -1)
372     {
373          // test sur la valeur de l'id qui doit être positive ou null
374          if ($id < 0) {
375               return null;
376          } else { // supprime les abonnés
377               global $core;
378               try {
379                    $blog = &$core->blog;
380                    $con = &$core->con;
381                    $blogid = $con->escape((string)$blog->id);
382
383                    // mise en forme du tableau d'id
384                    if (is_array($id)) 
385                         $ids = implode(", ", $id);
386                    else 
387                         $ids = $id;
388
389                    // requète sur les données et renvoi un booléen
390                    $strReq =
391                    'DELETE FROM '.$core->prefix.newsletterPlugin::pname().
392                    ' WHERE blog_id=\''.$blogid.'\' AND subscriber_id IN('.$ids.')';
393
394                    if ($con->execute($strReq)) 
395                         return true;
396                    else
397                         return false;
398               } catch (Exception $e) { 
399                    $core->error->add($e->getMessage()); 
400               }
401          }
402     }
403
404     /**
405     * retourne le contenu de la table sous forme de tableau de données brutes
406     */
407     public static function getlist($active = false)
408     {
409          global $core;
410          try {
411               $blog = &$core->blog;
412               $con = &$core->con;
413               $blogid = $con->escape((string)$blog->id);
414
415               // requête sur les données et renvoi null si erreur
416               $strReq =
417                    'SELECT *'.
418                    ' FROM '.$core->prefix.newsletterPlugin::pname().
419                    ' WHERE blog_id=\''.$blogid.'\'';
420
421               if ($active) $strReq .= ' AND state=\'enabled\'';           
422               
423               $rs = $con->select($strReq);
424               if ($rs->isEmpty()) 
425                    return null;
426               else 
427                    return $rs;
428          } catch (Exception $e) { 
429               $core->error->add($e->getMessage()); 
430          }
431     }
432
433     /**
434     * modifie l'état de l'abonné
435     */
436     public static function state($id = -1, $_state = null)
437     {
438          // test sur la valeur de l'id qui doit être positive ou null
439          if ($id < 0) {
440               return null;
441          } else { 
442               // modifie l'état des abonnés
443         
444               // filtrage sur le code de status
445               switch ($_state) {
446                    case 'pending':
447                    case 'enabled':
448                    case 'suspended':
449                    case 'disabled':
450                         break;
451                    default:
452                         return false;
453               }
454
455               global $core;
456               try {
457                    $blog = &$core->blog;
458                    $con = &$core->con;
459                    $blogid = $con->escape((string)$blog->id);
460
461                    // mise en forme du tableau d'id
462                    if (is_array($id)) 
463                         $ids = implode(", ", $id);
464                    else 
465                         $ids = $id;
466
467                    // génération de la requète
468                    $cur = $con->openCursor($core->prefix.newsletterPlugin::pname());
469
470                    $cur->state = $con->escape(html::escapeHTML(html::clean($_state)));
471
472                    $cur->update('WHERE blog_id=\''.$con->escape($blogid).'\' AND subscriber_id IN('.$ids.')');
473                    return true;
474               } catch (Exception $e) { 
475                    $core->error->add($e->getMessage()); 
476               }
477          }
478     }
479
480     /**
481     * place les comptes en attente
482     */
483     public static function pending($id = -1) 
484     { 
485          return self::state($id, 'pending'); 
486     }
487
488     /**
489     * active les comptes
490     */
491     public static function enable($id = -1) 
492     { 
493          return self::state($id, 'enabled'); 
494     }
495
496     /**
497     * suspend les comptes
498     */
499     public static function suspend($id = -1)
500     { 
501          return self::state($id, 'suspended'); 
502     }
503
504     /**
505     * désactive les comptes
506     */
507     public static function disable($id = -1)
508     { 
509          return self::state($id, 'disabled'); 
510     }
511
512     /**
513     * comptes en attente de confirmation
514     */
515     public static function confirm($id = -1)
516     { 
517          return self::state($id, 'confirm'); 
518     }
519
520     /**
521     * modifie la date de dernier envoi
522     */
523     public static function lastsent($id = -1, $_lastsent = null) 
524     {
525          // test sur la valeur de l'id qui doit être positive ou null
526          if ($id < 0) 
527               return null;
528          // modifie l'état des abonnés
529          else {
530               global $core;
531             try {
532                    $blog = &$core->blog;
533                    $con = &$core->con;
534                    $blogid = $con->escape((string)$blog->id);
535
536                // mise en forme du tableau d'id
537                if (is_array($id)) 
538                    $ids = implode(", ", $id);
539                else 
540                    $ids = $id;
541
542                // génération de la requète
543                if ($_lastsent == 'clear') 
544                    $req = 'UPDATE '.$core->prefix.newsletterPlugin::pname().' SET lastsent=subscribed';
545                else if ($_lastsent == null) 
546                    $req = 'UPDATE '.$core->prefix.newsletterPlugin::pname().' SET lastsent=now()';
547                else 
548                    $cur->lastsent = $con->escape(html::escapeHTML(html::clean($_lastsent)));
549               
550                $req .= ' WHERE blog_id=\''.$con->escape($blogid).'\' AND subscriber_id IN('.$ids.')';
551                $con->execute($req);
552                                   
553                    return true;
554             } catch (Exception $e) { 
555               $core->error->add($e->getMessage()); 
556             }
557          }
558     }
559
560     /**
561     * modifie le format de la lettre pour l'abonné
562     */
563     public static function changemode($id = -1, $_modesend = null)
564     {
565          // test sur la valeur de l'id qui doit être positive ou null
566          if ($id < 0) {
567               return null;
568          } else { 
569               // modifie le format de la lettre de l'abonné
570         
571               // filtrage sur le code de status
572               switch ($_modesend) {
573                    case 'html':
574                    case 'text':
575                         break;
576                    default:
577                         return false;
578               }
579
580               global $core;
581               try {
582                    $blog = &$core->blog;
583                    $con = &$core->con;
584                    $blogid = $con->escape((string)$blog->id);
585
586                    // mise en forme du tableau d'id
587                    if (is_array($id)) 
588                         $ids = implode(", ", $id);
589                    else 
590                         $ids = $id;
591
592                    // génération de la requète
593                    $cur = $con->openCursor($core->prefix.newsletterPlugin::pname());
594
595                    $cur->modesend = $con->escape(html::escapeHTML(html::clean($_modesend)));
596
597                    $cur->update('WHERE blog_id=\''.$con->escape($blogid).'\' AND subscriber_id IN('.$ids.')');
598                    return true;
599               } catch (Exception $e) { 
600                    $core->error->add($e->getMessage()); 
601               }
602          }
603     }
604     
605     /**
606     * change le format en html des comptes
607     */
608     public static function changemodehtml($id = -1)
609     { 
610          return self::changemode($id, 'html'); 
611     }
612
613     /**
614     * change le format en text des comptes
615     */
616     public static function changemodetext($id = -1)
617     { 
618          return self::changemode($id, 'text'); 
619     }
620
621     /* ==================================================
622          billets
623     ================================================== */
624
625     /**
626     * retourne les billets pour la newsletter:
627     */
628     public static function getPosts($dt=null)
629     {
630          global $core;
631          try  {
632         
633               $con = &$core->con;
634               $blog = &$core->blog;
635
636               // paramétrage de la récupération des billets
637               $params = array();
638
639               // sélection du contenu
640               $params['no_content'] = (newsletterPlugin::getViewContentPost() ? false : true); 
641               // sélection des billets
642               $params['post_type'] = 'post';
643               // uniquement les billets publiés, sans mot de passe
644               $params['post_status'] = 1;
645               // sans mot de passe
646               $params['sql'] = ' AND P.post_password IS NULL';
647               
648               // limitation du nombre de billets
649               $maxPost = newsletterPlugin::getMaxPosts();
650               if ($maxPost > 0) {
651                    $params['limit'] = $maxPost;
652               }
653
654               // définition du tris des enregistrements et filtrage dans le temps
655               // $params['order'] = ' P.post_id DESC, P.post_dt ASC';
656               $params['order'] = ' P.post_upddt ASC';
657               
658               // filtre sur la cartegorie
659               $category = newsletterPlugin::getCategory();
660               if ($category)
661               {
662                    if ($category == 'null') {
663                         $params['sql'] = ' AND P.cat_id IS NULL ';
664                    } elseif (is_numeric($category)) {
665                         $params['cat_id'] = (integer) $category;
666                    } else {
667                         $params['cat_url'] = $category;
668                    }
669               }
670
671               /*             
672               $year = dt::dt2str('%Y', $dt);
673               $month = dt::dt2str('%m', $dt);
674               $day = dt::dt2str('%d', $dt);
675               $hours = dt::dt2str('%H', $dt);
676               $minutes = dt::dt2str('%M', $dt);
677               $seconds = dt::dt2str('%S', $dt);
678
679               // depuis lastsent
680               $params['sql'] .= ' AND '.$con->dateFormat('P.post_dt','%Y-%m-%d %H:%M:%S')."> '$year-$month-$day $hours:$minutes:$seconds'";
681               */
682
683               // récupération des billets
684               $rs = $blog->getPosts($params, false);
685               
686               $minPosts = newsletterPlugin::getMinPosts();
687               if($rs->count() < $minPosts)
688                    return null;
689               else 
690                    return($rs->isEmpty()?null:$rs);
691
692          } catch (Exception $e) { 
693               $core->error->add($e->getMessage()); 
694          }
695     }
696
697     public static function getNewsletterPosts()
698     {
699          global $core;
700
701          // boucle sur les billets concernés pour l'abonnés
702          $bodies = array();
703          $posts = array();
704
705          $format = '';
706          if (!empty($attr['format'])) {
707               $format = addslashes($attr['format']);
708          }             
709     
710          $posts = self::getPosts();
711         
712          $posts->core = $core;
713          $posts->moveStart();
714          while ($posts->fetch())
715          {
716               //$p_ids[] = $posts->post_id;
717
718               // récupération des informations du billet
719               if(newsletterPlugin::getViewContentPost()) {
720                    $bodies[] = array(
721                         'title' => $posts->post_title,
722                         'url' => $posts->getURL(),
723                         'date' => $posts->getDate($format),
724                         'category' => $posts->getCategoryURL(),
725                         'content' => html::escapeHTML(newsletterTools::cutString(html::decodeEntities(html::clean($posts->getExcerpt().$posts->getContent())),newsletterPlugin::getSizeContentPost())),
726                         'author' => $posts->getAuthorCN(),
727                         'post_dt' => $posts->post_dt
728                         );
729               } else {
730                    $bodies[] = array(
731                         'title' => $posts->post_title,
732                         'url' => $posts->getURL(),
733                         'date' => $posts->getDate($format),
734                         'category' => $posts->getCategoryURL(),
735                         'content' => html::escapeHTML(''),
736                         'author' => $posts->getAuthorCN(),
737                         'post_dt' => $posts->post_dt
738                         );
739               }
740          }
741          return $bodies;
742     }
743
744     public static function getUserPosts($posts=array(),$dt=null)
745     {
746          $bodies = array();
747          foreach ($posts as $k => $v) {
748               if($dt < $v['post_dt']) {
749                    $bodies[] = $posts[$k];
750               }
751          }
752         
753          return $bodies;
754     }
755
756     /* ==================================================
757          emails
758     ================================================== */
759
760     /**
761     * renvoi l'url de base de newsletter
762     */
763     public static function url($cmd = '')
764     {
765          global $core;
766          try {
767               $url = &$core->url;
768               $blog = &$core->blog;
769               $blogurl = &$blog->url;
770
771               if ($cmd == '') 
772                    return http::concatURL($blogurl, $url->getBase('newsletter'));
773               else 
774                    return http::concatURL($blogurl, $url->getBase('newsletter')).'/'.$cmd;
775          } catch (Exception $e) { 
776               $core->error->add($e->getMessage()); 
777          }
778     }
779
780     /**
781     * préparation de l'envoi d'un mail à un abonné
782     */
783     private static function BeforeSendmailTo($header, $footer)
784     {
785          global $core;
786          try
787          {
788               $url = &$core->url;
789               $blog = &$core->blog;
790               $blogname = &$blog->name;
791               $blogdesc = &$blog->desc;
792               $blogurl = &$blog->url;
793               $urlBase = http::concatURL($blogurl, $url->getBase('newsletter'));
794
795               nlTemplate::clear();
796               nlTemplate::assign('header', $header);
797               nlTemplate::assign('footer', $footer);
798               nlTemplate::assign('blogName', $blogname);
799               nlTemplate::assign('blogDesc', $blogdesc);
800               nlTemplate::assign('blogUrl', $blogurl);
801               nlTemplate::assign('txtIntroductoryMsg', newsletterPlugin::getIntroductoryMsg());
802               nlTemplate::assign('txtMsgPresentationForm', newsletterPlugin::getMsgPresentationForm());
803               nlTemplate::assign('txtHeading', newsletterPlugin::getPresentationPostsMsg());
804               nlTemplate::assign('txt_intro_confirm', newsletterPlugin::getTxtIntroConfirm().', ');
805               nlTemplate::assign('txtConfirm', newsletterPlugin::getTxtConfirm());
806               nlTemplate::assign('txt_intro_disable', newsletterPlugin::getTxtIntroDisable().', ');
807               nlTemplate::assign('txtDisable', newsletterPlugin::getTxtDisable());
808               nlTemplate::assign('txt_intro_enable', newsletterPlugin::getTxtIntroEnable().', ');
809               nlTemplate::assign('txtEnable', newsletterPlugin::getTxtEnable());
810               nlTemplate::assign('txtChangingMode', newsletterPlugin::getChangeModeMsg());   
811
812               if(newsletterPlugin::getCheckUseSuspend()) {
813                    nlTemplate::assign('txt_intro_suspend', newsletterPlugin::getTxtIntroSuspend().', ');
814                    nlTemplate::assign('txtSuspend', newsletterPlugin::getTxtSuspend());
815                    nlTemplate::assign('txtSuspended', newsletterPlugin::getTxtSuspendedMsg());
816               } else {
817                    nlTemplate::assign('txt_intro_suspend', ' ');
818                    nlTemplate::assign('txtSuspend', ' ');
819                    nlTemplate::assign('txtSuspended', ' ');
820               }
821                             
822               nlTemplate::assign('txtDisabled',newsletterPlugin::getTxtDisabledMsg());
823               nlTemplate::assign('txtEnabled', newsletterPlugin::getTxtEnabledMsg());
824               nlTemplate::assign('txtBy', __(', by'));
825          }
826          catch (Exception $e) { $core->error->add($e->getMessage()); }
827     }
828
829
830
831     /**
832      * Prepare la liste des messages et declenche l'envoi de cette liste.
833      * Retourne les resultats des envois dans un string
834      *
835      * @param:     $id            array
836      * @param:     $action        string
837      *
838      * @return:    string
839      */
840     public static function send($id=-1,$action=null)
841     {
842          global $core;
843
844          $url = &$core->url;
845          $blog = &$core->blog;
846          $blogurl = &$blog->url;
847
848          $send = array();
849
850          try {
851               if (!newsletterPlugin::isActive()) {         // test si le plugin est actif
852                    return false;
853               } else if ($id == -1 || $action === null) {  // test sur la valeur de l'id qui doit être positive ou null
854                    return false;
855               } else {                                     // envoi des mails aux abonnés
856
857                    // prise en compte du paramètres: liste d'id ou id simple
858                    if (is_array($id)) {
859                         $ids = $id;
860                    } else { 
861                         $ids = array(); 
862                         $ids[] = $id; 
863                    }
864         
865                    $newsletter_mailing = new newsletterMailing($core);         
866
867                    // filtrage sur le type de mail
868                    switch ($action) {
869                         case 'newsletter':
870                              self::prepareMessagesNewsletter($ids,$newsletter_mailing);
871                              break;
872                         case 'confirm':
873                              self::prepareMessagesConfirm($ids,$newsletter_mailing);
874                              break;
875                         case 'suspend':
876                              self::prepareMessagesSuspend($ids,$newsletter_mailing);
877                              break;
878                         case 'enable':
879                              self::prepareMessagesEnable($ids,$newsletter_mailing);
880                              break;
881                         case 'disable':
882                              self::prepareMessagesDisable($ids,$newsletter_mailing);
883                              break;
884                         case 'resume':
885                              self::prepareMessagesResume($ids,$newsletter_mailing);
886                              break;
887                         case 'changemode':
888                              self::prepareMessagesChangeMode($ids,$newsletter_mailing);
889                              break;
890                         default:
891                              return false;
892                    }
893
894                    // Envoi des messages
895                    $newsletter_mailing->batchSend();
896                   
897                    $sent_states = $newsletter_mailing->getStates();
898                    $sent_success = $newsletter_mailing->getSuccess();
899                    $sent_errors = $newsletter_mailing->getErrors();
900                    $sent_nothing = $newsletter_mailing->getNothingToSend();
901                   
902                    if (is_array($sent_states) && count($sent_states) > 0) {
903                         // positionnement de l'état des comptes
904                         switch ($action) {
905                              case 'newsletter':
906                                   self::lastsent($sent_states);
907                                   break;
908                              case 'confirm':
909                                   self::confirm($sent_states);
910                                   break;
911                              case 'suspend': 
912                                   self::suspend($sent_states);
913                                   break;
914                              case 'enable': 
915                                   self::enable($sent_states);
916                                   break;
917                              case 'disable': 
918                                   self::disable($sent_states);
919                                   break;
920                              case 'resume':
921                                   break;
922                              case 'changemode':
923                                   break;
924                         }
925                    }         
926               
927                    $msg = '';
928                   
929                    if (isset($sent_success) && count($sent_success) > 0) 
930                         $msg .= __('Successful mail sent for').' '.implode(', ', $sent_success).'<br />';
931
932                    if (isset($sent_errors) && count($sent_errors) > 0) 
933                         $msg .= __('Mail sent error for').' '.implode(', ', $sent_errors).'<br />';
934
935                    if (isset($sent_nothing) &&count($sent_nothing) > 0) 
936                         $msg .= __('Nothing to send for').' '.implode(', ', $sent_nothing).'<br />';
937                   
938                    return $msg;
939               }
940          } catch (Exception $e) { 
941               $core->error->add($e->getMessage()); 
942          }
943     }
944
945     /**
946      * Prepare le contenu des messages de type newsletter
947      * Modifie l'objet newsletterMailing fourni en parametre
948      *
949      * @param:     $ids                     array
950      * @param:     $newsletter_mailing      newsletterMailing
951      *
952      * @return:    boolean
953      */
954     private static function prepareMessagesNewsletter($ids=-1,&$newsletter_mailing)
955     {
956          // initialisation des variables de travail
957          $mode = newsletterPlugin::getSendMode();
958          $subject = text::toUTF8(newsletterPlugin::getNewsletterSubject());
959          $minPosts = newsletterPlugin::getMinPosts();
960                   
961          // initialisation du moteur de template
962          self::BeforeSendmailTo(newsletterPlugin::getPresentationMsg(), newsletterPlugin::getConcludingMsg());
963                   
964          // recuperation des billets
965          $newsletter_posts = self::getNewsletterPosts();
966
967          // boucle sur les ids des abonnés
968          foreach ($ids as $subscriber_id)
969          {
970               // récupération de l'abonné et extraction des données
971               $subscriber = self::get($subscriber_id);
972
973               // récupération des billets en fonction de l'abonné (date de dernier envoi)
974               $user_posts = self::getUserPosts($newsletter_posts,$subscriber->lastsent);
975         
976               if(count($user_posts) < $minPosts) {
977                    $newsletter_mailing->addNothingToSend($subscriber_id,$subscriber->email);
978               } else {
979                    $body = '';
980                    /*$convert = new html2text();
981                    $convert->labelLinks = __('Links:');
982                    $convert->set_base_url($blogurl);*/
983                             
984                    // définition du format d'envoi
985                    if (!newsletterPlugin::getUseDefaultFormat() && $subscriber->modesend != null) {
986                         $mode = $subscriber->modesend;
987                    }
988                             
989                    // intégration dans le template des billets en génération du rendu
990                    if(newsletterPlugin::getCheckUseSuspend()) {
991                         nlTemplate::assign('urlSuspend', self::url('suspend/'.newsletterTools::base64_url_encode($subscriber->email)));
992                    } else {
993                         nlTemplate::assign('urlSuspend', ' ');
994                    }
995                    nlTemplate::assign('urlDisable', self::url('disable/'.newsletterTools::base64_url_encode($subscriber->email)));
996                    nlTemplate::assign('posts', $user_posts);
997
998                    $body = nlTemplate::render('newsletter', $mode);
999                             
1000                    if($mode == 'text') {
1001                         $convert = new html2text();
1002                         $convert->set_html($body);
1003                         $convert->labelLinks = __('Links:');
1004                         $body = $convert->get_text();
1005                    }
1006                             
1007                    // ajoute le message dans la liste d'envoi
1008                    $newsletter_mailing->addMessage($subscriber_id,$subscriber->email,$subject,$body,$mode);
1009               }
1010          }
1011          return true;
1012     }
1013
1014     /**
1015      * Prepare le contenu des messages de type confirm
1016      * Modifie l'objet newsletterMailing fourni en parametre
1017      *
1018      * @param:     $ids                     array
1019      * @param:     $newsletter_mailing      newsletterMailing
1020      *
1021      * @return:    boolean
1022      */
1023     private static function prepareMessagesConfirm($ids=-1,&$newsletter_mailing)
1024     {
1025          // initialisation des variables de travail
1026          $mode = newsletterPlugin::getSendMode();
1027          $subject = text::toUTF8(newsletterPlugin::getConfirmSubject());
1028
1029          // initialisation du moteur de template
1030          self::BeforeSendmailTo(newsletterPlugin::getConfirmMsg(),newsletterPlugin::getConcludingConfirmMsg());
1031         
1032          // boucle sur les ids des abonnés
1033          foreach ($ids as $subscriber_id)
1034          {
1035               $body = '';
1036               // récupération de l'abonné et extraction des données
1037               $subscriber = self::get($subscriber_id);
1038
1039               // définition du format d'envoi
1040               if (!newsletterPlugin::getUseDefaultFormat() && $subscriber->modesend != null) {
1041                    $mode = $subscriber->modesend;
1042               }
1043
1044               // génération du rendu
1045               nlTemplate::assign('urlConfirm', self::url('confirm/'.newsletterTools::base64_url_encode($subscriber->email).'/'.$subscriber->regcode.'/'.newsletterTools::base64_url_encode($subscriber->modesend)));
1046               nlTemplate::assign('urlDisable', self::url('disable/'.newsletterTools::base64_url_encode($subscriber->email)));
1047
1048               $body = nlTemplate::render('confirm', $mode);
1049
1050               if($mode == 'text') {
1051                    $convert = new html2text();
1052                    $convert->set_html($body);
1053                    $convert->labelLinks = __('Links:');
1054                    $body = $convert->get_text();
1055               }
1056
1057               // ajoute le message dans la liste d'envoi
1058               $newsletter_mailing->addMessage($subscriber_id,$subscriber->email,$subject,$body,$mode);
1059          }
1060          return true;
1061     }
1062
1063     /**
1064      * Prepare le contenu des messages de type suspend
1065      * Modifie l'objet newsletterMailing fourni en parametre
1066      *
1067      * @param:     $ids                     array
1068      * @param:     $newsletter_mailing      newsletterMailing
1069      *
1070      * @return:    boolean
1071      */
1072     private static function prepareMessagesSuspend($ids=-1,&$newsletter_mailing)
1073     {
1074          // initialisation des variables de travail
1075          $mode = newsletterPlugin::getSendMode();
1076          $subject = text::toUTF8(newsletterPlugin::getSuspendSubject());
1077
1078          // initialisation du moteur de template
1079          self::BeforeSendmailTo(newsletterPlugin::getSuspendMsg(),newsletterPlugin::getConcludingSuspendMsg());
1080
1081          // boucle sur les ids des abonnés
1082          foreach ($ids as $subscriber_id)
1083          {
1084               // récupération de l'abonné et extraction des données
1085               $subscriber = self::get($subscriber_id);
1086
1087               // définition du format d'envoi
1088               if (!newsletterPlugin::getUseDefaultFormat() && $subscriber->modesend != null) {
1089                    $mode = $subscriber->modesend;
1090               }
1091
1092               // génération du rendu
1093               nlTemplate::assign('urlEnable', self::url('enable/'.newsletterTools::base64_url_encode($subscriber->email)));
1094
1095               $body = nlTemplate::render('suspend', $mode);
1096               
1097               if($mode == 'text') {
1098                    $convert = new html2text();
1099                    $convert->set_html($body);
1100                    $convert->labelLinks = __('Links:');
1101                    $body = $convert->get_text();
1102               }
1103
1104               // ajoute le message dans la liste d'envoi
1105               $newsletter_mailing->addMessage($subscriber_id,$subscriber->email,$subject,$body,$mode);
1106          }
1107          return true;
1108     }
1109
1110     /**
1111      * Prepare le contenu des messages de type enable
1112      * Modifie l'objet newsletterMailing fourni en parametre
1113      *
1114      * @param:     $ids                     array
1115      * @param:     $newsletter_mailing      newsletterMailing
1116      *
1117      * @return:    boolean
1118      */
1119     private static function prepareMessagesEnable($ids=-1,&$newsletter_mailing)
1120     {
1121          // initialisation des variables de travail
1122          $mode = newsletterPlugin::getSendMode();
1123          $subject = text::toUTF8(newsletterPlugin::getEnableSubject());
1124
1125          // initialisation du moteur de template
1126          self::BeforeSendmailTo(newsletterPlugin::getEnableMsg(),newsletterPlugin::getConcludingEnableMsg());
1127
1128          // boucle sur les ids des abonnés
1129          foreach ($ids as $subscriber_id)
1130          {
1131               // récupération de l'abonné et extraction des données
1132               $subscriber = self::get($subscriber_id);
1133
1134               // définition du format d'envoi
1135               if (!newsletterPlugin::getUseDefaultFormat() && $subscriber->modesend != null) {
1136                    $mode = $subscriber->modesend;
1137               }
1138
1139               // génération du rendu
1140               nlTemplate::assign('urlDisable', self::url('disable/'.newsletterTools::base64_url_encode($subscriber->email)));
1141                    if(newsletterPlugin::getCheckUseSuspend()) {
1142                         nlTemplate::assign('urlSuspend', self::url('suspend/'.newsletterTools::base64_url_encode($subscriber->email)));
1143                    } else {
1144                         nlTemplate::assign('urlSuspend', ' ');
1145                    }
1146
1147               $body = nlTemplate::render('enable', $mode);
1148
1149               if($mode == 'text') {
1150                    $convert = new html2text();
1151                    $convert->set_html($body);
1152                    $convert->labelLinks = __('Links:');
1153                    $body = $convert->get_text();
1154               }
1155         
1156               // ajoute le message dans la liste d'envoi
1157               $newsletter_mailing->addMessage($subscriber_id,$subscriber->email,$subject,$body,$mode);
1158          }
1159          return true;
1160     }
1161
1162     /**
1163      * Prepare le contenu des messages de type disable
1164      * Modifie l'objet newsletterMailing fourni en parametre
1165      *
1166      * @param:     $ids                     array
1167      * @param:     $newsletter_mailing      newsletterMailing
1168      *
1169      * @return:    boolean
1170      */
1171     private static function prepareMessagesDisable($ids=-1,&$newsletter_mailing)
1172     {
1173          // initialisation des variables de travail
1174          $mode = newsletterPlugin::getSendMode();
1175          $subject = text::toUTF8(newsletterPlugin::getDisableSubject());
1176
1177          // initialisation du moteur de template
1178          self::BeforeSendmailTo(newsletterPlugin::getDisableMsg(),newsletterPlugin::getConcludingDisableMsg());
1179
1180          // boucle sur les ids des abonnés
1181          foreach ($ids as $subscriber_id)
1182          {
1183               // récupération de l'abonné et extraction des données
1184               $subscriber = self::get($subscriber_id);
1185
1186               // définition du format d'envoi
1187               if (!newsletterPlugin::getUseDefaultFormat() && $subscriber->modesend != null) {
1188                    $mode = $subscriber->modesend;
1189               }
1190
1191               // génération du rendu
1192               nlTemplate::assign('urlEnable', self::url('enable/'.newsletterTools::base64_url_encode($subscriber->email)));
1193
1194               $body = nlTemplate::render('disable', $mode);
1195
1196               if($mode == 'text') {
1197                    $convert = new html2text();
1198                    $convert->set_html($body);
1199                    $convert->labelLinks = __('Links:');
1200                    $body = $convert->get_text();
1201               }
1202         
1203               // ajoute le message dans la liste d'envoi
1204               $newsletter_mailing->addMessage($subscriber_id,$subscriber->email,$subject,$body,$mode);
1205          }
1206          return true;
1207     }
1208
1209     /**
1210      * Prepare le contenu des messages de type resume
1211      * Modifie l'objet newsletterMailing fourni en parametre
1212      *
1213      * @param:     $ids                     array
1214      * @param:     $newsletter_mailing      newsletterMailing
1215      *
1216      * @return:    boolean
1217      */
1218     private static function prepareMessagesResume($ids=-1,&$newsletter_mailing)
1219     {
1220          // initialisation des variables de travail
1221          $mode = newsletterPlugin::getSendMode();
1222          $subject = text::toUTF8(newsletterPlugin::getResumeSubject());
1223
1224          // initialisation du moteur de template
1225          self::BeforeSendmailTo(newsletterPlugin::getHeaderResumeMsg(),newsletterPlugin::getFooterResumeMsg());
1226
1227          // boucle sur les ids des abonnés
1228          foreach ($ids as $subscriber_id)
1229          {
1230               // récupération de l'abonné et extraction des données
1231               $subscriber = self::get($subscriber_id);
1232
1233               $txt_intro_enable = newsletterPlugin::getTxtIntroEnable().', ';
1234               $urlEnable = self::url('enable/'.newsletterTools::base64_url_encode($subscriber->email));
1235               $txtEnable = newsletterPlugin::getTxtEnable();
1236                         
1237               $txt_intro_disable = newsletterPlugin::getTxtIntroDisable().', ';
1238               $urlDisable = self::url('disable/'.newsletterTools::base64_url_encode($subscriber->email));
1239               $txtDisable = newsletterPlugin::getTxtDisable();
1240
1241               $txt_intro_suspend = newsletterPlugin::getTxtIntroSuspend().', ';
1242               $urlSuspend = self::url('suspend/'.newsletterTools::base64_url_encode($subscriber->email));
1243               $txtSuspend = newsletterPlugin::getTxtSuspend();
1244                         
1245               $txt_intro_confirm = newsletterPlugin::getTxtIntroConfirm().', ';
1246               $urlConfirm = self::url('confirm/'.newsletterTools::base64_url_encode($subscriber->email).'/'.$subscriber->regcode.'/'.newsletterTools::base64_url_encode($subscriber->modesend));
1247               $txtConfirm = newsletterPlugin::getTxtConfirm();
1248               
1249               $urlResume = '';
1250                         
1251               switch ($subscriber->state) {
1252                    case 'suspended':
1253                    {
1254                         $urlResume = $txt_intro_enable.' <a href="'.$urlEnable.'">'.$txtEnable.'</a><br />';
1255                         $urlResume .= $txt_intro_disable.' <a href="'.$urlDisable.'">'.$txtDisable.'</a>';
1256                         nlTemplate::assign('txtResume', __('Your account is suspended.'));
1257                         break;
1258                    }
1259                    case 'disabled':
1260                    {
1261                         $urlResume = $txt_intro_enable.' <a href="'.$urlEnable.'">'.$txtEnable.'</a><br />';
1262                         if(newsletterPlugin::getCheckUseSuspend()) {
1263                              $urlResume .= $txt_intro_suspend.' <a href="'.$urlSuspend.'">'.$txtSuspend.'</a>';
1264                         }
1265                         nlTemplate::assign('txtResume', __('Your account is disabled.'));
1266                         break;
1267                    }
1268                    case 'enabled':
1269                    {
1270                         $urlResume = $txt_intro_disable.' <a href="'.$urlDisable.'">'.$txtDisable.'</a><br />';
1271                         if(newsletterPlugin::getCheckUseSuspend()) {
1272                              $urlResume .= $txt_intro_suspend.' <a href="'.$urlSuspend.'">'.$txtSuspend.'</a>';
1273                         }
1274                         nlTemplate::assign('txtResume', __('Your account is enabled.'));
1275                         break;
1276                    }
1277                    case 'pending':
1278                    {
1279                         $urlResume = $txt_intro_disable.' <a href="'.$urlDisable.'">'.$txtDisable.'</a><br />';
1280                         $urlResume .= $txt_intro_confirm.' <a href="'.$urlConfirm.'">'.$txtConfirm.'</a>';
1281                         nlTemplate::assign('txtResume', __('Your account is pending confirmation.'));
1282                         break;
1283                    }
1284                    default:
1285                    {
1286                    }
1287               }
1288 
1289               // définition du format d'envoi
1290               if (!newsletterPlugin::getUseDefaultFormat() && $subscriber->modesend != null) {
1291                    $mode = $subscriber->modesend;
1292               }
1293
1294               nlTemplate::assign('txtMode', __('Your sending mode is'). ' ' .__(''.$mode.''). '.');
1295               nlTemplate::assign('urlResume', $urlResume);
1296               $body = nlTemplate::render('resume', $mode);
1297
1298               if($mode == 'text') {
1299                    $convert = new html2text();
1300                    $convert->set_html($body);
1301                    $convert->labelLinks = __('Links:');
1302                    $body = $convert->get_text();
1303               }
1304
1305               // ajoute le message dans la liste d'envoi
1306               $newsletter_mailing->addMessage($subscriber_id,$subscriber->email,$subject,$body,$mode);
1307          }
1308          return true;
1309     }
1310
1311     /**
1312      * Prepare le contenu des messages de type changemode
1313      * Modifie l'objet newsletterMailing fourni en parametre
1314      *
1315      * @param:     $ids                     array
1316      * @param:     $newsletter_mailing      newsletterMailing
1317      *
1318      * @return:    boolean
1319      */
1320     private static function prepareMessagesChangeMode($ids=-1,&$newsletter_mailing)
1321     {
1322          // initialisation des variables de travail
1323          $mode = newsletterPlugin::getSendMode();
1324          $subject = text::toUTF8(newsletterPlugin::getChangeModeSubject());
1325
1326          // initialisation du moteur de template
1327          self::BeforeSendmailTo(newsletterPlugin::getHeaderChangeModeMsg(),newsletterPlugin::getFooterChangeModeMsg());         
1328
1329          // boucle sur les ids des abonnés
1330          foreach ($ids as $subscriber_id)
1331          {
1332               // récupération de l'abonné et extraction des données
1333               $subscriber = self::get($subscriber_id);
1334
1335               // définition du format d'envoi
1336               if (!newsletterPlugin::getUseDefaultFormat() && $subscriber->modesend != null) {
1337                    $mode = $subscriber->modesend;
1338               }                       
1339                         
1340               // génération du rendu
1341               nlTemplate::assign('urlEnable', self::url('enable/'.newsletterTools::base64_url_encode($subscriber->email)));
1342
1343               $body = nlTemplate::render('changemode', $mode);
1344
1345               if($mode == 'text') {
1346                    $convert = new html2text();
1347                    $convert->set_html($body);
1348                    $convert->labelLinks = __('Links:');
1349                    $body = $convert->get_text();
1350               }
1351
1352               // ajoute le message dans la liste d'envoi
1353               $newsletter_mailing->addMessage($subscriber_id,$subscriber->email,$subject,$body,$mode);
1354          }
1355          return true;
1356     }
1357
1358     /**
1359      * Envoi automatique de la newsletter pour tous les abonnés actifs
1360      *
1361      * @return:    boolean
1362      */
1363     public static function autosendNewsletter()
1364     {
1365          // test si le plugin est actif
1366          if (!newsletterPlugin::isActive()) {
1367               return;
1368          }
1369
1370          // test si l'envoi automatique est activé
1371          if (!newsletterPlugin::getAutosend()) {
1372               return;
1373          } else {
1374               $datas = self::getlist(true);
1375               if (!is_object($datas)) {
1376                    return;
1377               } else {
1378                    $ids = array();
1379                    $datas->moveStart();
1380                    while ($datas->fetch()) { 
1381                         $ids[] = $datas->subscriber_id;
1382                    }
1383                    self::send($ids,'newsletter');
1384               }             
1385          }   
1386     }
1387
1388     /**
1389      * Envoi par tâche planifiée de la newsletter pour tous les abonnés actifs
1390      *
1391      * @return:    boolean
1392      */
1393     public static function cronSendNewsletter()
1394     {
1395          // test si le plugin est actif
1396          if (!newsletterPlugin::isActive()) {
1397               return;
1398          }
1399         
1400          // test si la planification est activée
1401          if (!newsletterPlugin::getCheckSchedule()) {
1402               return;
1403          } else {
1404               $datas = self::getlist(true);
1405               if (!is_object($datas)) {
1406                    return;
1407               } else {
1408                    $ids = array();
1409                    $datas->moveStart();
1410                    while ($datas->fetch()) { 
1411                         $ids[] = $datas->subscriber_id;
1412                    }
1413                    self::send($ids,'newsletter');
1414               }
1415          }
1416     }
1417
1418     /* ==================================================
1419          gestion des comptes
1420     ================================================== */
1421
1422     /**
1423     * création du compte
1424     */
1425     public static function accountCreate($email = null, $regcode = null, $modesend = null)
1426     {
1427          global $core;
1428          try {         
1429               if ($email == null) {              // l'email doit être renseigné
1430                    return __('Bad email !');
1431               } else {                           // création du compte
1432                    if (self::getemail($email) != null) {
1433                         return __('Email already exist !');
1434                    } else if (!self::add($email, null, null, $modesend)) {
1435                         return __('Error creating account !');
1436                    } else {
1437                         $subscriber = self::getemail($email);
1438                         $msg = self::send($subscriber->subscriber_id,'confirm');
1439                         return $msg;
1440                    }
1441               }
1442          } catch (Exception $e) { 
1443               $core->error->add($e->getMessage()); 
1444          }
1445     }
1446
1447     /**
1448     * suppression du compte
1449     */
1450     public static function accountDelete($email = null)
1451     {
1452          global $core;
1453          try {         
1454               if ($email == null) {              // l'email doit être renseigné
1455                    return __('Bad email !');
1456               } else {                           // suppression du compte
1457                    $subscriber = self::getemail($email);
1458                    $msg = null;
1459                    if (!$subscriber || $subscriber->subscriber_id == null) 
1460                         return __('Email don\'t exist !');
1461                    else {
1462                         $msg = self::send($subscriber->subscriber_id,'disable');
1463                         self::delete($subscriber->subscriber_id);
1464                         return $msg;
1465                    }
1466               }
1467          } catch (Exception $e) { 
1468               $core->error->add($e->getMessage()); 
1469          }
1470     }
1471
1472     /**
1473     * suspension du compte
1474     */
1475     static function accountSuspend($email = null)
1476     {
1477          global $core;
1478          try {
1479
1480               if ($email == null) {              // l'email doit être renseigné
1481                    return __('Bad email !');
1482               } else {                           // suspension du compte
1483                    $subscriber = self::getemail($email);
1484                    $msg = '';
1485                    if (!$subscriber || $subscriber->subscriber_id == null) 
1486                         return __('Email don\'t exist !');
1487                    else {
1488                         $msg = self::send($subscriber->subscriber_id,'suspend');                       
1489                         self::suspend($subscriber->subscriber_id);
1490                         return $msg;
1491                    }
1492               }
1493          } catch (Exception $e) { 
1494               $core->error->add($e->getMessage()); 
1495          }
1496     }
1497
1498     /**
1499     * information sur le compte
1500     */
1501     public static function accountResume($email = null)
1502     {
1503          global $core;
1504          try {         
1505               if ($email == null) {              // l'email doit être renseigné
1506                    return __('Bad email !');
1507               } else {                           // information sur le compte
1508                    $subscriber = self::getemail($email);
1509                    $msg = '';
1510                    if (!$subscriber || $subscriber->subscriber_id == null) 
1511                         return __('Email don\'t exist !');
1512                    else {
1513                         $msg = self::send($subscriber->subscriber_id,'resume');                         
1514                         //self::resume($subscriber->subscriber_id);
1515                         return $msg;
1516                    }
1517               }
1518          } catch (Exception $e) { 
1519               $core->error->add($e->getMessage()); 
1520          }         
1521     }
1522
1523     /**
1524     * changement du format sur le compte
1525     */
1526     public static function accountChangeMode($email = null, $modesend = null)
1527     {
1528          global $core;
1529          try {
1530               if ($email == null) {              // l'email doit être renseigné
1531                    return __('Bad email !');
1532               } else {                           // information sur le compte
1533                    $subscriber = self::getemail($email);
1534                    $msg = '';
1535                    if (!$subscriber || $subscriber->subscriber_id == null) 
1536                         return __('Email don\'t exist !');
1537                    else {
1538                         $msg = self::send($subscriber->subscriber_id,'changemode');                     
1539                         self::changeMode($subscriber->subscriber_id, $modesend);
1540                         return $msg;
1541                    }
1542               }
1543          } catch (Exception $e) { 
1544               $core->error->add($e->getMessage()); 
1545          }
1546     }
1547
1548}
1549
1550?>
Note: See TracBrowser for help on using the repository browser.

Sites map