Dotclear

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

Revision 2645, 56.0 KB checked in by kwon, 13 years ago (diff)

Newsletter 3.7.9 : prepare the final version
  • 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-2010 Benoit de Marne.
6# benoit.de.marne@gmail.com
7# Many thanks to Association Dotclear and special thanks to Olivier Le Bris
8#
9# Licensed under the GPL version 2.0 license.
10# A copy of this license is available in LICENSE file or at
11# http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
12# -- END LICENSE BLOCK ------------------------------------
13
14// Loading libraries
15require dirname(__FILE__).'/class.template.php';
16require dirname(__FILE__).'/class.newsletter.mailing.php';
17
18class newsletterCore
19{
20     
21     /**
22      * getRawDatas
23      *
24      * Retrieves table newsletter from database.
25      *
26      * @param boolean $onlyblog  only the current blog
27      * @return recordSet  the retrieved recordset
28      */
29     public static function getRawDatas($onlyblog = false)
30     {
31          global $core;
32          try
33          {
34               $blog = &$core->blog;
35               $con = &$core->con;
36               $blogid = (string)$blog->id;
37
38               $strReq =
39                    'SELECT *'.
40                    ' FROM '.$core->prefix.newsletterPlugin::pname();
41                   
42               if($onlyblog) {
43                    $strReq .= ' WHERE blog_id=\''.$blogid.'\''; 
44               }
45
46               $rs = $con->select($strReq);
47               if ($rs->isEmpty())
48                    return null;
49               else 
50                    return $rs;
51          } catch (Exception $e) { 
52               $core->blog->dcNewsletter->addError($e->getMessage());
53          }
54     }
55
56     /**
57     * retourne le prochain id de la table
58     */
59     public static function nextId()
60     {
61          global $core;
62          try {
63               $blog = &$core->blog;
64               $con = &$core->con;
65               $blogid = (string)$blog->id;
66
67               // requète sur les données et renvoi un entier
68               $strReq =
69                    'SELECT max(subscriber_id)'.
70                    ' FROM '.$core->prefix.newsletterPlugin::pname();
71
72               $rs = $con->select($strReq);
73               if ($rs->isEmpty()) 
74                    return 0;
75               else 
76                    return ((integer)$rs->f(0)) +1;
77          } catch (Exception $e) { 
78               $core->blog->dcNewsletter->addError($e->getMessage());
79          }
80     }
81
82     /**
83     * renvoi un id pris au hasard dans la table
84     */
85     public static function randomId()
86     {
87          global $core;
88          try {
89               $blog = &$core->blog;
90               $con = &$core->con;
91               $blogid = (string)$blog->id;
92
93               // requète sur les données et renvoi un entier
94               $strReq =
95               'SELECT min(subscriber_id), max(subscriber_id)'.
96               ' FROM '.$core->prefix.newsletterPlugin::pname().
97               ' WHERE blog_id=\''.$blogid.'\'';
98
99               $rs = $con->select($strReq);
100               if ($rs->isEmpty()) 
101                    return 0;
102               else 
103                    return rand($rs->f(0), $rs->f(1));
104          } catch (Exception $e) { 
105               $core->blog->dcNewsletter->addError($e->getMessage());
106          }
107     }
108
109     /**
110     * test l'existence d'un abonné par son id
111     */
112     public static function exist($id = -1) 
113     {
114          if (!is_numeric($id)) {
115               return null;
116          } else if ($id < 0) {
117               return null;
118          } else {
119               global $core;
120               try {
121                    $blog = &$core->blog;
122                    $con = &$core->con;
123                    $blogid = (string)$blog->id;
124
125                    $strReq =
126                    'SELECT subscriber_id'.
127                    ' FROM '.$core->prefix.newsletterPlugin::pname().
128                    ' WHERE blog_id=\''.$blogid.'\' AND subscriber_id='.$id;
129
130                    $rs = $con->select($strReq);
131                    if ($rs->isEmpty()) 
132                         return false;
133                    else 
134                         return true;
135               } catch (Exception $e) { 
136                    $core->blog->dcNewsletter->addError($e->getMessage());
137               }
138          }
139     }
140
141     /**
142     * getEmail
143     *
144     * Retrieves a subscriber
145     *
146     * @param string $_email  the mail of the subscriber
147     * @return recordSet  the retrieved recordset
148     */
149     public static function getEmail($_email = null)
150     {
151          if ($_email == null) {
152               return null;
153          } else {
154               global $core;
155
156               $blog = &$core->blog;
157               $con = &$core->con;
158               $blogid = (string)$blog->id;
159
160               $email = $con->escape(html::escapeHTML(html::clean($_email)));
161     
162          $strReq =
163                    'SELECT subscriber_id'.
164                    ' FROM '.$core->prefix.newsletterPlugin::pname().
165                    ' WHERE blog_id=\''.$blogid.'\' AND email=\''.$email.'\'';
166
167               $rs = $con->select($strReq);
168               if ($rs->isEmpty()) 
169                    return null;
170               else 
171                    return self::get($rs->f('subscriber_id'));
172          }
173     }
174
175     /**
176     * récupère des abonnés par leur id
177     */
178     public static function get($id = -1)
179     {
180          // test sur la valeur de l'id qui doit être positive ou null
181          if ($id < 0) return null;
182
183          // récupère les abonnés
184          else
185          {
186               global $core;
187               try {
188                    $blog = &$core->blog;
189                    $con = &$core->con;
190                    $blogid = (string)$blog->id;
191
192                    // mise en forme du tableau d'id
193                    if (is_array($id)) 
194                         $ids = implode(", ", $id);
195                    else 
196                         $ids = $id;
197
198                    // requète sur les données et renvoi null si erreur
199                    $strReq =
200                    'SELECT subscriber_id,email,regcode,state,subscribed,lastsent,modesend' .
201                    ' FROM '.$core->prefix.newsletterPlugin::pname().
202                    ' WHERE blog_id=\''.$blogid.'\' AND subscriber_id IN('.$ids.')';
203
204                    $rs = $con->select($strReq);
205                    if ($rs->isEmpty()) 
206                         return null;
207                    else 
208                         return $rs;
209               } catch (Exception $e) { 
210                    $core->blog->dcNewsletter->addError($e->getMessage());
211               }
212          }
213     }
214
215     /**
216     * add
217     *
218     * Add a subscriber
219     *
220     * @param string $_email  the mail
221     * @param integer $_blogid  the blog
222     * @param string $_regcode  the security code
223     * @param string $_modesend  the format of the mail
224   
225     * @return integer  the result of the SQL insert
226     */   
227     public static function add($_email = null, $_blogid = null, $_regcode = null, $_modesend = null)
228     {
229          global $core;
230         
231          if ($_email == null) {
232               throw new Exception(__('You must input an email'));
233          } else {
234               $blog = $core->blog;
235               $con = $core->con;
236               $blogid = $con->escape((string)$blog->id);
237               $newsletter_settings = new newsletterSettings($core);
238
239               if (!text::isEmail($_email)) {
240                    throw new Exception(__('The given email is invalid').' : '.$_email);
241               }
242
243               if (newsletterCore::getEmail($_email)) {
244                    throw new Exception(__('The email already exist').' : '.$_email);
245               }
246
247               // generate regcode
248               if ($_regcode == null) {
249                    $_regcode = newsletterTools::regcode();
250               }
251
252               if ($_modesend == null) {
253                    $_modesend = $newsletter_settings->getSendMode();
254               }
255
256               if ($_blogid == null) {
257                    $_blogid = $blogid;
258               }
259                   
260               // create SQL request
261               $cur = $con->openCursor($core->prefix.newsletterPlugin::pname());
262               $cur->subscriber_id = self::nextId();
263               $cur->blog_id = $_blogid;
264               $cur->email = $con->escape(html::escapeHTML(html::clean($_email)));
265               $cur->regcode = $con->escape(html::escapeHTML(html::clean($_regcode)));
266               $cur->state = 'pending';
267
268               # Settings compatibility test
269               if (version_compare(DC_VERSION,'2.2-alpha','>=')) {
270                    $system_settings = $core->blog->settings->system;
271               } else {
272                    $system_settings->system_settings =& $core->blog->settings;
273               }         
274               
275               $time = time() + dt::getTimeOffset($system_settings->blog_timezone);
276               
277               $cur->lastsent = $cur->subscribed = date('Y-m-d H:i:s',$time);
278               $cur->modesend = $con->escape(html::escapeHTML(html::clean($_modesend)));
279
280               // launch SQL request
281               return($cur->insert());
282          }
283     }
284     
285     /**
286     * met à jour un abonné par son id
287     */
288     public static function update($id = -1, $_email = null, $_state = null, $_regcode = null, $_subscribed = null, $_lastsent = null, $_modesend = null) 
289     {
290          // test des paramètres
291          if (!self::exist($id)) {
292               return null;
293          } else { // met à jour l'abonné
294               global $core;
295               try {
296                    $blog = &$core->blog;
297                    $con = &$core->con;
298                    $blogid = $con->escape((string)$blog->id);
299
300                    // génération de la requète
301                    $cur = $con->openCursor($core->prefix.newsletterPlugin::pname());
302
303                    $cur->subscriber_id = $id;
304                    $cur->blog_id = $blogid;
305
306                    if ($_email != null) 
307                         $cur->email = $con->escape(html::escapeHTML(html::clean($_email)));
308                   
309                    if ($_state != null) 
310                         $cur->state = $con->escape(html::escapeHTML(html::clean($_state)));
311                   
312                    if ($_regcode != null) 
313                         $cur->regcode = $con->escape(html::escapeHTML(html::clean($_regcode)));
314                   
315                    if ($_subscribed != null) 
316                         $cur->subscribed = $con->escape(html::escapeHTML(html::clean($_subscribed)));
317                   
318                    if ($_lastsent != null) 
319                         $cur->lastsent = $con->escape(html::escapeHTML(html::clean($_lastsent)));
320                   
321                    if ($_modesend != null) 
322                         $cur->modesend = $con->escape(html::escapeHTML(html::clean($_modesend)));
323
324                    $cur->update('WHERE blog_id=\''.$con->escape($blogid).'\' AND subscriber_id='.$id);
325                   
326                    return true;
327               } catch (Exception $e) { 
328                    $core->blog->dcNewsletter->addError($e->getMessage());
329               }
330          }
331     }
332
333     /**
334     * supprime un abonné par son id
335     */
336     public static function delete($id = -1)
337     {
338          // test sur la valeur de l'id qui doit être positive ou null
339          if ($id < 0) {
340               return null;
341          } else { // supprime les abonnés
342               global $core;
343               try {
344                    $blog = &$core->blog;
345                    $con = &$core->con;
346                    $blogid = $con->escape((string)$blog->id);
347
348                    // mise en forme du tableau d'id
349                    if (is_array($id)) 
350                         $ids = implode(", ", $id);
351                    else 
352                         $ids = $id;
353
354                    // requète sur les données et renvoi un booléen
355                    $strReq =
356                    'DELETE FROM '.$core->prefix.newsletterPlugin::pname().
357                    ' WHERE blog_id=\''.$blogid.'\' AND subscriber_id IN('.$ids.')';
358
359                    if ($con->execute($strReq)) 
360                         return true;
361                    else
362                         return false;
363               } catch (Exception $e) { 
364                    $core->blog->dcNewsletter->addError($e->getMessage());
365               }
366          }
367     }
368
369     /**
370     * retourne le contenu de la table sous forme de tableau de données brutes
371     */
372     public static function getSubscribers($params=array(),$count_only=false)
373     {
374          global $core;
375          $blog = &$core->blog;
376          $con = &$core->con;
377          $blogid = $con->escape((string)$blog->id);
378
379          if ($count_only) {
380               $strReq = 'SELECT count(N.subscriber_id) ';
381          } else {
382               $strReq =
383               'SELECT N.subscriber_id, N.blog_id, N.email, N.regcode, '.
384               'N.state, N.subscribed, N.lastsent, N.modesend ';
385          }
386
387          $strReq .=
388          'FROM '.$core->prefix.newsletterPlugin::pname().' N ';
389
390          $strReq .=
391          "WHERE N.blog_id = '".$blogid."' ";
392
393          if (!empty($params['state'])) {
394               $strReq .= "AND N.state = '".$con->escape($params['state'])."' ";
395          }
396
397          if (!empty($params['subscriber_id'])) {
398               if (is_array($params['subscriber_id'])) {
399                    array_walk($params['subscriber_id'],create_function('&$v,$k','if($v!==null){$v=(integer)$v;}'));
400               } else {
401                    $params['subscriber_id'] = array((integer) $params['subscriber_id']);
402               }
403               $strReq .= 'AND N.subscriber_id '.$con->in($params['subscriber_id']);
404          }
405     
406          if (!$count_only)
407          {
408               if (!empty($params['order'])) {
409                    $strReq .= 'ORDER BY '.$con->escape($params['order']).' ';
410               } else {
411                    $strReq .= 'ORDER BY N.subscribed DESC ';
412               }
413          }
414               
415          if (!$count_only && !empty($params['limit'])) {
416               $strReq .= $con->limit($params['limit']);
417          }
418
419          $rs = $con->select($strReq);
420
421          return $rs;
422     }
423
424     /**
425     * retourne le contenu de la table sous forme de tableau de données brutes
426     */
427     public static function getlist($active = false)
428     {
429          global $core;
430          try {
431               $blog = &$core->blog;
432               $con = &$core->con;
433               $blogid = $con->escape((string)$blog->id);
434
435               // requête sur les données et renvoi null si erreur
436               $strReq =
437                    'SELECT *'.
438                    ' FROM '.$core->prefix.newsletterPlugin::pname().
439                    ' WHERE blog_id=\''.$blogid.'\'';
440
441               if ($active) $strReq .= ' AND state=\'enabled\'';           
442               
443               $rs = $con->select($strReq);
444               if ($rs->isEmpty()) 
445                    return null;
446               else 
447                    return $rs;
448          } catch (Exception $e) { 
449               $core->blog->dcNewsletter->addError($e->getMessage());
450          }
451     }
452
453     /**
454     * modifie l'état de l'abonné
455     */
456     public static function state($id = -1, $_state = null)
457     {
458          // test sur la valeur de l'id qui doit être positive ou null
459          if ($id < 0) {
460               return null;
461          } else { 
462               // modifie l'état des abonnés
463         
464               // filtrage sur le code de status
465               switch ($_state) {
466                    case 'pending':
467                    case 'enabled':
468                    case 'suspended':
469                    case 'disabled':
470                         break;
471                    default:
472                         return false;
473               }
474
475               global $core;
476               try {
477                    $blog = &$core->blog;
478                    $con = &$core->con;
479                    $blogid = $con->escape((string)$blog->id);
480
481                    // mise en forme du tableau d'id
482                    if (is_array($id)) 
483                         $ids = implode(", ", $id);
484                    else 
485                         $ids = $id;
486
487                    // génération de la requète
488                    $cur = $con->openCursor($core->prefix.newsletterPlugin::pname());
489
490                    $cur->state = $con->escape(html::escapeHTML(html::clean($_state)));
491
492                    $ret = $cur->update('WHERE blog_id=\''.$con->escape($blogid).'\' AND subscriber_id IN('.$ids.')');
493                    return $ret;
494               } catch (Exception $e) { 
495                    $core->blog->dcNewsletter->addError($e->getMessage());
496               }
497          }
498     }
499
500     /**
501     * place les comptes en attente
502     */
503     public static function pending($id = -1) 
504     { 
505          return self::state($id, 'pending'); 
506     }
507
508     /**
509     * active les comptes
510     */
511     public static function enable($id = -1) 
512     { 
513          return self::state($id, 'enabled'); 
514     }
515
516     /**
517     * suspend les comptes
518     */
519     public static function suspend($id = -1)
520     { 
521          return self::state($id, 'suspended'); 
522     }
523
524     /**
525     * désactive les comptes
526     */
527     public static function disable($id = -1)
528     { 
529          return self::state($id, 'disabled'); 
530     }
531
532     /**
533     * comptes en attente de confirmation
534     */
535     public static function confirm($id = -1)
536     { 
537          return self::state($id, 'confirm'); 
538     }
539
540     /**
541     * modifie la date de dernier envoi
542     */
543     public static function lastsent($id = -1, $_lastsent = null) 
544     {
545          // test sur la valeur de l'id qui doit être positive ou null
546          if ($id < 0) {
547               return false;
548          }
549         
550          // modifie l'état des abonnés
551          else {
552               global $core;
553               try {
554                    $blog = &$core->blog;
555                    $con = &$core->con;
556                    $blogid = $con->escape((string)$blog->id);
557
558                    // mise en forme du tableau d'id
559                    if (is_array($id)) 
560                         $ids = implode(", ", $id);
561                    else 
562                         $ids = $id;
563
564                    // génération de la requète
565                    if ($_lastsent == 'clear')
566                         $req = 'UPDATE '.$core->prefix.newsletterPlugin::pname().' SET lastsent=subscribed';
567                    else if ($_lastsent == null) 
568                         $req = 'UPDATE '.$core->prefix.newsletterPlugin::pname().' SET lastsent=now()';
569                    else 
570                         $cur->lastsent = $con->escape(html::escapeHTML(html::clean($_lastsent)));
571               
572                    $req .= ' WHERE blog_id=\''.$con->escape($blogid).'\' AND subscriber_id IN('.$ids.')';
573                    return ($con->execute($req));
574             } catch (Exception $e) { 
575               $core->blog->dcNewsletter->addError($e->getMessage());
576             }
577          }
578     }
579
580     /**
581     * modifie le format de la lettre pour l'abonné
582     */
583     public static function changemode($id = -1, $_modesend = null)
584     {
585          // test sur la valeur de l'id qui doit être positive ou null
586          if ($id < 0) {
587               return null;
588          } else { 
589               // modifie le format de la lettre de l'abonné
590         
591               // filtrage sur le code de status
592               switch ($_modesend) {
593                    case 'html':
594                    case 'text':
595                         break;
596                    default:
597                         return false;
598               }
599
600               global $core;
601               try {
602                    $blog = &$core->blog;
603                    $con = &$core->con;
604                    $blogid = $con->escape((string)$blog->id);
605
606                    // mise en forme du tableau d'id
607                    if (is_array($id)) 
608                         $ids = implode(", ", $id);
609                    else 
610                         $ids = $id;
611
612                    // génération de la requète
613                    $cur = $con->openCursor($core->prefix.newsletterPlugin::pname());
614
615                    $cur->modesend = $con->escape(html::escapeHTML(html::clean($_modesend)));
616
617                    $cur->update('WHERE blog_id=\''.$con->escape($blogid).'\' AND subscriber_id IN('.$ids.')');
618                    return true;
619               } catch (Exception $e) { 
620                    $core->blog->dcNewsletter->addError($e->getMessage());
621               }
622          }
623     }
624     
625     /**
626     * change le format en html des comptes
627     */
628     public static function changemodehtml($id = -1)
629     { 
630          return self::changemode($id, 'html'); 
631     }
632
633     /**
634     * change le format en text des comptes
635     */
636     public static function changemodetext($id = -1)
637     { 
638          return self::changemode($id, 'text'); 
639     }
640
641     /* ==================================================
642          billets
643     ================================================== */
644
645     /**
646     * retourne les billets pour la newsletter:
647     */
648     public static function getPosts($l_post_id=null)
649     {
650          global $core;
651          try {
652               $con = &$core->con;
653               $blog = &$core->blog;
654               $newsletter_settings = new newsletterSettings($core);
655               $debug = false;
656               
657               # Settings compatibility test
658               if (version_compare(DC_VERSION,'2.2-alpha','>=')) {
659                    $system_settings = $core->blog->settings->system;
660               } else {
661                    $system_settings = $core->blog->settings;
662               }             
663               
664               // paramétrage de la récupération des billets
665               $params = array();
666
667               // sélection du contenu
668               //$params['no_content'] = ($newsletter_settings->getViewContentPost() ? false : true);
669                $params['no_content'] = false;
670               
671               // sélection des billets
672               $params['post_type'] = 'post';
673               // uniquement les billets publiés, sans mot de passe
674               $params['post_status'] = 1;
675               // sans mot de passe
676               $params['sql'] = ' AND P.post_password IS NULL';
677               
678               // envoi d'un billet specifique
679               if($l_post_id !== null) {
680                    $params['post_id'] = (integer) $l_post_id;
681               } else {
682                    // filtre sur la date du dernier envoi
683                    if ($newsletter_settings->getDatePreviousSend() !== null) {
684
685                         if ($newsletter_settings->getOrderDate() == 'post_dt') {
686                              $date_previous_send = date('Y-m-j H:i:s',$newsletter_settings->getDatePreviousSend() + dt::getTimeOffset($system_settings->blog_timezone));
687                              $now = date('Y-m-j H:i:s',time() + dt::getTimeOffset($system_settings->blog_timezone));
688                         } else {
689                              $date_previous_send = date('Y-m-j H:i:s',$newsletter_settings->getDatePreviousSend());
690                              $now = date('Y-m-j H:i:s',time());
691                         }
692                             
693                         $params['sql'] = ' AND P.'.$newsletter_settings->getOrderDate().' BETWEEN "'.$date_previous_send.'" AND "'.$now.'" ';
694                         if($debug) {
695                              $core->blog->dcNewsletter->addMessage(' P.'.$newsletter_settings->getOrderDate().' BETWEEN "'.$date_previous_send.'" AND "'.$now.'" ');
696                         }
697                    }
698               }
699               
700               // limitations du nombre de billets
701               $maxPost = $newsletter_settings->getMaxPosts();
702               if ($maxPost > 1) {
703                    $params['limit'] = $maxPost;
704               }
705         
706               // définition du tris des enregistrements et filtrage dans le temps
707               $params['order'] = ' P.'.$newsletter_settings->getOrderDate().' DESC';
708
709               // filtre sur la categorie
710               $category = $newsletter_settings->getCategory();
711               
712               if ($category) {
713                    // filtre sur les sous-categories
714                    if ($newsletter_settings->getCheckSubCategories()) {
715                   
716                         $rs = $con->select(
717                              'SELECT cat_lft, cat_rgt FROM '.$core->prefix.'category '.
718                              "WHERE blog_id = '".$con->escape($blog->id)."' ".
719                              'AND cat_id='.(integer)$category
720                         );
721                         
722                         $cat_borders = array();
723                         while ($rs->fetch()) {
724                              $cat_borders = 'C.cat_lft BETWEEN '.$rs->cat_lft.' AND '.$rs->cat_rgt.'';
725                         }
726                         if (count($cat_borders) > 0) {
727                              $params['sql'] = ' AND (C.cat_id IS NOT NULL AND '.$cat_borders.')';
728                         }
729                    } else {
730                         if ($category == 'null') {
731                              $params['sql'] = ' AND P.cat_id IS NULL ';
732                         } elseif (is_numeric($category)) {
733                              $params['cat_id'] = (integer) $category;
734                         } else {
735                              $params['cat_url'] = $category;
736                         }
737                    }
738               }
739
740               // récupération des billets
741               $rs = $blog->getPosts($params, false);
742               
743               if($debug) {
744                    $core->blog->dcNewsletter->addMessage('nb billets='.$rs->count().', $category='.$category);
745               }
746               
747               $minPosts = $newsletter_settings->getMinPosts();
748               if($rs->count() < $minPosts)
749                    return null;
750               else 
751                    return($rs->isEmpty()?null:$rs);
752          } catch (Exception $e) { 
753                    $core->blog->dcNewsletter->addError($e->getMessage());
754          }
755     }
756
757     public static function getNewsletterPosts($l_post_id=null)
758     {
759          global $core;
760          $newsletter_settings = new newsletterSettings($core);
761
762          # Settings compatibility test
763          if (version_compare(DC_VERSION,'2.2-alpha','>=')) {
764               $system_settings = $core->blog->settings->system;
765          } else {
766               $system_settings = $core->blog->settings;
767          }             
768         
769          // boucle sur les billets concernés pour l'abonnés
770          $bodies = array();
771          $posts = array();
772     
773          $posts = self::getPosts($l_post_id);
774         
775          if($posts!==null) {
776               $posts->core = $core;
777               $posts->moveStart();
778
779               while ($posts->fetch())
780               {
781                    $_body_swap = html::escapeHTML('');
782                   
783                    // Affiche les miniatures
784                    if ($newsletter_settings->getViewThumbnails()) {
785                         
786                         // reprise du code de context::EntryFirstImageHelper et adaptation
787                         $size=$newsletter_settings->getSizeThumbnails();
788                         if (!preg_match('/^sq|t|s|m|o$/',$size)) {
789                              $size = 's';
790                         }
791                         $class = !empty($attr['class']) ? $attr['class'] : '';
792                         
793                         $p_url = $system_settings->public_url;
794                         $p_site = preg_replace('#^(.+?//.+?)/(.*)$#','$1',$core->blog->url);
795                         $p_root = $core->blog->public_path;
796                   
797                         $pattern = '(?:'.preg_quote($p_site,'/').')?'.preg_quote($p_url,'/');
798                         $pattern = sprintf('/<img.+?src="%s(.*?\.(?:jpg|gif|png))"[^>]+/msu',$pattern);
799                   
800                         $src = '';
801                         $alt = '';
802                   
803                         # We first look in post content
804                         $subject = $posts->post_excerpt_xhtml.$posts->post_content_xhtml.$posts->cat_desc;
805                             
806                         if (preg_match_all($pattern,$subject,$m) > 0)
807                         {
808                              foreach ($m[1] as $i => $img) {
809                                   if (($src = newsletterLetter::ContentFirstImageLookup($p_root,$img,$size)) !== false) {
810                                        //$src = $p_url.(dirname($img) != '/' ? dirname($img) : '').'/'.$src;
811                                        if (dirname($img) != '/' && dirname($img) != '\\') {
812                                             $src = $p_url.dirname($img).'/'.$src;
813                                        } else {
814                                             $src = $p_url.'/'.$src;
815                                        }
816                                       
817                                        if (preg_match('/alt="([^"]+)"/',$m[0][$i],$malt)) {
818                                             $alt = $malt[1];
819                                        }
820                                        break;
821                                   }
822                              }
823                         }
824
825                         # No src, look in category description if available
826                         if (!$src && $posts->cat_desc)
827                         {
828                              if (preg_match_all($pattern,$posts->cat_desc,$m) > 0)
829                              {
830                                   foreach ($m[1] as $i => $img) {
831                                        if (($src = newsletterLetter::ContentFirstImageLookup($p_root,$img,$size)) !== false) {
832                                             //$src = $p_url.(dirname($img) != '/' ? dirname($img) : '').'/'.$src;
833                                             if (dirname($img) != '/' && dirname($img) != '\\') {
834                                                  $src = $p_url.dirname($img).'/'.$src;
835                                             } else {
836                                                  $src = $p_url.'/'.$src;
837                                             }
838                                                 
839                                             if (preg_match('/alt="([^"]+)"/',$m[0][$i],$malt)) {
840                                                  $alt = $malt[1];
841                                             }
842                                             break;
843                                        }
844                                   }
845                              };
846                         }                       
847                         
848                         
849                         if ($src) {
850                              $_body_swap .= '<p class="content_img" style="border: 0px;">';
851                              $_body_swap .= html::absoluteURLs('<img alt="'.$alt.'" src="'.$src.'" class="'.$class.'" />',$posts->getURL()); 
852                              $_body_swap .= '</p>';
853                         }                   
854                    }
855                   
856                    //$_body_save = $_body_swap;
857                   
858                    // Contenu du billet
859                    /*
860                    if ($newsletter_settings->getExcerptRestriction()) {
861                         $_body_swap .= html::escapeHTML(newsletterTools::cutString(html::decodeEntities(html::clean($posts->getExcerpt($posts,true))),$newsletter_settings->getSizeContentPost()));
862                    } else {
863                         if ($newsletter_settings->getViewContentPost()) {
864                              $_body_swap .= html::escapeHTML(newsletterTools::cutString(html::decodeEntities(html::clean($posts->getExcerpt().' '.$posts->getContent())),$newsletter_settings->getSizeContentPost()));
865                         }
866                    }
867                    //*/
868
869                    // Contenu des billets
870                    $news_content = '';
871                    if ($newsletter_settings->getExcerptRestriction()) {
872                         // Get only Excerpt
873                         $news_content = $posts->getExcerpt($posts,true);
874                         $news_content = html::absoluteURLs($news_content,$posts->getURL());
875                    } else {
876                         if ($newsletter_settings->getViewContentPost()) {
877                              $news_content = $posts->getExcerpt($posts,true).' '.$posts->getContent($posts,true);
878                              $news_content = html::absoluteURLs($news_content,$posts->getURL());
879                         }
880                    }
881                   
882                    if(!empty($news_content)) {
883                         if($newsletter_settings->getViewContentInTextFormat()) {
884                              $news_content = context::remove_html($news_content);
885                              $news_content = text::cutString($news_content,$newsletter_settings->getSizeContentPost());
886                              $news_content = html::escapeHTML($news_content);
887                              $news_content = $news_content.' ... ';
888                         } else {
889                              $news_content = text::cutString($news_content,$newsletter_settings->getSizeContentPost());
890                              $news_content = newsletterTools::cutHtmlString($news_content,$newsletter_settings->getSizeContentPost());
891                              $news_content = html::decodeEntities($news_content);
892                              $news_content = preg_replace('/<\/p>$/',"...</p>",$news_content);                             
893                         }
894
895                         // Affichage
896                         $_body_swap .= $news_content;
897                    }
898                   
899                    // Affiche le lien "read more"
900                    //$style_readmore='style="color: #d5b72b; text-decoration: none"';
901                    //$_body_swap .= '<a href="'.$posts->getURL().'" '.$style_readmore.'>Read more - Lire la suite</a>';
902                    $style_readmore='';
903                   
904                    $_body_swap .= '<p class="read-it">';
905                    $_body_swap .= '<a href="'.$posts->getURL().'">Read more - Lire la suite</a>';
906                    $_body_swap .= '</p>';
907                   
908                    $format = $system_settings->date_format.' - '.$system_settings->time_format;
909                    $tdate = $newsletter_settings->getOrderDate();
910                   
911                    if($tdate == 'post_dt')
912                         $sdate = dt::dt2str($format,$posts->$tdate);
913                    else
914                         $sdate = dt::dt2str($format,$posts->$tdate,$posts->post_tz);
915               
916                    $bodies[] = array(
917                         'title' => $posts->post_title,
918                         'url' => $posts->getURL(),
919                         'date' => $sdate,
920                         'category' => $posts->getCategoryURL(),
921                         'content' => $_body_swap,
922                         'author' => $posts->getAuthorCN(),
923                         'post_dt' => $posts->post_dt,
924                         'post_creadt' => $posts->post_creadt,
925                         'post_upddt' => $posts->post_upddt
926                    );
927                   
928               }
929          }
930          return $bodies;
931     }
932
933     public static function getUserPosts($posts=array(),$dt=null)
934     {
935          $bodies = array();
936          foreach ($posts as $k => $v) {
937               //if($dt < $v['post_dt']) {
938               if($dt < $v[$newsletter_settings->getOrderDate()]) {
939                    $bodies[] = $posts[$k];
940               }
941          }
942          return $bodies;
943     }
944
945     /* ==================================================
946          emails
947     ================================================== */
948
949     /**
950     * renvoi l'url de base de newsletter
951     */
952     public static function url($cmd = '')
953     {
954          global $core;
955          try {
956               $url = &$core->url;
957               $blog = &$core->blog;
958               $blogurl = &$blog->url;
959
960               if ($cmd == '') 
961                    return http::concatURL($blogurl, $url->getBase('newsletter'));
962               else 
963                    return http::concatURL($blogurl, $url->getBase('newsletter')).'/'.$cmd;
964          } catch (Exception $e) { 
965               $core->blog->dcNewsletter->addError($e->getMessage());
966          }
967     }
968
969     /**
970     * préparation de l'envoi d'un mail à un abonné
971     */
972     private static function BeforeSendmailTo($header, $footer)
973     {
974          global $core;
975          try
976          {
977               $url = &$core->url;
978               $blog = &$core->blog;
979               $blogname = &$blog->name;
980               $blogdesc = &$blog->desc;
981               $blogurl = &$blog->url;
982               $urlBase = http::concatURL($blogurl, $url->getBase('newsletter'));
983               $newsletter_settings = new newsletterSettings($core);
984
985               nlTemplate::clear();
986               nlTemplate::assign('header', $header);
987               nlTemplate::assign('footer', $footer);
988               nlTemplate::assign('blogName', $blogname);
989               nlTemplate::assign('blogDesc', $blogdesc);
990               nlTemplate::assign('blogUrl', $blogurl);
991               nlTemplate::assign('txtIntroductoryMsg', $newsletter_settings->getIntroductoryMsg());
992               nlTemplate::assign('txtMsgPresentationForm', $newsletter_settings->getMsgPresentationForm());
993               nlTemplate::assign('txtHeading', $newsletter_settings->getPresentationPostsMsg());
994               nlTemplate::assign('txt_intro_confirm', $newsletter_settings->getTxtIntroConfirm().', ');
995               nlTemplate::assign('txtConfirm', $newsletter_settings->getTxtConfirm());
996               nlTemplate::assign('txt_intro_disable', $newsletter_settings->getTxtIntroDisable().', ');
997               nlTemplate::assign('txtDisable', $newsletter_settings->getTxtDisable());
998               nlTemplate::assign('txt_intro_enable', $newsletter_settings->getTxtIntroEnable().', ');
999               nlTemplate::assign('txtEnable', $newsletter_settings->getTxtEnable());
1000               nlTemplate::assign('txtChangingMode', $newsletter_settings->getChangeModeMsg());
1001               nlTemplate::assign('txt_visu_online', $newsletter_settings->getTxtLinkVisuOnline()); 
1002
1003               if($newsletter_settings->getCheckUseSuspend()) {
1004                    nlTemplate::assign('txt_intro_suspend', $newsletter_settings->getTxtIntroSuspend().', ');
1005                    nlTemplate::assign('txtSuspend', $newsletter_settings->getTxtSuspend());
1006                    nlTemplate::assign('txtSuspended', $newsletter_settings->getTxtSuspendedMsg());
1007               } else {
1008                    nlTemplate::assign('txt_intro_suspend', ' ');
1009                    nlTemplate::assign('txtSuspend', ' ');
1010                    nlTemplate::assign('txtSuspended', ' ');
1011               }
1012                             
1013               nlTemplate::assign('txtDisabled',$newsletter_settings->getTxtDisabledMsg());
1014               nlTemplate::assign('txtEnabled', $newsletter_settings->getTxtEnabledMsg());
1015               nlTemplate::assign('txtBy', __(', by'));
1016          } catch (Exception $e) {
1017               $core->error->add($e->getMessage());
1018          }
1019     }
1020
1021     /**
1022      * Prepare la liste des messages et declenche l'envoi de cette liste.
1023      * Retourne les resultats des envois dans un string
1024      *
1025      * @param:     $id            array
1026      * @param:     $action        string
1027      *
1028      * @return:    string
1029      */
1030     public static function send($id=-1,$action=null,$l_post_id=null)
1031     {
1032          global $core;
1033
1034          $url = &$core->url;
1035          $blog = &$core->blog;
1036          $blogurl = &$blog->url;
1037         
1038          $send = array();
1039         
1040          # Settings compatibility test
1041          if (version_compare(DC_VERSION,'2.2-alpha','>=')) {
1042               $blog_settings =& $core->blog->settings->newsletter;
1043               $system_settings = $core->blog->settings->system;
1044          } else {
1045               $blog_settings =& $core->blog->settings;
1046               $system_settings =& $core->blog->settings;
1047          }
1048                   
1049          $newsletter_flag = (boolean)$blog_settings->newsletter_flag;
1050
1051          try {
1052               if (!$newsletter_flag) {           // test si le plugin est actif
1053                    return false;
1054               } else if ($id == -1 || $action === null) {  // test sur la valeur de l'id qui doit être positive ou null
1055                    return false;
1056               } else {                                     // envoi des mails aux abonnés
1057
1058                    // prise en compte du paramètres: liste d'id ou id simple
1059                    if (is_array($id)) {
1060                         $ids = $id;
1061                    } else { 
1062                         $ids = array(); 
1063                         $ids[] = $id; 
1064                    }
1065
1066                    $msg = '';
1067                    $newsletter_mailing = new newsletterMailing($core);         
1068                    $newsletter_settings = new newsletterSettings($core);
1069
1070                    // filtrage sur le type de mail
1071                    switch ($action) {
1072                         case 'newsletter':
1073                              $tmp_letter_id = self::insertMessageNewsletter($newsletter_mailing,$newsletter_settings,$l_post_id);
1074                              if ($tmp_letter_id === null) {
1075                                   /*
1076                                   $t_msg='';
1077                                   $t_msg.=date('Y-m-j H:i',time() + dt::getTimeOffset($system_settings->blog_timezone)).': ';
1078                                   $t_msg.=__('not enough posts for sending');
1079                                   $core->blog->dcNewsletter->addMessage($msg);
1080                                   //*/
1081                                   return false;
1082                              }
1083                              self::prepareMessagesNewsletter($ids,$newsletter_mailing,$newsletter_settings,$tmp_letter_id);
1084                              break;
1085                         case 'confirm':
1086                              self::prepareMessagesConfirm($ids,$newsletter_mailing,$newsletter_settings);
1087                              break;
1088                         case 'suspend':
1089                              self::prepareMessagesSuspend($ids,$newsletter_mailing,$newsletter_settings);
1090                              break;
1091                         case 'enable':
1092                              self::prepareMessagesEnable($ids,$newsletter_mailing,$newsletter_settings);
1093                              break;
1094                         case 'disable':
1095                              self::prepareMessagesDisable($ids,$newsletter_mailing,$newsletter_settings);
1096                              break;
1097                         case 'resume':
1098                              self::prepareMessagesResume($ids,$newsletter_mailing,$newsletter_settings);
1099                              break;
1100                         case 'changemode':
1101                              self::prepareMessagesChangeMode($ids,$newsletter_mailing,$newsletter_settings);
1102                              break;
1103                         default:
1104                              return false;
1105                    }
1106
1107                    // Envoi des messages
1108                    $newsletter_mailing->batchSend();
1109
1110                    if($action == 'newsletter') {
1111                         $newsletter_settings->setDatePreviousSend();
1112                         $newsletter_settings->save();
1113                         $msg=date('Y-m-j H:i',$newsletter_settings->getDatePreviousSend() + dt::getTimeOffset($system_settings->blog_timezone)).': ';
1114                    }                   
1115                   
1116                    $sent_states = $newsletter_mailing->getStates();
1117                    $sent_success = $newsletter_mailing->getSuccess();
1118                    $sent_errors = $newsletter_mailing->getErrors();
1119                    $sent_nothing = $newsletter_mailing->getNothingToSend();
1120                   
1121                    if (is_array($sent_states) && count($sent_states) > 0) {
1122                         // positionnement de l'état des comptes
1123                         switch ($action) {
1124                              case 'newsletter':
1125                                   self::lastsent($sent_states);
1126                                   break;
1127                              case 'confirm':
1128                                   self::confirm($sent_states);
1129                                   break;
1130                              case 'suspend': 
1131                                   self::suspend($sent_states);
1132                                   break;
1133                              case 'enable': 
1134                                   self::enable($sent_states);
1135                                   break;
1136                              case 'disable': 
1137                                   self::disable($sent_states);
1138                                   break;
1139                              case 'resume':
1140                                   break;
1141                              case 'changemode':
1142                                   break;
1143                         }
1144                    }         
1145               
1146                    if (isset($sent_success) && count($sent_success) > 0) 
1147                         $msg .= __('Successful mail sent for').' '.implode(', ', $sent_success).'<br />';
1148
1149                    if (isset($sent_errors) && count($sent_errors) > 0) {
1150                         $msg .= __('Mail sent error for').' '.implode(', ', $sent_errors).'<br />';
1151                         $core->blog->dcNewsletter->addError($msg);
1152                    }
1153
1154                    if (isset($sent_nothing) &&count($sent_nothing) > 0) 
1155                         $msg .= __('Nothing to send for').' '.implode(', ', $sent_nothing).'<br />';
1156                   
1157                    return $msg;
1158               }
1159          } catch (Exception $e) { 
1160               $core->blog->dcNewsletter->addError($e->getMessage());
1161          }
1162     }
1163
1164     /**
1165      * Prepare le message de type newsletter pour chaque subscriber
1166      * Modifie l'objet newsletterMailing fourni en parametre
1167      *
1168      * @param:     $ids                     array
1169      * @param:     $newsletter_mailing      newsletterMailing
1170      *
1171      * @return:    boolean
1172      */
1173     private static function prepareMessagesNewsletter($ids=-1,$newsletter_mailing, newsletterSettings $newsletter_settings, $letter_id=null)
1174     {
1175          global $core;
1176         
1177          $subject='';
1178          $body='';     
1179          $mode = $newsletter_settings->getSendMode();
1180
1181          // recupere le contenu de la letter
1182          $params = array();
1183          $params['post_type'] = 'newsletter';
1184          $params['post_id'] = (integer) $letter_id;
1185     
1186          $rs = $core->blog->getPosts($params);
1187         
1188          if ($rs->isEmpty()) {
1189               throw new Exception('No post for this ID');
1190          }
1191         
1192          // formatte les champs de la letter pour l'envoi
1193          $subject=text::toUTF8($rs->post_title);
1194          $body=$rs->post_content_xhtml;
1195          $body=text::toUTF8($body);
1196         
1197          foreach ($ids as $subscriber_id)
1198          {
1199               // get subscriber and extract datas
1200               $subscriber = self::get($subscriber_id);
1201
1202               // define mode for the current subscriber
1203               if (!$newsletter_settings->getUseDefaultFormat() && $subscriber->modesend != null) {
1204                    $mode = $subscriber->modesend;
1205               }
1206               
1207               /* Remplacement des liens pour les users */
1208               $patterns[0] = '/{\$urlDisable}/';
1209               $patterns[1] = '/{\$urlSuspend}/';
1210               $patterns[2] = '/{\$url_visu_online}/';
1211               //$patterns[3] = '/<\/head>/';
1212               $patterns[3] = '/<body>/';
1213               
1214               $replacements[0] = newsletterCore::url('disable/'.newsletterTools::base64_url_encode($subscriber->email));
1215               if($newsletter_settings->getCheckUseSuspend()) {       
1216                    $replacements[1] = newsletterCore::url('suspend/'.newsletterTools::base64_url_encode($subscriber->email));
1217               } else {
1218                    $replacements[1] = ' ';
1219               }
1220               $replacements[2] = newsletterLetter::getURL($letter_id);
1221               $replacements[3] = newsletterLetter::letter_style();
1222               $replacements[3] .= '<body>';
1223         
1224               /* chaine initiale */
1225               $count = 0;
1226               $scontent = preg_replace($patterns, $replacements, $body, 1, $count);
1227
1228               if($mode == 'text') {
1229                    $convert = new html2text();
1230                    $convert->set_html($scontent);
1231                    $convert->labelLinks = __('Links:');
1232                    $scontent = $convert->get_text();
1233               }
1234
1235               // ajoute le message dans la liste d'envoi
1236               $newsletter_mailing->addMessage($subscriber_id,$subscriber->email,$subject,$scontent,$mode);
1237          }
1238          return true;
1239     }
1240
1241     /**
1242      * Prepare le contenu des messages de type newsletter
1243      * Modifie l'objet newsletterMailing fourni en parametre
1244      *
1245      * @param:     $ids                     array
1246      * @param:     $newsletter_mailing      newsletterMailing
1247      *
1248      * @return:    boolean
1249      */
1250     public static function insertMessageNewsletter($newsletter_mailing, newsletterSettings $newsletter_settings, $l_post_id=null)
1251     {
1252          global $core;
1253         
1254               # Settings compatibility test
1255          if (version_compare(DC_VERSION,'2.2-alpha','>=')) {
1256               $system_settings = $core->blog->settings->system;
1257          } else {
1258               $system_settings =& $core->blog->settings;
1259          }         
1260         
1261          // initialisation des variables de travail
1262          $mode = $newsletter_settings->getSendMode();
1263          $subject = text::toUTF8($newsletter_settings->getNewsletterSubjectWithDate());
1264          $minPosts = $newsletter_settings->getMinPosts();
1265
1266          // initialisation du moteur de template
1267          self::BeforeSendmailTo($newsletter_settings->getPresentationMsg(), $newsletter_settings->getConcludingMsg());
1268
1269          // recuperation des billets
1270          $newsletter_posts = self::getNewsletterPosts($l_post_id);
1271         
1272          if(count($newsletter_posts) < $minPosts) {
1273               /*
1274               $t_msg='';
1275               $t_msg.=date('Y-m-j H:i',time() + dt::getTimeOffset($system_settings->blog_timezone)).': ';
1276               $t_msg.=__('not enough posts for sending');
1277               $core->blog->dcNewsletter->addMessage($t_msg);
1278               //*/
1279               return null;
1280          } else {
1281               $body = '';
1282
1283               // intégration dans le template des billets en génération du rendu
1284               nlTemplate::assign('posts', $newsletter_posts);
1285               
1286               $body = nlTemplate::render('newsletter', $mode);
1287                             
1288               if($mode == 'text') {
1289                    $convert = new html2text();
1290                    $convert->set_html($body);
1291                    $convert->labelLinks = __('Links:');
1292                    $body = $convert->get_text();
1293               }
1294                             
1295               // ajoute le message dans la liste d'envoi
1296               $old_nltr = new newsletterLetter($core);
1297               $old_nltr->insertOldLetter($subject,$body);
1298               return $old_nltr->getLetterId();
1299          }
1300     }
1301     
1302     /**
1303      * Prepare le contenu des messages de type confirm
1304      * Modifie l'objet newsletterMailing fourni en parametre
1305      *
1306      * @param:     $ids                     array
1307      * @param:     $newsletter_mailing      newsletterMailing
1308      *
1309      * @return:    boolean
1310      */
1311     private static function prepareMessagesConfirm($ids=-1,$newsletter_mailing,newsletterSettings $newsletter_settings)
1312     {
1313          // initialisation des variables de travail
1314          $mode = $newsletter_settings->getSendMode();
1315          $subject = text::toUTF8($newsletter_settings->getConfirmSubject());
1316
1317          // initialisation du moteur de template
1318          self::BeforeSendmailTo($newsletter_settings->getConfirmMsg(),$newsletter_settings->getConcludingConfirmMsg());
1319         
1320          // boucle sur les ids des abonnés
1321          foreach ($ids as $subscriber_id)
1322          {
1323               $body = '';
1324               // récupération de l'abonné et extraction des données
1325               $subscriber = self::get($subscriber_id);
1326
1327               // définition du format d'envoi
1328               if (!$newsletter_settings->getUseDefaultFormat() && $subscriber->modesend != null) {
1329                    $mode = $subscriber->modesend;
1330               }
1331
1332               // génération du rendu
1333               nlTemplate::assign('urlConfirm', self::url('confirm/'.newsletterTools::base64_url_encode($subscriber->email).'/'.$subscriber->regcode.'/'.newsletterTools::base64_url_encode($subscriber->modesend)));
1334               nlTemplate::assign('urlDisable', self::url('disable/'.newsletterTools::base64_url_encode($subscriber->email)));
1335
1336               $body = nlTemplate::render('confirm', $mode);
1337
1338               if($mode == 'text') {
1339                    $convert = new html2text();
1340                    $convert->set_html($body);
1341                    $convert->labelLinks = __('Links:');
1342                    $body = $convert->get_text();
1343               }
1344
1345               // ajoute le message dans la liste d'envoi
1346               $newsletter_mailing->addMessage($subscriber_id,$subscriber->email,$subject,$body,$mode);
1347          }
1348          return true;
1349     }
1350
1351     /**
1352      * Prepare le contenu des messages de type suspend
1353      * Modifie l'objet newsletterMailing fourni en parametre
1354      *
1355      * @param:     $ids                     array
1356      * @param:     $newsletter_mailing      newsletterMailing
1357      *
1358      * @return:    boolean
1359      */
1360     private static function prepareMessagesSuspend($ids=-1,$newsletter_mailing,newsletterSettings $newsletter_settings)
1361     {
1362          // initialisation des variables de travail
1363          $mode = $newsletter_settings->getSendMode();
1364          $subject = text::toUTF8($newsletter_settings->getSuspendSubject());
1365
1366          // initialisation du moteur de template
1367          self::BeforeSendmailTo($newsletter_settings->getSuspendMsg(),$newsletter_settings->getConcludingSuspendMsg());
1368
1369          // boucle sur les ids des abonnés
1370          foreach ($ids as $subscriber_id)
1371          {
1372               // récupération de l'abonné et extraction des données
1373               $subscriber = self::get($subscriber_id);
1374
1375               // définition du format d'envoi
1376               if (!$newsletter_settings->getUseDefaultFormat() && $subscriber->modesend != null) {
1377                    $mode = $subscriber->modesend;
1378               }
1379
1380               // génération du rendu
1381               nlTemplate::assign('urlEnable', self::url('enable/'.newsletterTools::base64_url_encode($subscriber->email)));
1382
1383               $body = nlTemplate::render('suspend', $mode);
1384               
1385               if($mode == 'text') {
1386                    $convert = new html2text();
1387                    $convert->set_html($body);
1388                    $convert->labelLinks = __('Links:');
1389                    $body = $convert->get_text();
1390               }
1391
1392               // ajoute le message dans la liste d'envoi
1393               $newsletter_mailing->addMessage($subscriber_id,$subscriber->email,$subject,$body,$mode);
1394          }
1395          return true;
1396     }
1397
1398     /**
1399      * Prepare le contenu des messages de type enable
1400      * Modifie l'objet newsletterMailing fourni en parametre
1401      *
1402      * @param:     $ids                     array
1403      * @param:     $newsletter_mailing      newsletterMailing
1404      *
1405      * @return:    boolean
1406      */
1407     private static function prepareMessagesEnable($ids=-1,$newsletter_mailing,newsletterSettings $newsletter_settings)
1408     {
1409          // initialisation des variables de travail
1410          $mode = $newsletter_settings->getSendMode();
1411          $subject = text::toUTF8($newsletter_settings->getEnableSubject());
1412
1413          // initialisation du moteur de template
1414          self::BeforeSendmailTo($newsletter_settings->getEnableMsg(),$newsletter_settings->getConcludingEnableMsg());
1415
1416          // boucle sur les ids des abonnés
1417          foreach ($ids as $subscriber_id)
1418          {
1419               // récupération de l'abonné et extraction des données
1420               $subscriber = self::get($subscriber_id);
1421
1422               // définition du format d'envoi
1423               if (!$newsletter_settings->getUseDefaultFormat() && $subscriber->modesend != null) {
1424                    $mode = $subscriber->modesend;
1425               }
1426
1427               // génération du rendu
1428               nlTemplate::assign('urlDisable', self::url('disable/'.newsletterTools::base64_url_encode($subscriber->email)));
1429                    if($newsletter_settings->getCheckUseSuspend()) {
1430                         nlTemplate::assign('urlSuspend', self::url('suspend/'.newsletterTools::base64_url_encode($subscriber->email)));
1431                    } else {
1432                         nlTemplate::assign('urlSuspend', ' ');
1433                    }
1434
1435               $body = nlTemplate::render('enable', $mode);
1436
1437               if($mode == 'text') {
1438                    $convert = new html2text();
1439                    $convert->set_html($body);
1440                    $convert->labelLinks = __('Links:');
1441                    $body = $convert->get_text();
1442               }
1443         
1444               // ajoute le message dans la liste d'envoi
1445               $newsletter_mailing->addMessage($subscriber_id,$subscriber->email,$subject,$body,$mode);
1446          }
1447          return true;
1448     }
1449
1450     /**
1451      * Prepare le contenu des messages de type disable
1452      * Modifie l'objet newsletterMailing fourni en parametre
1453      *
1454      * @param:     $ids                     array
1455      * @param:     $newsletter_mailing      newsletterMailing
1456      *
1457      * @return:    boolean
1458      */
1459     private static function prepareMessagesDisable($ids=-1,$newsletter_mailing,newsletterSettings $newsletter_settings)
1460     {
1461          // initialisation des variables de travail
1462          $mode = $newsletter_settings->getSendMode();
1463          $subject = text::toUTF8($newsletter_settings->getDisableSubject());
1464
1465          // initialisation du moteur de template
1466          self::BeforeSendmailTo($newsletter_settings->getDisableMsg(),$newsletter_settings->getConcludingDisableMsg());
1467
1468          // boucle sur les ids des abonnés
1469          foreach ($ids as $subscriber_id)
1470          {
1471               // récupération de l'abonné et extraction des données
1472               $subscriber = self::get($subscriber_id);
1473
1474               // définition du format d'envoi
1475               if (!$newsletter_settings->getUseDefaultFormat() && $subscriber->modesend != null) {
1476                    $mode = $subscriber->modesend;
1477               }
1478
1479               // génération du rendu
1480               nlTemplate::assign('urlEnable', self::url('enable/'.newsletterTools::base64_url_encode($subscriber->email)));
1481
1482               $body = nlTemplate::render('disable', $mode);
1483
1484               if($mode == 'text') {
1485                    $convert = new html2text();
1486                    $convert->set_html($body);
1487                    $convert->labelLinks = __('Links:');
1488                    $body = $convert->get_text();
1489               }
1490         
1491               // ajoute le message dans la liste d'envoi
1492               $newsletter_mailing->addMessage($subscriber_id,$subscriber->email,$subject,$body,$mode);
1493          }
1494          return true;
1495     }
1496
1497     /**
1498      * Prepare le contenu des messages de type resume
1499      * Modifie l'objet newsletterMailing fourni en parametre
1500      *
1501      * @param:     $ids                     array
1502      * @param:     $newsletter_mailing      newsletterMailing
1503      *
1504      * @return:    boolean
1505      */
1506     private static function prepareMessagesResume($ids=-1,$newsletter_mailing,newsletterSettings $newsletter_settings)
1507     {
1508          // initialisation des variables de travail
1509          $mode = $newsletter_settings->getSendMode();
1510          $subject = text::toUTF8($newsletter_settings->getResumeSubject());
1511
1512          // initialisation du moteur de template
1513          self::BeforeSendmailTo($newsletter_settings->getHeaderResumeMsg(),$newsletter_settings->getFooterResumeMsg());
1514
1515          // boucle sur les ids des abonnés
1516          foreach ($ids as $subscriber_id)
1517          {
1518               // récupération de l'abonné et extraction des données
1519               $subscriber = self::get($subscriber_id);
1520
1521               $txt_intro_enable = $newsletter_settings->getTxtIntroEnable().', ';
1522               $urlEnable = self::url('enable/'.newsletterTools::base64_url_encode($subscriber->email));
1523               $txtEnable = $newsletter_settings->getTxtEnable();
1524                         
1525               $txt_intro_disable = $newsletter_settings->getTxtIntroDisable().', ';
1526               $urlDisable = self::url('disable/'.newsletterTools::base64_url_encode($subscriber->email));
1527               $txtDisable = $newsletter_settings->getTxtDisable();
1528
1529               $txt_intro_suspend = $newsletter_settings->getTxtIntroSuspend().', ';
1530               $urlSuspend = self::url('suspend/'.newsletterTools::base64_url_encode($subscriber->email));
1531               $txtSuspend = $newsletter_settings->getTxtSuspend();
1532                         
1533               $txt_intro_confirm = $newsletter_settings->getTxtIntroConfirm().', ';
1534               $urlConfirm = self::url('confirm/'.newsletterTools::base64_url_encode($subscriber->email).'/'.$subscriber->regcode.'/'.newsletterTools::base64_url_encode($subscriber->modesend));
1535               $txtConfirm = $newsletter_settings->getTxtConfirm();
1536               
1537               $urlResume = '';
1538                         
1539               switch ($subscriber->state) {
1540                    case 'suspended':
1541                    {
1542                         $urlResume = $txt_intro_enable.' <a href="'.$urlEnable.'">'.$txtEnable.'</a><br />';
1543                         $urlResume .= $txt_intro_disable.' <a href="'.$urlDisable.'">'.$txtDisable.'</a>';
1544                         nlTemplate::assign('txtResume', __('Your account is suspended.'));
1545                         break;
1546                    }
1547                    case 'disabled':
1548                    {
1549                         $urlResume = $txt_intro_enable.' <a href="'.$urlEnable.'">'.$txtEnable.'</a><br />';
1550                         if($newsletter_settings->getCheckUseSuspend()) {
1551                              $urlResume .= $txt_intro_suspend.' <a href="'.$urlSuspend.'">'.$txtSuspend.'</a>';
1552                         }
1553                         nlTemplate::assign('txtResume', __('Your account is disabled.'));
1554                         break;
1555                    }
1556                    case 'enabled':
1557                    {
1558                         $urlResume = $txt_intro_disable.' <a href="'.$urlDisable.'">'.$txtDisable.'</a><br />';
1559                         if($newsletter_settings->getCheckUseSuspend()) {
1560                              $urlResume .= $txt_intro_suspend.' <a href="'.$urlSuspend.'">'.$txtSuspend.'</a>';
1561                         }
1562                         nlTemplate::assign('txtResume', __('Your account is enabled.'));
1563                         break;
1564                    }
1565                    case 'pending':
1566                    {
1567                         $urlResume = $txt_intro_disable.' <a href="'.$urlDisable.'">'.$txtDisable.'</a><br />';
1568                         $urlResume .= $txt_intro_confirm.' <a href="'.$urlConfirm.'">'.$txtConfirm.'</a>';
1569                         nlTemplate::assign('txtResume', __('Your account is pending confirmation.'));
1570                         break;
1571                    }
1572                    default:
1573                    {
1574                    }
1575               }
1576 
1577               // définition du format d'envoi
1578               if (!$newsletter_settings->getUseDefaultFormat() && $subscriber->modesend != null) {
1579                    $mode = $subscriber->modesend;
1580               }
1581
1582               nlTemplate::assign('txtMode', __('Your sending mode is'). ' ' .__(''.$mode.''). '.');
1583               nlTemplate::assign('urlResume', $urlResume);
1584               $body = nlTemplate::render('resume', $mode);
1585
1586               if($mode == 'text') {
1587                    $convert = new html2text();
1588                    $convert->set_html($body);
1589                    $convert->labelLinks = __('Links:');
1590                    $body = $convert->get_text();
1591               }
1592
1593               // ajoute le message dans la liste d'envoi
1594               $newsletter_mailing->addMessage($subscriber_id,$subscriber->email,$subject,$body,$mode);
1595          }
1596          return true;
1597     }
1598
1599     /**
1600      * Prepare le contenu des messages de type changemode
1601      * Modifie l'objet newsletterMailing fourni en parametre
1602      *
1603      * @param:     $ids                     array
1604      * @param:     $newsletter_mailing      newsletterMailing
1605      *
1606      * @return:    boolean
1607      */
1608     private static function prepareMessagesChangeMode($ids=-1,$newsletter_mailing,newsletterSettings $newsletter_settings)
1609     {
1610          // initialisation des variables de travail
1611          $mode = $newsletter_settings->getSendMode();
1612          $subject = text::toUTF8($newsletter_settings->getChangeModeSubject());
1613
1614          // initialisation du moteur de template
1615          self::BeforeSendmailTo($newsletter_settings->getHeaderChangeModeMsg(),$newsletter_settings->getFooterChangeModeMsg());       
1616
1617          // boucle sur les ids des abonnés
1618          foreach ($ids as $subscriber_id)
1619          {
1620               // récupération de l'abonné et extraction des données
1621               $subscriber = self::get($subscriber_id);
1622
1623               // définition du format d'envoi
1624               if (!$newsletter_settings->getUseDefaultFormat() && $subscriber->modesend != null) {
1625                    $mode = $subscriber->modesend;
1626               }                       
1627                         
1628               // génération du rendu
1629               nlTemplate::assign('urlEnable', self::url('enable/'.newsletterTools::base64_url_encode($subscriber->email)));
1630
1631               $body = nlTemplate::render('changemode', $mode);
1632
1633               if($mode == 'text') {
1634                    $convert = new html2text();
1635                    $convert->set_html($body);
1636                    $convert->labelLinks = __('Links:');
1637                    $body = $convert->get_text();
1638               }
1639
1640               // ajoute le message dans la liste d'envoi
1641               $newsletter_mailing->addMessage($subscriber_id,$subscriber->email,$subject,$body,$mode);
1642          }
1643          return true;
1644     }
1645
1646     /**
1647      * Envoi automatique de la newsletter pour tous les abonnés actifs
1648      *
1649      * @return:    boolean
1650      */
1651     public static function autosendNewsletter($l_post_id=null)
1652     {
1653          global $core;
1654
1655          # Settings compatibility test
1656          if (version_compare(DC_VERSION,'2.2-alpha','>=')) {
1657               $blog_settings =& $core->blog->settings->newsletter;
1658               $system_settings =& $core->blog->settings->system;
1659          } else {
1660               $blog_settings =& $core->blog->settings;
1661               $system_settings =& $core->blog->settings;
1662          }
1663                   
1664          $newsletter_flag = (boolean)$blog_settings->newsletter_flag;
1665         
1666          // test si le plugin est actif
1667          if (!$newsletter_flag) {
1668               return;
1669          }
1670         
1671          $newsletter_settings = new newsletterSettings($core);
1672         
1673          // test si l'envoi automatique est activé
1674          if ($newsletter_settings->getAutosend() || $newsletter_settings->getSendUpdatePost()) {
1675               
1676               $datas = self::getlist(true);
1677               if (!is_object($datas)) {
1678                    return;
1679               } else {
1680                    $ids = array();
1681                    $datas->moveStart();
1682                    while ($datas->fetch()) { 
1683                         $ids[] = $datas->subscriber_id;
1684                    }
1685
1686                    if ($newsletter_settings->getMinPosts() > 1) {
1687                         self::send($ids,'newsletter');
1688                    } else {
1689                         //$core->blog->dcNewsletter->addMessage('send post='.$l_post_id);
1690                         self::send($ids,'newsletter',$l_post_id);
1691                    }
1692               }             
1693          } else {
1694               return;
1695          }
1696     }
1697
1698     /**
1699      * Envoi par tâche planifiée de la newsletter pour tous les abonnés actifs
1700      *
1701      * @return:    boolean
1702      */
1703     public static function cronSendNewsletter()
1704     {
1705          global $core;
1706
1707          # Settings compatibility test
1708          if (version_compare(DC_VERSION,'2.2-alpha','>=')) {
1709               $blog_settings =& $core->blog->settings->newsletter;
1710               $system_settings = $core->blog->settings->system;
1711          } else {
1712               $blog_settings =& $core->blog->settings;
1713               $system_settings =& $core->blog->settings;
1714          }
1715                   
1716          $newsletter_flag = (boolean)$blog_settings->newsletter_flag;
1717         
1718          // test si le plugin est actif
1719          if (!$newsletter_flag) {
1720               return;
1721          }
1722
1723          $newsletter_settings = new newsletterSettings($core);       
1724          // test si la planification est activée
1725          if (!$newsletter_settings->getCheckSchedule()) {
1726               return;
1727          } else {
1728               $datas = self::getlist(true);
1729               if (!is_object($datas)) {
1730                    return;
1731               } else {
1732                    $ids = array();
1733                    $datas->moveStart();
1734                    while ($datas->fetch()) { 
1735                         $ids[] = $datas->subscriber_id;
1736                    }
1737                    self::send($ids,'newsletter');
1738               }
1739          }
1740     }
1741
1742     /* ==================================================
1743          gestion des comptes
1744     ================================================== */
1745
1746     /**
1747     * création du compte
1748     */
1749     public static function accountCreate($email = null, $regcode = null, $modesend = null)
1750     {
1751          global $core;
1752          try {         
1753               if ($email == null) {              // l'email doit être renseigné
1754                    return __('Bad email !');
1755               } else {                           // création du compte
1756                    if (self::getemail($email) != null) {
1757                         return __('Email already exist !');
1758                    } else if (!self::add($email, null, null, $modesend)) {
1759                         return __('Error creating account !');
1760                    } else {
1761                         $subscriber = self::getemail($email);
1762                         $msg = self::send($subscriber->subscriber_id,'confirm');
1763                         return $msg;
1764                    }
1765               }
1766          } catch (Exception $e) { 
1767               $core->blog->dcNewsletter->addError($e->getMessage());
1768          }
1769     }
1770
1771     /**
1772     * suppression du compte
1773     */
1774     public static function accountDelete($email = null)
1775     {
1776          global $core;
1777          try {         
1778               if ($email == null) {              // l'email doit être renseigné
1779                    return __('Bad email !');
1780               } else {                           // suppression du compte
1781                    $subscriber = self::getemail($email);
1782                    $msg = null;
1783                    if (!$subscriber || $subscriber->subscriber_id == null) 
1784                         return __('Email don\'t exist !');
1785                    else {
1786                         $msg = self::send($subscriber->subscriber_id,'disable');
1787                         self::delete($subscriber->subscriber_id);
1788                         return $msg;
1789                    }
1790               }
1791          } catch (Exception $e) { 
1792               $core->blog->dcNewsletter->addError($e->getMessage());
1793          }
1794     }
1795
1796     /**
1797     * suspension du compte
1798     */
1799     static function accountSuspend($email = null)
1800     {
1801          global $core;
1802          try {
1803
1804               if ($email == null) {              // l'email doit être renseigné
1805                    return __('Bad email !');
1806               } else {                           // suspension du compte
1807                    $subscriber = self::getemail($email);
1808                    $msg = '';
1809                    if (!$subscriber || $subscriber->subscriber_id == null) 
1810                         return __('Email don\'t exist !');
1811                    else {
1812                         $msg = self::send($subscriber->subscriber_id,'suspend');                       
1813                         self::suspend($subscriber->subscriber_id);
1814                         return $msg;
1815                    }
1816               }
1817          } catch (Exception $e) { 
1818               $core->blog->dcNewsletter->addError($e->getMessage());
1819          }
1820     }
1821
1822     /**
1823     * information sur le compte
1824     */
1825     public static function accountResume($email = null)
1826     {
1827          global $core;
1828          try {         
1829               if ($email == null) {              // l'email doit être renseigné
1830                    return __('Bad email !');
1831               } else {                           // information sur le compte
1832                    $subscriber = self::getemail($email);
1833                    $msg = '';
1834                    if (!$subscriber || $subscriber->subscriber_id == null) 
1835                         return __('Email don\'t exist !');
1836                    else {
1837                         $msg = self::send($subscriber->subscriber_id,'resume');                         
1838                         //self::resume($subscriber->subscriber_id);
1839                         return $msg;
1840                    }
1841               }
1842          } catch (Exception $e) { 
1843               $core->blog->dcNewsletter->addError($e->getMessage());
1844          }         
1845     }
1846
1847     /**
1848     * changement du format sur le compte
1849     */
1850     public static function accountChangeMode($email = null, $modesend = null)
1851     {
1852          global $core;
1853          try {
1854               if ($email == null) {              // l'email doit être renseigné
1855                    return __('Bad email !');
1856               } else {                           // information sur le compte
1857                    $subscriber = self::getemail($email);
1858                    $msg = '';
1859                    if (!$subscriber || $subscriber->subscriber_id == null) 
1860                         return __('Email don\'t exist !');
1861                    else {
1862                         $msg = self::send($subscriber->subscriber_id,'changemode');                     
1863                         self::changeMode($subscriber->subscriber_id, $modesend);
1864                         return $msg;
1865                    }
1866               }
1867          } catch (Exception $e) { 
1868               $core->blog->dcNewsletter->addError($e->getMessage());
1869          }
1870     }
1871     
1872} // end class newsletterCore
1873
1874?>
Note: See TracBrowser for help on using the repository browser.

Sites map