Dotclear

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

Revision 1442, 42.2 KB checked in by kwon, 14 years ago (diff)

newsletter : closes #224 + ajout des extraits (GaD)
  • 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               
657               // filtre sur la cartegorie
658               $category = newsletterPlugin::getCategory();
659               if ($category)
660               {
661                    if ($category == 'null') {
662                         $params['sql'] = ' AND P.cat_id IS NULL ';
663                    } elseif (is_numeric($category)) {
664                         $params['cat_id'] = (integer) $category;
665                    } else {
666                         $params['cat_url'] = $category;
667                    }
668               }
669
670               /*             
671               $year = dt::dt2str('%Y', $dt);
672               $month = dt::dt2str('%m', $dt);
673               $day = dt::dt2str('%d', $dt);
674               $hours = dt::dt2str('%H', $dt);
675               $minutes = dt::dt2str('%M', $dt);
676               $seconds = dt::dt2str('%S', $dt);
677
678               // depuis lastsent
679               $params['sql'] .= ' AND '.$con->dateFormat('P.post_dt','%Y-%m-%d %H:%M:%S')."> '$year-$month-$day $hours:$minutes:$seconds'";
680               */
681
682               // récupération des billets
683               $rs = $blog->getPosts($params, false);
684               
685               $minPosts = newsletterPlugin::getMinPosts();
686               if($rs->count() < $minPosts)
687                    return null;
688               else 
689                    return($rs->isEmpty()?null:$rs);
690
691          } catch (Exception $e) { 
692               $core->error->add($e->getMessage()); 
693          }
694     }
695
696     public static function getNewsletterPosts()
697     {
698          global $core;
699
700          // boucle sur les billets concernés pour l'abonnés
701          $bodies = array();
702          $posts = array();
703
704          $format = '';
705          if (!empty($attr['format'])) {
706               $format = addslashes($attr['format']);
707          }             
708     
709          $posts = self::getPosts();
710         
711          $posts->core = $core;
712          $posts->moveStart();
713          while ($posts->fetch())
714          {
715               //$p_ids[] = $posts->post_id;
716
717               // récupération des informations du billet
718               if(newsletterPlugin::getViewContentPost()) {
719                    $bodies[] = array(
720                         'title' => $posts->post_title,
721                         'url' => $posts->getURL(),
722                         'date' => $posts->getDate($format),
723                         'category' => $posts->getCategoryURL(),
724                         'content' => html::escapeHTML(newsletterTools::cutString(html::decodeEntities(html::clean($posts->getExcerpt().$posts->getContent())),newsletterPlugin::getSizeContentPost())),
725                         'author' => $posts->getAuthorCN(),
726                         'post_dt' => $posts->post_dt
727                         );
728               } else {
729                    $bodies[] = array(
730                         'title' => $posts->post_title,
731                         'url' => $posts->getURL(),
732                         'date' => $posts->getDate($format),
733                         'category' => $posts->getCategoryURL(),
734                         'content' => html::escapeHTML(''),
735                         'author' => $posts->getAuthorCN(),
736                         'post_dt' => $posts->post_dt
737                         );
738               }
739          }
740          return $bodies;
741     }
742
743     public static function getUserPosts($posts=array(),$dt=null)
744     {
745          $bodies = array();
746          foreach ($posts as $k => $v) {
747               if($dt < $v['post_dt']) {
748                    $bodies[] = $posts[$k];
749               }
750          }
751         
752          return $bodies;
753     }
754
755     /* ==================================================
756          emails
757     ================================================== */
758
759     /**
760     * renvoi l'url de base de newsletter
761     */
762     public static function url($cmd = '')
763     {
764          global $core;
765          try {
766               $url = &$core->url;
767               $blog = &$core->blog;
768               $blogurl = &$blog->url;
769
770               if ($cmd == '') 
771                    return http::concatURL($blogurl, $url->getBase('newsletter'));
772               else 
773                    return http::concatURL($blogurl, $url->getBase('newsletter')).'/'.$cmd;
774          } catch (Exception $e) { 
775               $core->error->add($e->getMessage()); 
776          }
777     }
778
779     /**
780     * préparation de l'envoi d'un mail à un abonné
781     */
782     private static function BeforeSendmailTo($header, $footer)
783     {
784          global $core;
785          try
786          {
787               $url = &$core->url;
788               $blog = &$core->blog;
789               $blogname = &$blog->name;
790               $blogdesc = &$blog->desc;
791               $blogurl = &$blog->url;
792               $urlBase = http::concatURL($blogurl, $url->getBase('newsletter'));
793
794               nlTemplate::clear();
795               nlTemplate::assign('header', $header);
796               nlTemplate::assign('footer', $footer);
797               nlTemplate::assign('blogName', $blogname);
798               nlTemplate::assign('blogDesc', $blogdesc);
799               nlTemplate::assign('blogUrl', $blogurl);
800               nlTemplate::assign('txtIntroductoryMsg', newsletterPlugin::getIntroductoryMsg());
801               nlTemplate::assign('txtMsgPresentationForm', newsletterPlugin::getMsgPresentationForm());
802               nlTemplate::assign('txtHeading', newsletterPlugin::getPresentationPostsMsg());
803               nlTemplate::assign('txt_intro_confirm', newsletterPlugin::getTxtIntroConfirm().', ');
804               nlTemplate::assign('txtConfirm', newsletterPlugin::getTxtConfirm());
805               nlTemplate::assign('txt_intro_disable', newsletterPlugin::getTxtIntroDisable().', ');
806               nlTemplate::assign('txtDisable', newsletterPlugin::getTxtDisable());
807               nlTemplate::assign('txt_intro_enable', newsletterPlugin::getTxtIntroEnable().', ');
808               nlTemplate::assign('txtEnable', newsletterPlugin::getTxtEnable());
809               nlTemplate::assign('txtChangingMode', newsletterPlugin::getChangeModeMsg());   
810
811               if(newsletterPlugin::getCheckUseSuspend()) {
812                    nlTemplate::assign('txt_intro_suspend', newsletterPlugin::getTxtIntroSuspend().', ');
813                    nlTemplate::assign('txtSuspend', newsletterPlugin::getTxtSuspend());
814                    nlTemplate::assign('txtSuspended', newsletterPlugin::getTxtSuspendedMsg());
815               } else {
816                    nlTemplate::assign('txt_intro_suspend', ' ');
817                    nlTemplate::assign('txtSuspend', ' ');
818                    nlTemplate::assign('txtSuspended', ' ');
819               }
820                             
821               nlTemplate::assign('txtDisabled',newsletterPlugin::getTxtDisabledMsg());
822               nlTemplate::assign('txtEnabled', newsletterPlugin::getTxtEnabledMsg());
823               nlTemplate::assign('txtBy', __(', by'));
824          }
825          catch (Exception $e) { $core->error->add($e->getMessage()); }
826     }
827
828
829
830     /**
831      * Prepare la liste des messages et declenche l'envoi de cette liste.
832      * Retourne les resultats des envois dans un string
833      *
834      * @param:     $id            array
835      * @param:     $action        string
836      *
837      * @return:    string
838      */
839     public static function send($id=-1,$action=null)
840     {
841          global $core;
842
843          $url = &$core->url;
844          $blog = &$core->blog;
845          $blogurl = &$blog->url;
846
847          $send = array();
848
849          try {
850               if (!newsletterPlugin::isActive()) {         // test si le plugin est actif
851                    return false;
852               } else if ($id == -1 || $action === null) {  // test sur la valeur de l'id qui doit être positive ou null
853                    return false;
854               } else {                                     // envoi des mails aux abonnés
855
856                    // prise en compte du paramètres: liste d'id ou id simple
857                    if (is_array($id)) {
858                         $ids = $id;
859                    } else { 
860                         $ids = array(); 
861                         $ids[] = $id; 
862                    }
863         
864                    $newsletter_mailing = new newsletterMailing($core);         
865
866                    // filtrage sur le type de mail
867                    switch ($action) {
868                         case 'newsletter':
869                              self::prepareMessagesNewsletter($ids,$newsletter_mailing);
870                              break;
871                         case 'confirm':
872                              self::prepareMessagesConfirm($ids,$newsletter_mailing);
873                              break;
874                         case 'suspend':
875                              self::prepareMessagesSuspend($ids,$newsletter_mailing);
876                              break;
877                         case 'enable':
878                              self::prepareMessagesEnable($ids,$newsletter_mailing);
879                              break;
880                         case 'disable':
881                              self::prepareMessagesDisable($ids,$newsletter_mailing);
882                              break;
883                         case 'resume':
884                              self::prepareMessagesResume($ids,$newsletter_mailing);
885                              break;
886                         case 'changemode':
887                              self::prepareMessagesChangeMode($ids,$newsletter_mailing);
888                              break;
889                         default:
890                              return false;
891                    }
892
893                    // Envoi des messages
894                    $newsletter_mailing->batchSend();
895                   
896                    $sent_states = $newsletter_mailing->getStates();
897                    $sent_success = $newsletter_mailing->getSuccess();
898                    $sent_errors = $newsletter_mailing->getErrors();
899                    $sent_nothing = $newsletter_mailing->getNothingToSend();
900                   
901                    if (is_array($sent_states) && count($sent_states) > 0) {
902                         // positionnement de l'état des comptes
903                         switch ($action) {
904                              case 'newsletter':
905                                   self::lastsent($sent_states);
906                                   break;
907                              case 'confirm':
908                                   self::confirm($sent_states);
909                                   break;
910                              case 'suspend': 
911                                   self::suspend($sent_states);
912                                   break;
913                              case 'enable': 
914                                   self::enable($sent_states);
915                                   break;
916                              case 'disable': 
917                                   self::disable($sent_states);
918                                   break;
919                              case 'resume':
920                                   break;
921                              case 'changemode':
922                                   break;
923                         }
924                    }         
925               
926                    $msg = '';
927                   
928                    if (isset($sent_success) && count($sent_success) > 0) 
929                         $msg .= __('Successful mail sent for').' '.implode(', ', $sent_success).'<br />';
930
931                    if (isset($sent_errors) && count($sent_errors) > 0) 
932                         $msg .= __('Mail sent error for').' '.implode(', ', $sent_errors).'<br />';
933
934                    if (isset($sent_nothing) &&count($sent_nothing) > 0) 
935                         $msg .= __('Nothing to send for').' '.implode(', ', $sent_nothing).'<br />';
936                   
937                    return $msg;
938               }
939          } catch (Exception $e) { 
940               $core->error->add($e->getMessage()); 
941          }
942     }
943
944     /**
945      * Prepare le contenu des messages de type newsletter
946      * Modifie l'objet newsletterMailing fourni en parametre
947      *
948      * @param:     $ids                     array
949      * @param:     $newsletter_mailing      newsletterMailing
950      *
951      * @return:    boolean
952      */
953     private static function prepareMessagesNewsletter($ids=-1,&$newsletter_mailing)
954     {
955          // initialisation des variables de travail
956          $mode = newsletterPlugin::getSendMode();
957          $subject = text::toUTF8(newsletterPlugin::getNewsletterSubject());
958          $minPosts = newsletterPlugin::getMinPosts();
959                   
960          // initialisation du moteur de template
961          self::BeforeSendmailTo(newsletterPlugin::getPresentationMsg(), newsletterPlugin::getConcludingMsg());
962                   
963          // recuperation des billets
964          $newsletter_posts = self::getNewsletterPosts();
965
966          // boucle sur les ids des abonnés
967          foreach ($ids as $subscriber_id)
968          {
969               // récupération de l'abonné et extraction des données
970               $subscriber = self::get($subscriber_id);
971
972               // récupération des billets en fonction de l'abonné (date de dernier envoi)
973               $user_posts = self::getUserPosts($newsletter_posts,$subscriber->lastsent);
974         
975               if(count($user_posts) < $minPosts) {
976                    $newsletter_mailing->addNothingToSend($subscriber_id,$subscriber->email);
977               } else {
978                    $body = '';
979                    /*$convert = new html2text();
980                    $convert->labelLinks = __('Links:');
981                    $convert->set_base_url($blogurl);*/
982                             
983                    // définition du format d'envoi
984                    if (!newsletterPlugin::getUseDefaultFormat() && $subscriber->modesend != null) {
985                         $mode = $subscriber->modesend;
986                    }
987                             
988                    // intégration dans le template des billets en génération du rendu
989                    if(newsletterPlugin::getCheckUseSuspend()) {
990                         nlTemplate::assign('urlSuspend', self::url('suspend/'.newsletterTools::base64_url_encode($subscriber->email)));
991                    } else {
992                         nlTemplate::assign('urlSuspend', ' ');
993                    }
994                    nlTemplate::assign('urlDisable', self::url('disable/'.newsletterTools::base64_url_encode($subscriber->email)));
995                    nlTemplate::assign('posts', $user_posts);
996
997                    $body = nlTemplate::render('newsletter', $mode);
998                             
999                    if($mode == 'text') {
1000                         $convert = new html2text();
1001                         $convert->set_html($body);
1002                         $convert->labelLinks = __('Links:');
1003                         $body = $convert->get_text();
1004                    }
1005                             
1006                    // ajoute le message dans la liste d'envoi
1007                    $newsletter_mailing->addMessage($subscriber_id,$subscriber->email,$subject,$body,$mode);
1008               }
1009          }
1010          return true;
1011     }
1012
1013     /**
1014      * Prepare le contenu des messages de type confirm
1015      * Modifie l'objet newsletterMailing fourni en parametre
1016      *
1017      * @param:     $ids                     array
1018      * @param:     $newsletter_mailing      newsletterMailing
1019      *
1020      * @return:    boolean
1021      */
1022     private static function prepareMessagesConfirm($ids=-1,&$newsletter_mailing)
1023     {
1024          // initialisation des variables de travail
1025          $mode = newsletterPlugin::getSendMode();
1026          $subject = text::toUTF8(newsletterPlugin::getConfirmSubject());
1027
1028          // initialisation du moteur de template
1029          self::BeforeSendmailTo(newsletterPlugin::getConfirmMsg(),newsletterPlugin::getConcludingConfirmMsg());
1030         
1031          // boucle sur les ids des abonnés
1032          foreach ($ids as $subscriber_id)
1033          {
1034               $body = '';
1035               // récupération de l'abonné et extraction des données
1036               $subscriber = self::get($subscriber_id);
1037
1038               // définition du format d'envoi
1039               if (!newsletterPlugin::getUseDefaultFormat() && $subscriber->modesend != null) {
1040                    $mode = $subscriber->modesend;
1041               }
1042
1043               // génération du rendu
1044               nlTemplate::assign('urlConfirm', self::url('confirm/'.newsletterTools::base64_url_encode($subscriber->email).'/'.$subscriber->regcode.'/'.newsletterTools::base64_url_encode($subscriber->modesend)));
1045               nlTemplate::assign('urlDisable', self::url('disable/'.newsletterTools::base64_url_encode($subscriber->email)));
1046
1047               $body = nlTemplate::render('confirm', $mode);
1048
1049               if($mode == 'text') {
1050                    $convert = new html2text();
1051                    $convert->set_html($body);
1052                    $convert->labelLinks = __('Links:');
1053                    $body = $convert->get_text();
1054               }
1055
1056               // ajoute le message dans la liste d'envoi
1057               $newsletter_mailing->addMessage($subscriber_id,$subscriber->email,$subject,$body,$mode);
1058          }
1059          return true;
1060     }
1061
1062     /**
1063      * Prepare le contenu des messages de type suspend
1064      * Modifie l'objet newsletterMailing fourni en parametre
1065      *
1066      * @param:     $ids                     array
1067      * @param:     $newsletter_mailing      newsletterMailing
1068      *
1069      * @return:    boolean
1070      */
1071     private static function prepareMessagesSuspend($ids=-1,&$newsletter_mailing)
1072     {
1073          // initialisation des variables de travail
1074          $mode = newsletterPlugin::getSendMode();
1075          $subject = text::toUTF8(newsletterPlugin::getSuspendSubject());
1076
1077          // initialisation du moteur de template
1078          self::BeforeSendmailTo(newsletterPlugin::getSuspendMsg(),newsletterPlugin::getConcludingSuspendMsg());
1079
1080          // boucle sur les ids des abonnés
1081          foreach ($ids as $subscriber_id)
1082          {
1083               // récupération de l'abonné et extraction des données
1084               $subscriber = self::get($subscriber_id);
1085
1086               // définition du format d'envoi
1087               if (!newsletterPlugin::getUseDefaultFormat() && $subscriber->modesend != null) {
1088                    $mode = $subscriber->modesend;
1089               }
1090
1091               // génération du rendu
1092               nlTemplate::assign('urlEnable', self::url('enable/'.newsletterTools::base64_url_encode($subscriber->email)));
1093
1094               $body = nlTemplate::render('suspend', $mode);
1095               
1096               if($mode == 'text') {
1097                    $convert = new html2text();
1098                    $convert->set_html($body);
1099                    $convert->labelLinks = __('Links:');
1100                    $body = $convert->get_text();
1101               }
1102
1103               // ajoute le message dans la liste d'envoi
1104               $newsletter_mailing->addMessage($subscriber_id,$subscriber->email,$subject,$body,$mode);
1105          }
1106          return true;
1107     }
1108
1109     /**
1110      * Prepare le contenu des messages de type enable
1111      * Modifie l'objet newsletterMailing fourni en parametre
1112      *
1113      * @param:     $ids                     array
1114      * @param:     $newsletter_mailing      newsletterMailing
1115      *
1116      * @return:    boolean
1117      */
1118     private static function prepareMessagesEnable($ids=-1,&$newsletter_mailing)
1119     {
1120          // initialisation des variables de travail
1121          $mode = newsletterPlugin::getSendMode();
1122          $subject = text::toUTF8(newsletterPlugin::getEnableSubject());
1123
1124          // initialisation du moteur de template
1125          self::BeforeSendmailTo(newsletterPlugin::getEnableMsg(),newsletterPlugin::getConcludingEnableMsg());
1126
1127          // boucle sur les ids des abonnés
1128          foreach ($ids as $subscriber_id)
1129          {
1130               // récupération de l'abonné et extraction des données
1131               $subscriber = self::get($subscriber_id);
1132
1133               // définition du format d'envoi
1134               if (!newsletterPlugin::getUseDefaultFormat() && $subscriber->modesend != null) {
1135                    $mode = $subscriber->modesend;
1136               }
1137
1138               // génération du rendu
1139               nlTemplate::assign('urlDisable', self::url('disable/'.newsletterTools::base64_url_encode($subscriber->email)));
1140                    if(newsletterPlugin::getCheckUseSuspend()) {
1141                         nlTemplate::assign('urlSuspend', self::url('suspend/'.newsletterTools::base64_url_encode($subscriber->email)));
1142                    } else {
1143                         nlTemplate::assign('urlSuspend', ' ');
1144                    }
1145
1146               $body = nlTemplate::render('enable', $mode);
1147
1148               if($mode == 'text') {
1149                    $convert = new html2text();
1150                    $convert->set_html($body);
1151                    $convert->labelLinks = __('Links:');
1152                    $body = $convert->get_text();
1153               }
1154         
1155               // ajoute le message dans la liste d'envoi
1156               $newsletter_mailing->addMessage($subscriber_id,$subscriber->email,$subject,$body,$mode);
1157          }
1158          return true;
1159     }
1160
1161     /**
1162      * Prepare le contenu des messages de type disable
1163      * Modifie l'objet newsletterMailing fourni en parametre
1164      *
1165      * @param:     $ids                     array
1166      * @param:     $newsletter_mailing      newsletterMailing
1167      *
1168      * @return:    boolean
1169      */
1170     private static function prepareMessagesDisable($ids=-1,&$newsletter_mailing)
1171     {
1172          // initialisation des variables de travail
1173          $mode = newsletterPlugin::getSendMode();
1174          $subject = text::toUTF8(newsletterPlugin::getDisableSubject());
1175
1176          // initialisation du moteur de template
1177          self::BeforeSendmailTo(newsletterPlugin::getDisableMsg(),newsletterPlugin::getConcludingDisableMsg());
1178
1179          // boucle sur les ids des abonnés
1180          foreach ($ids as $subscriber_id)
1181          {
1182               // récupération de l'abonné et extraction des données
1183               $subscriber = self::get($subscriber_id);
1184
1185               // définition du format d'envoi
1186               if (!newsletterPlugin::getUseDefaultFormat() && $subscriber->modesend != null) {
1187                    $mode = $subscriber->modesend;
1188               }
1189
1190               // génération du rendu
1191               nlTemplate::assign('urlEnable', self::url('enable/'.newsletterTools::base64_url_encode($subscriber->email)));
1192
1193               $body = nlTemplate::render('disable', $mode);
1194
1195               if($mode == 'text') {
1196                    $convert = new html2text();
1197                    $convert->set_html($body);
1198                    $convert->labelLinks = __('Links:');
1199                    $body = $convert->get_text();
1200               }
1201         
1202               // ajoute le message dans la liste d'envoi
1203               $newsletter_mailing->addMessage($subscriber_id,$subscriber->email,$subject,$body,$mode);
1204          }
1205          return true;
1206     }
1207
1208     /**
1209      * Prepare le contenu des messages de type resume
1210      * Modifie l'objet newsletterMailing fourni en parametre
1211      *
1212      * @param:     $ids                     array
1213      * @param:     $newsletter_mailing      newsletterMailing
1214      *
1215      * @return:    boolean
1216      */
1217     private static function prepareMessagesResume($ids=-1,&$newsletter_mailing)
1218     {
1219          // initialisation des variables de travail
1220          $mode = newsletterPlugin::getSendMode();
1221          $subject = text::toUTF8(newsletterPlugin::getResumeSubject());
1222
1223          // initialisation du moteur de template
1224          self::BeforeSendmailTo(newsletterPlugin::getHeaderResumeMsg(),newsletterPlugin::getFooterResumeMsg());
1225
1226          // boucle sur les ids des abonnés
1227          foreach ($ids as $subscriber_id)
1228          {
1229               // récupération de l'abonné et extraction des données
1230               $subscriber = self::get($subscriber_id);
1231
1232               $txt_intro_enable = newsletterPlugin::getTxtIntroEnable().', ';
1233               $urlEnable = self::url('enable/'.newsletterTools::base64_url_encode($subscriber->email));
1234               $txtEnable = newsletterPlugin::getTxtEnable();
1235                         
1236               $txt_intro_disable = newsletterPlugin::getTxtIntroDisable().', ';
1237               $urlDisable = self::url('disable/'.newsletterTools::base64_url_encode($subscriber->email));
1238               $txtDisable = newsletterPlugin::getTxtDisable();
1239
1240               $txt_intro_suspend = newsletterPlugin::getTxtIntroSuspend().', ';
1241               $urlSuspend = self::url('suspend/'.newsletterTools::base64_url_encode($subscriber->email));
1242               $txtSuspend = newsletterPlugin::getTxtSuspend();
1243                         
1244               $txt_intro_confirm = newsletterPlugin::getTxtIntroConfirm().', ';
1245               $urlConfirm = self::url('confirm/'.newsletterTools::base64_url_encode($subscriber->email).'/'.$subscriber->regcode.'/'.newsletterTools::base64_url_encode($subscriber->modesend));
1246               $txtConfirm = newsletterPlugin::getTxtConfirm();
1247               
1248               $urlResume = '';
1249                         
1250               switch ($subscriber->state) {
1251                    case 'suspended':
1252                    {
1253                         $urlResume = $txt_intro_enable.' <a href="'.$urlEnable.'">'.$txtEnable.'</a><br />';
1254                         $urlResume .= $txt_intro_disable.' <a href="'.$urlDisable.'">'.$txtDisable.'</a>';
1255                         nlTemplate::assign('txtResume', __('Your account is suspended.'));
1256                         break;
1257                    }
1258                    case 'disabled':
1259                    {
1260                         $urlResume = $txt_intro_enable.' <a href="'.$urlEnable.'">'.$txtEnable.'</a><br />';
1261                         if(newsletterPlugin::getCheckUseSuspend()) {
1262                              $urlResume .= $txt_intro_suspend.' <a href="'.$urlSuspend.'">'.$txtSuspend.'</a>';
1263                         }
1264                         nlTemplate::assign('txtResume', __('Your account is disabled.'));
1265                         break;
1266                    }
1267                    case 'enabled':
1268                    {
1269                         $urlResume = $txt_intro_disable.' <a href="'.$urlDisable.'">'.$txtDisable.'</a><br />';
1270                         if(newsletterPlugin::getCheckUseSuspend()) {
1271                              $urlResume .= $txt_intro_suspend.' <a href="'.$urlSuspend.'">'.$txtSuspend.'</a>';
1272                         }
1273                         nlTemplate::assign('txtResume', __('Your account is enabled.'));
1274                         break;
1275                    }
1276                    case 'pending':
1277                    {
1278                         $urlResume = $txt_intro_disable.' <a href="'.$urlDisable.'">'.$txtDisable.'</a><br />';
1279                         $urlResume .= $txt_intro_confirm.' <a href="'.$urlConfirm.'">'.$txtConfirm.'</a>';
1280                         nlTemplate::assign('txtResume', __('Your account is pending confirmation.'));
1281                         break;
1282                    }
1283                    default:
1284                    {
1285                    }
1286               }
1287 
1288               // définition du format d'envoi
1289               if (!newsletterPlugin::getUseDefaultFormat() && $subscriber->modesend != null) {
1290                    $mode = $subscriber->modesend;
1291               }
1292
1293               nlTemplate::assign('txtMode', __('Your sending mode is'). ' ' .__(''.$mode.''). '.');
1294               nlTemplate::assign('urlResume', $urlResume);
1295               $body = nlTemplate::render('resume', $mode);
1296
1297               if($mode == 'text') {
1298                    $convert = new html2text();
1299                    $convert->set_html($body);
1300                    $convert->labelLinks = __('Links:');
1301                    $body = $convert->get_text();
1302               }
1303
1304               // ajoute le message dans la liste d'envoi
1305               $newsletter_mailing->addMessage($subscriber_id,$subscriber->email,$subject,$body,$mode);
1306          }
1307          return true;
1308     }
1309
1310     /**
1311      * Prepare le contenu des messages de type changemode
1312      * Modifie l'objet newsletterMailing fourni en parametre
1313      *
1314      * @param:     $ids                     array
1315      * @param:     $newsletter_mailing      newsletterMailing
1316      *
1317      * @return:    boolean
1318      */
1319     private static function prepareMessagesChangeMode($ids=-1,&$newsletter_mailing)
1320     {
1321          // initialisation des variables de travail
1322          $mode = newsletterPlugin::getSendMode();
1323          $subject = text::toUTF8(newsletterPlugin::getChangeModeSubject());
1324
1325          // initialisation du moteur de template
1326          self::BeforeSendmailTo(newsletterPlugin::getHeaderChangeModeMsg(),newsletterPlugin::getFooterChangeModeMsg());         
1327
1328          // boucle sur les ids des abonnés
1329          foreach ($ids as $subscriber_id)
1330          {
1331               // récupération de l'abonné et extraction des données
1332               $subscriber = self::get($subscriber_id);
1333
1334               // définition du format d'envoi
1335               if (!newsletterPlugin::getUseDefaultFormat() && $subscriber->modesend != null) {
1336                    $mode = $subscriber->modesend;
1337               }                       
1338                         
1339               // génération du rendu
1340               nlTemplate::assign('urlEnable', self::url('enable/'.newsletterTools::base64_url_encode($subscriber->email)));
1341
1342               $body = nlTemplate::render('changemode', $mode);
1343
1344               if($mode == 'text') {
1345                    $convert = new html2text();
1346                    $convert->set_html($body);
1347                    $convert->labelLinks = __('Links:');
1348                    $body = $convert->get_text();
1349               }
1350
1351               // ajoute le message dans la liste d'envoi
1352               $newsletter_mailing->addMessage($subscriber_id,$subscriber->email,$subject,$body,$mode);
1353          }
1354          return true;
1355     }
1356
1357     /**
1358      * Envoi automatique de la newsletter pour tous les abonnés actifs
1359      *
1360      * @return:    boolean
1361      */
1362     public static function autosendNewsletter()
1363     {
1364          // test si le plugin est actif
1365          if (!newsletterPlugin::isActive()) {
1366               return;
1367          }
1368
1369          // test si l'envoi automatique est activé
1370          if (!newsletterPlugin::getAutosend()) {
1371               return;
1372          } else {
1373               $datas = self::getlist(true);
1374               if (!is_object($datas)) {
1375                    return;
1376               } else {
1377                    $ids = array();
1378                    $datas->moveStart();
1379                    while ($datas->fetch()) { 
1380                         $ids[] = $datas->subscriber_id;
1381                    }
1382                    self::send($ids,'newsletter');
1383               }             
1384          }   
1385     }
1386
1387     /**
1388      * Envoi par tâche planifiée de la newsletter pour tous les abonnés actifs
1389      *
1390      * @return:    boolean
1391      */
1392     public static function cronSendNewsletter()
1393     {
1394          // test si le plugin est actif
1395          if (!newsletterPlugin::isActive()) {
1396               return;
1397          }
1398         
1399          // test si la planification est activée
1400          if (!newsletterPlugin::getCheckSchedule()) {
1401               return;
1402          } else {
1403               $datas = self::getlist(true);
1404               if (!is_object($datas)) {
1405                    return;
1406               } else {
1407                    $ids = array();
1408                    $datas->moveStart();
1409                    while ($datas->fetch()) { 
1410                         $ids[] = $datas->subscriber_id;
1411                    }
1412                    self::send($ids,'newsletter');
1413               }
1414          }
1415     }
1416
1417     /* ==================================================
1418          gestion des comptes
1419     ================================================== */
1420
1421     /**
1422     * création du compte
1423     */
1424     public static function accountCreate($email = null, $regcode = null, $modesend = null)
1425     {
1426          global $core;
1427          try {         
1428               if ($email == null) {              // l'email doit être renseigné
1429                    return __('Bad email !');
1430               } else {                           // création du compte
1431                    if (self::getemail($email) != null) {
1432                         return __('Email already exist !');
1433                    } else if (!self::add($email, null, null, $modesend)) {
1434                         return __('Error creating account !');
1435                    } else {
1436                         $subscriber = self::getemail($email);
1437                         $msg = self::send($subscriber->subscriber_id,'confirm');
1438                         return $msg;
1439                    }
1440               }
1441          } catch (Exception $e) { 
1442               $core->error->add($e->getMessage()); 
1443          }
1444     }
1445
1446     /**
1447     * suppression du compte
1448     */
1449     public static function accountDelete($email = null)
1450     {
1451          global $core;
1452          try {         
1453               if ($email == null) {              // l'email doit être renseigné
1454                    return __('Bad email !');
1455               } else {                           // suppression du compte
1456                    $subscriber = self::getemail($email);
1457                    $msg = null;
1458                    if (!$subscriber || $subscriber->subscriber_id == null) 
1459                         return __('Email don\'t exist !');
1460                    else {
1461                         $msg = self::send($subscriber->subscriber_id,'disable');
1462                         self::delete($subscriber->subscriber_id);
1463                         return $msg;
1464                    }
1465               }
1466          } catch (Exception $e) { 
1467               $core->error->add($e->getMessage()); 
1468          }
1469     }
1470
1471     /**
1472     * suspension du compte
1473     */
1474     static function accountSuspend($email = null)
1475     {
1476          global $core;
1477          try {
1478
1479               if ($email == null) {              // l'email doit être renseigné
1480                    return __('Bad email !');
1481               } else {                           // suspension du compte
1482                    $subscriber = self::getemail($email);
1483                    $msg = '';
1484                    if (!$subscriber || $subscriber->subscriber_id == null) 
1485                         return __('Email don\'t exist !');
1486                    else {
1487                         $msg = self::send($subscriber->subscriber_id,'suspend');                       
1488                         self::suspend($subscriber->subscriber_id);
1489                         return $msg;
1490                    }
1491               }
1492          } catch (Exception $e) { 
1493               $core->error->add($e->getMessage()); 
1494          }
1495     }
1496
1497     /**
1498     * information sur le compte
1499     */
1500     public static function accountResume($email = null)
1501     {
1502          global $core;
1503          try {         
1504               if ($email == null) {              // l'email doit être renseigné
1505                    return __('Bad email !');
1506               } else {                           // information sur le compte
1507                    $subscriber = self::getemail($email);
1508                    $msg = '';
1509                    if (!$subscriber || $subscriber->subscriber_id == null) 
1510                         return __('Email don\'t exist !');
1511                    else {
1512                         $msg = self::send($subscriber->subscriber_id,'resume');                         
1513                         //self::resume($subscriber->subscriber_id);
1514                         return $msg;
1515                    }
1516               }
1517          } catch (Exception $e) { 
1518               $core->error->add($e->getMessage()); 
1519          }         
1520     }
1521
1522     /**
1523     * changement du format sur le compte
1524     */
1525     public static function accountChangeMode($email = null, $modesend = null)
1526     {
1527          global $core;
1528          try {
1529               if ($email == null) {              // l'email doit être renseigné
1530                    return __('Bad email !');
1531               } else {                           // information sur le compte
1532                    $subscriber = self::getemail($email);
1533                    $msg = '';
1534                    if (!$subscriber || $subscriber->subscriber_id == null) 
1535                         return __('Email don\'t exist !');
1536                    else {
1537                         $msg = self::send($subscriber->subscriber_id,'changemode');                     
1538                         self::changeMode($subscriber->subscriber_id, $modesend);
1539                         return $msg;
1540                    }
1541               }
1542          } catch (Exception $e) { 
1543               $core->error->add($e->getMessage()); 
1544          }
1545     }
1546
1547}
1548
1549?>
Note: See TracBrowser for help on using the repository browser.

Sites map