include/newsletter.inc.php

   1 <?php
   2 /***************************************************************************
   3  *  Copyright (C) 2003-2011 Polytechnique.org                              *
   4  *  http://opensource.polytechnique.org/                                   *
   5  *                                                                         *
   6  *  This program is free software; you can redistribute it and/or modify   *
   7  *  it under the terms of the GNU General Public License as published by   *
   8  *  the Free Software Foundation; either version 2 of the License, or      *
   9  *  (at your option) any later version.                                    *
  10  *                                                                         *
  11  *  This program is distributed in the hope that it will be useful,        *
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  14  *  GNU General Public License for more details.                           *
  15  *                                                                         *
  16  *  You should have received a copy of the GNU General Public License      *
  17  *  along with this program; if not, write to the Free Software            *
  18  *  Foundation, Inc.,                                                      *
  19  *  59 Temple Place, Suite 330, Boston, MA  02111-1307  USA                *
  20  ***************************************************************************/
  21
  22 // {{{ class MailNotFound
  23
  24 class MailNotFound extends Exception {
  25 }
  26
  27 // }}}
  28
  29 // {{{ class NewsLetter
  30
  31 class NewsLetter
  32 {
  33     public $id;  // ID of the NL (in table newsletters)
  34     public $group;  // Short name of the group corresponding to the NL
  35     public $group_id;  // ID of that group
  36     public $name;  // Name of the NL (e.g "Lettre de Polytechnique.org", ...)
  37     public $cats;  // List of all categories for this NL
  38     public $criteria;  // PlFlagSet of allowed filters for recipient selection
  39
  40     protected $custom_css = false;
  41
  42     // Base name to use instead of the group short name for NLs without a custom CSS
  43     const FORMAT_DEFAULT_GROUP = 'default';
  44
  45     // Diminutif of X.net groups with a specific NL view
  46     const GROUP_XORG = 'Polytechnique.org';
  47     const GROUP_AX = 'AX';
  48     const GROUP_EP = 'Ecole';
  49
  50     // Searches on mutiple fields
  51     const SEARCH_ALL = 'all';
  52     const SEARCH_TITLE = 'title';
  53
  54
  55     // {{{ Constructor, NewsLetter retrieval (forGroup, getAll)
  56
  57     public function __construct($id)
  58     {
  59         // Load NL data
  60         $res = XDB::query('SELECT  nls.group_id, g.diminutif AS group_name,
  61                                    nls.name AS nl_name, nls.custom_css, nls.criteria
  62                              FROM  newsletters AS nls
  63                         LEFT JOIN  groups AS g ON (nls.group_id = g.id)
  64                             WHERE  nls.id = {?}',
  65                             $id);
  66         if (!$res->numRows()) {
  67             throw new MailNotFound();
  68         }
  69
  70         $data = $res->fetchOneAssoc();
  71         $this->id = $id;
  72         $this->group_id = $data['group_id'];
  73         $this->group = $data['group_name'];
  74         $this->name = $data['nl_name'];
  75         $this->custom_css = $data['custom_css'];
  76         $this->criteria = new PlFlagSet($data['criteria']);
  77
  78         // Load the categories
  79         $res = XDB::iterRow(
  80             'SELECT  cid, title
  81                FROM  newsletter_cat
  82               WHERE  nlid = {?}
  83            ORDER BY  pos', $id);
  84         while (list($cid, $title) = $res->next()) {
  85             $this->cats[$cid] = $title;
  86         }
  87     }
  88
  89     /** Retrieve the NL associated with a given group.
  90      * @p $group Short name of the group
  91      * @return A NewsLetter object, or null if the group doesn't have a NL.
  92      */
  93     public static function forGroup($group)
  94     {
  95         $res = XDB::query('SELECT  nls.id
  96                              FROM  newsletters AS nls
  97                         LEFT JOIN  groups AS g ON (nls.group_id = g.id)
  98                             WHERE  g.diminutif = {?}', $group);
  99         if (!$res->numRows()) {
 100             return null;
 101         }
 102         return new NewsLetter($res->fetchOneCell());
 103     }
 104
 105     /** Retrieve all newsletters
 106      * @return An array of $id => NewsLetter objects
 107      */
 108     public static function getAll()
 109     {
 110         $res = XDB::query('SELECT  id
 111                              FROM  newsletters');
 112         $nls = array();
 113         foreach ($res->fetchColumn() as $id) {
 114             $nls[$id] = new NewsLetter($id);
 115         }
 116         return $nls;
 117     }
 118
 119     // }}}
 120     // {{{ Issue retrieval
 121
 122     /** Retrieve all issues which should be sent
 123      * @return An array of NLIssue objects to send (i.e state = 'new' and send_before <= today)
 124      */
 125     public static function getIssuesToSend()
 126     {
 127         $res = XDB::query('SELECT  id
 128                              FROM  newsletter_issues
 129                             WHERE  state = \'pending\' AND send_before <= NOW()');
 130         $issues = array();
 131         foreach ($res->fetchColumn() as $id) {
 132             $issues[$id] = new NLIssue($id);
 133         }
 134         return $issues;
 135     }
 136
 137     /** Retrieve a given issue of this NewsLetter
 138      * @p $name Name or ID of the issue to retrieve.
 139      * @return A NLIssue object.
 140      *
 141      * $name may be either a short_name, an ID or the special value 'last' which
 142      * selects the latest sent NL.
 143      * If $name is null, this will retrieve the current pending NL.
 144      */
 145     public function getIssue($name = null, $only_sent = true)
 146     {
 147         if ($name) {
 148             if ($name == 'last') {
 149                 if ($only_sent) {
 150                     $where = 'state = \'sent\' AND ';
 151                 } else {
 152                     $where = '';
 153                 }
 154                 $res = XDB::query('SELECT  MAX(id)
 155                                      FROM  newsletter_issues
 156                                     WHERE  ' . $where . ' nlid = {?}',
 157                                    $this->id);
 158             } else {
 159                 $res = XDB::query('SELECT  id
 160                                      FROM  newsletter_issues
 161                                     WHERE  nlid = {?} AND (id = {?} OR short_name = {?})',
 162                                   $this->id, $name, $name);
 163             }
 164             if (!$res->numRows()) {
 165                 throw new MailNotFound();
 166             }
 167             $id = $res->fetchOneCell();
 168         } else {
 169             $query = XDB::format('SELECT  id
 170                                     FROM  newsletter_issues
 171                                    WHERE  nlid = {?} AND state = \'new\'
 172                                 ORDER BY  id DESC', $this->id);
 173             $res = XDB::query($query);
 174             if ($res->numRows()) {
 175                 $id = $res->fetchOneCell();
 176             } else {
 177                 // Create a new, empty issue, and return it
 178                 $id = $this->createPending();
 179             }
 180         }
 181
 182         return new NLIssue($id, $this);
 183     }
 184
 185     /** Create a new, empty, pending newsletter issue
 186      * @p $nlid The id of the NL for which a new pending issue should be created.
 187      * @return Id of the newly created issue.
 188      */
 189     public function createPending()
 190     {
 191         XDB::execute('INSERT INTO  newsletter_issues
 192                               SET  nlid = {?}, state=\'new\', date=NOW(),
 193                                    title=\'to be continued\',
 194                                    mail_title=\'to be continued\'',
 195                                    $this->id);
 196         return XDB::insertId();
 197     }
 198
 199     /** Return all sent issues of this newsletter.
 200      * @return An array of (id => NLIssue)
 201      */
 202     public function listSentIssues($check_user = false, $user = null)
 203     {
 204         if ($check_user && $user == null) {
 205             $user = S::user();
 206         }
 207
 208         $res = XDB::query('SELECT  id
 209                              FROM  newsletter_issues
 210                             WHERE  nlid = {?} AND state = \'sent\'
 211                          ORDER BY  date DESC', $this->id);
 212         $issues = array();
 213         foreach ($res->fetchColumn() as $id) {
 214             $issue = new NLIssue($id, $this, false);
 215             if (!$check_user || $issue->checkUser($user)) {
 216                 $issues[$id] = $issue;
 217             }
 218         }
 219         return $issues;
 220     }
 221
 222     /** Return all issues of this newsletter, including invalid and sent.
 223      * @return An array of (id => NLIssue)
 224      */
 225     public function listAllIssues()
 226     {
 227         $res = XDB::query('SELECT  id
 228                              FROM  newsletter_issues
 229                             WHERE  nlid = {?}
 230                          ORDER BY  FIELD(state, \'pending\', \'new\') DESC, date DESC', $this->id);
 231         $issues = array();
 232         foreach ($res->fetchColumn() as $id) {
 233             $issues[$id] = new NLIssue($id, $this, false);
 234         }
 235         return $issues;
 236     }
 237
 238     /** Return the latest pending issue of the newsletter.
 239      * @p $create Whether to create an empty issue if no pending issue exist.
 240      * @return Either null, or a NL object.
 241      */
 242     public function getPendingIssue($create = false)
 243     {
 244         $res = XDB::query('SELECT  MAX(id)
 245                              FROM  newsletter_issues
 246                             WHERE  nlid = {?} AND state = \'new\'',
 247                             $this->id);
 248         $id = $res->fetchOneCell();
 249         if ($id != null) {
 250             return new NLIssue($id, $this);
 251         } else if ($create) {
 252             $id = $this->createPending();
 253             return new NLIssue($id, $this);
 254         } else {
 255             return null;
 256         }
 257     }
 258
 259     /** Returns a list of either issues or articles corresponding to the search.
 260      * @p $search The searched pattern.
 261      * @p $field The fields where to search, if none given, search in all possible fields.
 262      * @return The list of object found.
 263      */
 264     public function issueSearch($search, $field, $user)
 265     {
 266         $search = XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $search);
 267         if ($field == self::SEARCH_ALL) {
 268             $where = '(title ' . $search . ' OR mail_title ' . $search . ' OR head ' . $search . ' OR signature ' . $search . ')';
 269         } elseif ($field == self::SEARCH_TITLE) {
 270             $where = '(title ' . $search . ' OR mail_title ' . $search . ')';
 271         } else {
 272             $where = $field . $search;
 273         }
 274         $list = XDB::fetchColumn('SELECT  DISTINCT(id)
 275                                     FROM  newsletter_issues
 276                                    WHERE  nlid = {?} AND state = \'sent\' AND ' . $where . '
 277                                 ORDER BY  date DESC',
 278                                  $this->id);
 279
 280         $issues = array();
 281         foreach ($list as $id) {
 282             $issue = new NLIssue($id, $this, false);
 283             if ($issue->checkUser($user)) {
 284                 $issues[] = $issue;
 285             }
 286         }
 287         return $issues;
 288     }
 289
 290     public function articleSearch($search, $field, $user)
 291     {
 292         $search = XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $search);
 293         if ($field == self::SEARCH_ALL) {
 294             $where = '(a.title ' . $search . ' OR a.body ' . $search . ' OR a.append ' . $search . ')';
 295         } else {
 296             $where = 'a.' . $field . $search;
 297         }
 298         $list = XDB::fetchAllAssoc('SELECT  i.short_name, a.aid, i.id, a.title
 299                                       FROM  newsletter_art    AS a
 300                                 INNER JOIN  newsletter_issues AS i ON (a.id = i.id)
 301                                      WHERE  i.nlid = {?} AND i.state = \'sent\' AND ' . $where . '
 302                                   GROUP BY  a.id, a.aid
 303                                   ORDER BY  i.date DESC, a.aid',
 304                                    $this->id);
 305
 306         $articles = array();
 307         foreach ($list as $item) {
 308             $issue = new NLIssue($item['id'], $this, false);
 309             if ($issue->checkUser($user)) {
 310                 $articles[] = $item;
 311             }
 312         }
 313         return $articles;
 314     }
 315
 316     // }}}
 317     // {{{ Subscription related function
 318
 319     /** Unsubscribe a user from this newsletter
 320      * @p $uid UID to unsubscribe from the newsletter; if null, use current user.
 321      * @p $hash True if the uid is actually a hash.
 322      * @return True if the user was successfully unsubscribed.
 323      */
 324     public function unsubscribe($uid = null, $hash = false)
 325     {
 326         if (is_null($uid) && $hash) {
 327             // Unable to unsubscribe from an empty hash
 328             return false;
 329         }
 330         $user = is_null($uid) ? S::user()->id() : $uid;
 331         $field = $hash ? 'hash' : 'uid';
 332         $res = XDB::query('SELECT  uid
 333                              FROM  newsletter_ins
 334                             WHERE  nlid = {?} AND ' . $field . ' = {?}',
 335                             $this->id, $user);
 336         if (!$res->numRows()) {
 337             // No subscribed user with that UID/hash
 338             return false;
 339         }
 340         $user = $res->fetchOneCell();
 341
 342         XDB::execute('DELETE FROM  newsletter_ins
 343                             WHERE  nlid = {?} AND uid = {?}',
 344                             $this->id, $user);
 345         return true;
 346     }
 347
 348     /** Subscribe a user to a newsletter
 349      * @p $user User to subscribe to the newsletter; if null, use current user.
 350      */
 351     public function subscribe($user = null)
 352     {
 353         if (is_null($user)) {
 354             $user = S::user();
 355         }
 356         if (self::maySubscribe($user)) {
 357             XDB::execute('INSERT IGNORE INTO  newsletter_ins (nlid, uid, last, hash)
 358                                       VALUES  ({?}, {?}, NULL, hash)',
 359                          $this->id, $user->id());
 360         }
 361     }
 362
 363     /** Retrieve subscription state of a user
 364      * @p $user Target user; if null, use current user.
 365      * @return Boolean: true if the user has subscribed to the NL.
 366      */
 367     public function subscriptionState($user = null)
 368     {
 369         if (is_null($user)) {
 370             $user = S::user();
 371         }
 372         $res = XDB::query('SELECT  1
 373                              FROM  newsletter_ins
 374                             WHERE  nlid = {?} AND uid = {?}',
 375                           $this->id, $user->id());
 376         return ($res->numRows() == 1);
 377     }
 378
 379     /** Get the count of subscribers to the NL.
 380      * @return Number of subscribers.
 381      */
 382     public function subscriberCount()
 383     {
 384         return XDB::fetchOneCell('SELECT  COUNT(uid)
 385                                     FROM  newsletter_ins
 386                                    WHERE  nlid = {?}', $this->id);
 387     }
 388
 389     /** Get the number of subscribers to the NL whose last received mailing was $last.
 390      * @p $last ID of the issue for which subscribers should be counted.
 391      * @return Number of subscribers
 392      */
 393     public function subscriberCountForLast($last)
 394     {
 395         return XDB::fetchOneCell('SELECT  COUNT(uid)
 396                                     FROM  newsletter_ins
 397                                    WHERE  nlid = {?} AND last = {?}', $this->id, $last);
 398     }
 399
 400     /** Retrieve the list of newsletters a user has subscribed to
 401      * @p $user User whose subscriptions should be retrieved (if null, use session user).
 402      * @return Array of newsletter IDs
 403      */
 404     public static function getUserSubscriptions($user = null)
 405     {
 406         if (is_null($user)) {
 407             $user = S::user();
 408         }
 409         $res = XDB::query('SELECT  nlid
 410                              FROM  newsletter_ins
 411                             WHERE  uid = {?}',
 412                           $user->id());
 413         return $res->fetchColumn();
 414     }
 415
 416     /** Retrieve the UserFilterBuilder for subscribers to this NL.
 417      * This is the place where NL-specific filters may be allowed or prevented.
 418      * @p $envprefix Prefix to use for env fields (cf. UserFilterBuilder)
 419      * @return A UserFilterBuilder object using the given env prefix
 420      */
 421     public function getSubscribersUFB($envprefix = '')
 422     {
 423         require_once 'ufbuilder.inc.php';
 424         return new UFB_NewsLetter($this->criteria, $envprefix);
 425     }
 426
 427     // }}}
 428     // {{{ Permissions related functions
 429
 430     /** For later use: check whether a given user may subscribe to this newsletter.
 431      * @p $user User whose access should be checked
 432      * @return Boolean: whether the user may subscribe to the NL.
 433      */
 434     public function maySubscribe($user = null)
 435     {
 436         return true;
 437     }
 438
 439     /** Whether a given user may edit this newsletter
 440      * @p $uid UID of the user whose perms should be checked (if null, use current user)
 441      * @return Boolean: whether the user may edit the NL
 442      */
 443     public function mayEdit($user = null)
 444     {
 445         if (is_null($user)) {
 446             $user = S::user();
 447         }
 448         if ($user->checkPerms('admin')) {
 449             return true;
 450         }
 451         $res = XDB::query('SELECT  perms
 452                              FROM  group_members
 453                             WHERE  asso_id = {?} AND uid = {?}',
 454                             $this->group_id, $user->id());
 455         return ($res->numRows() && $res->fetchOneCell() == 'admin');
 456     }
 457
 458     /** Whether a given user may submit articles to this newsletter using X.org validation system
 459      * @p $user User whose access should be checked (if null, use current user)
 460      * @return Boolean: whether the user may submit articles
 461      */
 462     public function maySubmit($user = null)
 463     {
 464         // Submission of new articles is only enabled for the X.org NL (and forbidden when viewing issues on X.net)
 465         return ($this->group == self::GROUP_XORG && !isset($GLOBALS['IS_XNET_SITE']));
 466     }
 467
 468     // }}}
 469     // {{{ Display-related functions: cssFile, tplFile, prefix, admin_prefix, admin_links_enabled, automatic_mailings_enabled
 470
 471     /** Get the name of the css file used to display this newsletter.
 472      */
 473     public function cssFile()
 474     {
 475         if ($this->custom_css) {
 476             $base = $this->group;
 477         } else {
 478             $base = self::FORMAT_DEFAULT_GROUP;
 479         }
 480         return 'nl.' . $base . '.css';
 481     }
 482
 483     /** Get the name of the template file used to display this newsletter.
 484      */
 485     public function tplFile()
 486     {
 487         if ($this->custom_css) {
 488             $base = $this->group;
 489         } else {
 490             $base = self::FORMAT_DEFAULT_GROUP;
 491         }
 492         return 'newsletter/nl.' . $base . '.mail.tpl';
 493     }
 494
 495     /** Get the prefix leading to the page for this NL
 496      * Only X.org / AX / X groups may be seen on X.org.
 497      */
 498     public function prefix($enforce_xnet=true)
 499     {
 500         if (!empty($GLOBALS['IS_XNET_SITE'])) {
 501             return $this->group . '/nl';
 502         }
 503         switch ($this->group) {
 504         case self::GROUP_XORG:
 505             return 'nl';
 506         case self::GROUP_AX:
 507             return 'ax';
 508         case self::GROUP_EP:
 509             return 'epletter';
 510         default:
 511             // Don't display groups NLs on X.org
 512             assert(!$enforce_xnet);
 513         }
 514     }
 515
 516     /** Get the prefix to use for all 'admin' pages of this NL.
 517      */
 518     public function adminPrefix($enforce_xnet=true)
 519     {
 520         if (!empty($GLOBALS['IS_XNET_SITE'])) {
 521             return $this->group . '/admin/nl';
 522         }
 523         switch ($this->group) {
 524         case self::GROUP_XORG:
 525             return 'admin/newsletter';
 526         case self::GROUP_AX:
 527             return 'ax/admin';
 528         case self::GROUP_EP:
 529             return 'epletter/admin';
 530         default:
 531             // Don't display groups NLs on X.org
 532             assert(!$enforce_xnet);
 533         }
 534     }
 535
 536     /** Hack used to remove "admin" links on X.org page on X.net
 537      * The 'admin' links are enabled for all pages, except for X.org when accessing NL through X.net
 538      */
 539     public function adminLinksEnabled()
 540     {
 541         return ($this->group != self::GROUP_XORG || !isset($GLOBALS['IS_XNET_SITE']));
 542     }
 543
 544     /** Automatic mailings are disabled for X.org NL.
 545      */
 546     public function automaticMailingEnabled()
 547     {
 548         return $this->group != self::GROUP_XORG;
 549     }
 550
 551     public function hasCustomCss()
 552     {
 553         return $this->custom_css;
 554     }
 555
 556     // }}}
 557 }
 558
 559 // }}}
 560
 561 // {{{ class NLIssue
 562
 563 // A NLIssue is an issue of a given NewsLetter
 564 class NLIssue
 565 {
 566     protected $nlid;  // Id of the newsletter
 567
 568     const STATE_NEW = 'new';  // New, currently being edited
 569     const STATE_PENDING = 'pending';  // Ready for mailing
 570     const STATE_SENT = 'sent';  // Sent
 571
 572     public $nl;  // Related NL
 573
 574     public $id;  // Id of this issue of the newsletter
 575     public $shortname;  // Shortname for this issue
 576     public $title;  // Title of this issue
 577     public $title_mail;  // Title of the email
 578     public $state;  // State of the issue (one of the STATE_ values)
 579     public $sufb;  // Environment to use to generate the UFC through an UserFilterBuilder
 580
 581     public $date;  // Date at which this issue was sent
 582     public $send_before;  // Date at which issue should be sent
 583     public $head;  // Foreword of the issue (or body for letters with no articles)
 584     public $signature;  // Signature of the letter
 585     public $arts = array();  // Articles of the issue
 586
 587     const BATCH_SIZE = 60;  // Number of emails to send every minute.
 588
 589     // {{{ Constructor, id-related functions
 590
 591     /** Build a NewsLetter.
 592      * @p $id: ID of the issue (unique among all newsletters)
 593      * @p $nl: Optional argument containing an already built NewsLetter object.
 594      */
 595     function __construct($id, $nl = null, $fetch_articles = true)
 596     {
 597         return $this->fetch($id, $nl, $fetch_articles);
 598     }
 599
 600     protected function refresh()
 601     {
 602         return $this->fetch($this->id, $this->nl, false);
 603     }
 604
 605     protected function fetch($id, $nl = null, $fetch_articles = true)
 606     {
 607         // Load this issue
 608         $res = XDB::query('SELECT  nlid, short_name, date, send_before, state, sufb_json,
 609                                    title, mail_title, head, signature
 610                              FROM  newsletter_issues
 611                             WHERE  id = {?}',
 612                           $id);
 613         if (!$res->numRows()) {
 614             throw new MailNotFound();
 615         }
 616         $issue = $res->fetchOneAssoc();
 617         if ($nl && $nl->id == $issue['nlid']) {
 618             $this->nl = $nl;
 619         } else {
 620             $this->nl = new NewsLetter($issue['nlid']);
 621         }
 622         $this->id = $id;
 623         $this->nlid        = $issue['nlid'];
 624         $this->shortname   = $issue['short_name'];
 625         $this->date        = $issue['date'];
 626         $this->send_before = $issue['send_before'];
 627         $this->state       = $issue['state'];
 628         $this->title       = $issue['title'];
 629         $this->title_mail  = $issue['mail_title'];
 630         $this->head        = $issue['head'];
 631         $this->signature   = $issue['signature'];
 632         $this->sufb        = $this->importJSonStoredUFB($issue['sufb_json']);
 633
 634         if ($fetch_articles) {
 635             $this->fetchArticles();
 636         }
 637     }
 638
 639     protected function fetchArticles($force = false)
 640     {
 641         if (count($this->arts) && !$force) {
 642             return;
 643         }
 644
 645         // Load the articles
 646         $res = XDB::iterRow(
 647             'SELECT  a.title, a.body, a.append, a.aid, a.cid, a.pos
 648                FROM  newsletter_art AS a
 649          INNER JOIN  newsletter_issues AS ni USING(id)
 650          LEFT  JOIN  newsletter_cat AS c ON (a.cid = c.cid)
 651               WHERE  a.id = {?}
 652            ORDER BY  c.pos, a.pos',
 653            $this->id);
 654         while (list($title, $body, $append, $aid, $cid, $pos) = $res->next()) {
 655             $this->arts[$cid][$aid] = new NLArticle($title, $body, $append, $aid, $cid, $pos);
 656         }
 657     }
 658
 659     protected function importJSonStoredUFB($json = null)
 660     {
 661         require_once 'ufbuilder.inc.php';
 662         $ufb = $this->nl->getSubscribersUFB();
 663         if (is_null($json)) {
 664             return new StoredUserFilterBuilder($ufb, new PFC_True());
 665         }
 666         $export = json_decode($json, true);
 667         if (is_null($export)) {
 668             PlErrorReport::report("Invalid json while reading NL {$this->nlid}, issue {$this->id}: failed to import '''{$json}'''.");
 669             return new StoredUserFilterBuilder($ufb, new PFC_True());
 670         }
 671         $sufb = new StoredUserFilterBuilder($ufb);
 672         $sufb->fillFromExport($export);
 673         return $sufb;
 674     }
 675
 676     protected function exportStoredUFBAsJSon()
 677     {
 678         return json_encode($this->sufb->export());
 679     }
 680
 681     public function id()
 682     {
 683         return is_null($this->shortname) ? $this->id : $this->shortname;
 684     }
 685
 686     protected function selectId($where)
 687     {
 688         $res = XDB::query("SELECT  IFNULL(ni.short_name, ni.id)
 689                              FROM  newsletter_issues AS ni
 690                             WHERE  ni.state != 'new' AND ni.nlid = {?} AND ${where}
 691                             LIMIT  1", $this->nl->id);
 692         if ($res->numRows() != 1) {
 693             return null;
 694         }
 695         return $res->fetchOneCell();
 696     }
 697
 698     /** Delete this issue
 699      * @return True if the issue could be deleted, false otherwise.
 700      * Related articles will be deleted through cascading FKs.
 701      * If this issue was the last issue for at least one subscriber, the deletion will be aborted.
 702      */
 703     public function delete()
 704     {
 705         if ($this->state == self::STATE_NEW) {
 706             $res = XDB::query('SELECT  COUNT(*)
 707                                  FROM  newsletter_ins
 708                                 WHERE  last = {?}', $this->id);
 709             if ($res->fetchOneCell() > 0) {
 710                 return false;
 711             }
 712
 713             return XDB::execute('DELETE FROM  newsletter_issues
 714                                        WHERE  id = {?}', $this->id);
 715         } else {
 716             return false;
 717         }
 718     }
 719
 720     /** Schedule a mailing of this NL
 721      * If the 'send_before' field was NULL, it is set to the current time.
 722      * @return Boolean Whether the date could be set (false if trying to schedule an already sent NL)
 723      */
 724     public function scheduleMailing()
 725     {
 726         if ($this->state == self::STATE_NEW) {
 727             $success = XDB::execute('UPDATE  newsletter_issues
 728                                         SET  state = \'pending\', send_before = IFNULL(send_before, NOW())
 729                                       WHERE  id = {?}',
 730                                       $this->id);
 731             if ($success) {
 732                 global $globals;
 733                 $mailer = new PlMailer('newsletter/notify_scheduled.mail.tpl');
 734                 $mailer->assign('issue', $this);
 735                 $mailer->assign('base', $globals->baseurl);
 736                 $mailer->send();
 737                 $this->refresh();
 738             }
 739             return $success;
 740         } else {
 741             return false;
 742         }
 743     }
 744
 745     /** Cancel the scheduled mailing of this NL
 746      * @return Boolean: whether the mailing could be cancelled.
 747      */
 748     public function cancelMailing()
 749     {
 750         if ($this->state == self::STATE_PENDING) {
 751             $success = XDB::execute('UPDATE  newsletter_issues
 752                                         SET  state = \'new\'
 753                                       WHERE  id = {?}', $this->id);
 754             if ($success) {
 755                 $this->refresh();
 756             }
 757             return $success;
 758         } else {
 759             return false;
 760         }
 761     }
 762
 763     /** Helper function for smarty templates: is this issue editable ?
 764      */
 765     public function isEditable()
 766     {
 767         return $this->state == self::STATE_NEW;
 768     }
 769
 770     /** Helper function for smarty templates: is the mailing of this issue scheduled ?
 771      */
 772     public function isPending()
 773     {
 774         return $this->state == self::STATE_PENDING;
 775     }
 776
 777     /** Helper function for smarty templates: has this issue been sent ?
 778      */
 779     public function isSent()
 780     {
 781         return $this->state == self::STATE_SENT;
 782     }
 783
 784     // }}}
 785     // {{{ Navigation
 786
 787     private $id_prev = null;
 788     private $id_next = null;
 789     private $id_last = null;
 790
 791     /** Retrieve ID of the previous issue
 792      * That value, once fetched, is cached in the private $id_prev variable.
 793      * @return ID of the previous issue.
 794      */
 795     public function prev()
 796     {
 797         if (is_null($this->id_prev)) {
 798             $this->id_prev = $this->selectId(XDB::format("ni.id < {?} ORDER BY ni.id DESC", $this->id));
 799         }
 800         return $this->id_prev;
 801     }
 802
 803     /** Retrieve ID of the following issue
 804      * That value, once fetched, is cached in the private $id_next variable.
 805      * @return ID of the following issue.
 806      */
 807     public function next()
 808     {
 809         if (is_null($this->id_next)) {
 810             $this->id_next = $this->selectId(XDB::format("ni.id > {?} ORDER BY ni.id", $this->id));
 811         }
 812         return $this->id_next;
 813     }
 814
 815     /** Retrieve ID of the last issue
 816      * That value, once fetched, is cached in the private $id_last variable.
 817      * @return ID of the last issue.
 818      */
 819     public function last()
 820     {
 821         if (is_null($this->id_last)) {
 822             $this->id_last = $this->nl->getIssue('last')->id;
 823         }
 824         return $this->id_last;
 825     }
 826
 827     // }}}
 828     // {{{ Edition, articles
 829
 830     const ERROR_INVALID_SHORTNAME = 'invalid_shortname';
 831     const ERROR_INVALID_UFC = 'invalid_ufc';
 832     const ERROR_SQL_SAVE = 'sql_error';
 833
 834     /** Save the global properties of this NL issue (title&co).
 835      */
 836     public function save()
 837     {
 838         $errors = array();
 839
 840         // Fill the list of fields to update
 841         $fields = array(
 842             'title' => $this->title,
 843             'mail_title' => $this->title_mail,
 844             'head' => $this->head,
 845             'signature' => $this->signature,
 846         );
 847
 848         if ($this->isEditable()) {
 849             $fields['date'] = $this->date;
 850             if (!preg_match('/^[-a-z0-9]+$/i', $this->shortname) || is_numeric($this->shortname)) {
 851                 $errors[] = self::ERROR_INVALID_SHORTNAME;
 852             } else {
 853                 $fields['short_name'] = $this->shortname;
 854             }
 855             if ($this->sufb->isValid() || $this->sufb->isEmpty()) {
 856                 $fields['sufb_json'] = json_encode($this->sufb->export()->dict());
 857             } else {
 858                 $errors[] = self::ERROR_INVALID_UFC;
 859             }
 860
 861             if ($this->nl->automaticMailingEnabled()) {
 862                 $fields['send_before'] = ($this->send_before ? $this->send_before : null);
 863             }
 864         }
 865
 866         if (count($errors)) {
 867             return $errors;
 868         }
 869         $field_sets = array();
 870         foreach ($fields as $key => $value) {
 871             $field_sets[] = XDB::format($key . ' = {?}', $value);
 872         }
 873         XDB::execute('UPDATE  newsletter_issues
 874                          SET  ' . implode(', ', $field_sets) . '
 875                        WHERE  id={?}',
 876                        $this->id);
 877         if (XDB::affectedRows()) {
 878             $this->refresh();
 879         } else {
 880             $errors[] = self::ERROR_SQL_SAVE;
 881         }
 882         return $errors;
 883     }
 884
 885     /** Get an article by number
 886      * @p $aid Article ID (among articles of the issue)
 887      * @return A NLArticle object, or null if there is no article by that number
 888      */
 889     public function getArt($aid)
 890     {
 891         $this->fetchArticles();
 892
 893         foreach ($this->arts as $category => $artlist) {
 894             if (isset($artlist[$aid])) {
 895                 return $artlist[$aid];
 896             }
 897         }
 898         return null;
 899     }
 900
 901     /** Save an article
 902      * @p $a A reference to a NLArticle object (will be modified once saved)
 903      */
 904     public function saveArticle($a)
 905     {
 906         $this->fetchArticles();
 907
 908         // Prevent cid to be 0 (use NULL instead)
 909         $a->cid = ($a->cid == 0) ? null : $a->cid;
 910         if ($a->aid >= 0) {
 911             // Article already exists in DB
 912             XDB::execute('UPDATE  newsletter_art
 913                              SET  cid = {?}, pos = {?}, title = {?}, body = {?}, append = {?}
 914                            WHERE  id = {?} AND aid = {?}',
 915                          $a->cid, $a->pos, $a->title, $a->body, $a->append, $this->id, $a->aid);
 916         } else {
 917             // New article
 918             XDB::startTransaction();
 919             list($aid, $pos) = XDB::fetchOneRow('SELECT  MAX(aid) AS aid, MAX(pos) AS pos
 920                                                    FROM  newsletter_art AS a
 921                                                   WHERE  a.id = {?}',
 922                                                 $this->id);
 923             $a->aid = ++$aid;
 924             $a->pos = ($a->pos ? $a->pos : ++$pos);
 925             XDB::execute('INSERT INTO  newsletter_art (id, aid, cid, pos, title, body, append)
 926                                VALUES  ({?}, {?}, {?}, {?}, {?}, {?}, {?})',
 927                          $this->id, $a->aid, $a->cid, $a->pos,
 928                          $a->title, $a->body, $a->append);
 929             XDB::commit();
 930         }
 931         // Update local ID of article
 932         $this->arts[$a->aid] = $a;
 933     }
 934
 935     /** Delete an article by its ID
 936      * @p $aid ID of the article to delete
 937      */
 938     public function delArticle($aid)
 939     {
 940         $this->fetchArticles();
 941
 942         XDB::execute('DELETE FROM newsletter_art WHERE id={?} AND aid={?}', $this->id, $aid);
 943         foreach ($this->arts as $key=>$art) {
 944             unset($this->arts[$key][$aid]);
 945         }
 946     }
 947
 948     // }}}
 949     // {{{ Display
 950
 951     /** Retrieve the title of this issue
 952      * @p $mail Whether we want the normal title or the email subject
 953      * @return Title of the issue
 954      */
 955     public function title($mail = false)
 956     {
 957         return $mail ? $this->title_mail : $this->title;
 958     }
 959
 960     /** Retrieve the head of this issue
 961      * @p $user User for <dear> customization (may be null: no customization)
 962      * @p $type Either 'text' or 'html'
 963      * @return Formatted head of the issue.
 964      */
 965     public function head($user = null, $type = 'text')
 966     {
 967         if (is_null($user)) {
 968             return $this->head;
 969         } else {
 970             $head = $this->head;
 971             $head = str_replace(array('<cher>', '<prenom>', '<nom>'),
 972                                 array(($user->isFemale() ? 'Chère' : 'Cher'), $user->displayName(), ''),
 973                                 $head);
 974             return format_text($head, $type, 2, 64);
 975         }
 976     }
 977
 978     /** Retrieve the formatted signature of this issue.
 979      */
 980     public function signature($type = 'text')
 981     {
 982         return format_text($this->signature, $type, 2, 64);
 983     }
 984
 985     /** Get the title of a given category
 986      * @p $cid ID of the category to retrieve
 987      * @return Name of the category
 988      */
 989     public function category($cid)
 990     {
 991         return $this->nl->cats[$cid];
 992     }
 993
 994     /** Add required data to the given $page for proper CSS display
 995      * @p $page Smarty object
 996      * @return Either 'true' (if CSS was added to a page) or the raw CSS to add (when $page is null)
 997      */
 998     public function css($page = null)
 999     {
1000         if (!is_null($page)) {
1001             $page->addCssLink($this->nl->cssFile());
1002             return true;
1003         } else {
1004             $css = file_get_contents(dirname(__FILE__) . '/../htdocs/css/' . $this->nl->cssFile());
1005             return preg_replace('@/\*.*?\*/@us', '', $css);
1006         }
1007     }
1008
1009     /** Set up a smarty page for a 'text' mode render of the issue
1010      * @p $page Smarty object (using the $this->nl->tplFile() template)
1011      * @p $user User to use when rendering the template
1012      */
1013     public function toText($page, $user)
1014     {
1015         $this->fetchArticles();
1016
1017         $this->css($page);
1018         $page->assign('prefix', null);
1019         $page->assign('is_mail', false);
1020         $page->assign('mail_part', 'text');
1021         $page->assign('user', $user);
1022         $page->assign('hash', null);
1023         $this->assignData($page);
1024     }
1025
1026     /** Set up a smarty page for a 'html' mode render of the issue
1027      * @p $page Smarty object (using the $this->nl->tplFile() template)
1028      * @p $user User to use when rendering the template
1029      */
1030     public function toHtml($page, $user)
1031     {
1032         $this->fetchArticles();
1033
1034         $this->css($page);
1035         $page->assign('prefix', $this->nl->prefix() . '/show/' . $this->id());
1036         $page->assign('is_mail', false);
1037         $page->assign('mail_part', 'html');
1038         $page->assign('user', $user);
1039         $page->assign('hash', null);
1040         $this->assignData($page);
1041     }
1042
1043     /** Set all 'common' data for the page (those which are required for both web and email rendering)
1044      * @p $smarty Smarty object (e.g page) which should be filled
1045      */
1046     protected function assignData($smarty)
1047     {
1048         $this->fetchArticles();
1049
1050         $smarty->assign_by_ref('issue', $this);
1051         $smarty->assign_by_ref('nl', $this->nl);
1052     }
1053
1054     // }}}
1055     // {{{ Mailing
1056
1057     /** Check whether this issue is empty
1058      * An issue is empty if the email has no title (or the default one), or no articles and an empty head.
1059      */
1060     public function isEmpty()
1061     {
1062         return $this->title_mail == '' || $this->title_mail == 'to be continued' || (count($this->arts) == 0 && strlen($this->head) == 0);
1063     }
1064
1065     /** Retrieve the 'Send before' date, in a clean format.
1066      */
1067     public function getSendBeforeDate()
1068     {
1069         return strftime('%Y-%m-%d', strtotime($this->send_before));
1070     }
1071
1072     /** Retrieve the 'Send before' time (i.e hour), in a clean format.
1073      */
1074     public function getSendBeforeTime()
1075     {
1076         return strtotime($this->send_before);
1077     }
1078
1079     /** Create a hash based on some additional data
1080      * $line Line-specific data (to prevent two hashes generated at the same time to be the same)
1081      */
1082     protected static function createHash($line)
1083     {
1084         $hash = implode(time(), $line) . rand();
1085         $hash = md5($hash);
1086         return $hash;
1087     }
1088
1089     /** Send this issue to the given user, reusing an existing hash if provided.
1090      * @p $user User to whom the issue should be mailed
1091      * @p $hash Optional hash to use in the 'unsubscribe' link; if null, another one will be generated.
1092      */
1093     public function sendTo($user, $hash = null)
1094     {
1095         $this->fetchArticles();
1096
1097         if (is_null($hash)) {
1098             $hash = XDB::fetchOneCell("SELECT  hash
1099                                          FROM  newsletter_ins
1100                                         WHERE  uid = {?} AND nlid = {?}",
1101                                       $user->id(), $this->nl->id);
1102         }
1103         if (is_null($hash)) {
1104             $hash = self::createHash(array($user->displayName(), $user->fullName(),
1105                                        $user->isFemale(), $user->isEmailFormatHtml(),
1106                                        rand(), "X.org rulez"));
1107             XDB::execute("UPDATE  newsletter_ins as ni
1108                              SET  ni.hash = {?}
1109                            WHERE  ni.uid = {?} AND ni.nlid = {?}",
1110                          $hash, $user->id(), $this->nl->id);
1111         }
1112
1113         $mailer = new PlMailer($this->nl->tplFile());
1114         $this->assignData($mailer);
1115         $mailer->assign('is_mail', true);
1116         $mailer->assign('user', $user);
1117         $mailer->assign('prefix',  null);
1118         $mailer->assign('hash',    $hash);
1119         $mailer->sendTo($user);
1120     }
1121
1122     /** Select a subset of subscribers which should receive the newsletter.
1123      * NL-Specific selections (not yet received, is subscribed) are done when sending.
1124      * @return A PlFilterCondition.
1125      */
1126     protected function getRecipientsUFC()
1127     {
1128         return $this->sufb->getUFC();
1129     }
1130
1131     /** Check whether a given user may see this issue.
1132      * @p $user User whose access should be checked
1133      * @return Whether he may access the issue
1134      */
1135     public function checkUser($user = null)
1136     {
1137         if ($user == null) {
1138             $user = S::user();
1139         }
1140         $uf = new UserFilter($this->getRecipientsUFC());
1141         return $uf->checkUser($user);
1142     }
1143
1144     /** Sent this issue to all valid recipients
1145      * @return Number of issues sent
1146      */
1147     public function sendToAll()
1148     {
1149         $this->fetchArticles();
1150
1151         XDB::execute('UPDATE  newsletter_issues
1152                          SET  state = \'sent\', date=CURDATE()
1153                        WHERE  id = {?}',
1154                        $this->id);
1155
1156         $ufc = new PFC_And($this->getRecipientsUFC(), new UFC_NLSubscribed($this->nl->id, $this->id), new UFC_HasValidEmail());
1157         $emailsCount = 0;
1158         $uf = new UserFilter($ufc, array(new UFO_IsAdmin(), new UFO_Uid()));
1159         $limit = new PlLimit(self::BATCH_SIZE);
1160
1161         while (true) {
1162             $sent = array();
1163             $users = $uf->getUsers($limit);
1164             if (count($users) == 0) {
1165                 return $emailsCount;
1166             }
1167             foreach ($users as $user) {
1168                 $sent[] = $user->id();
1169                 $this->sendTo($user, $hash);
1170                 ++$emailsCount;
1171             }
1172             XDB::execute("UPDATE  newsletter_ins
1173                              SET  last = {?}
1174                            WHERE  nlid = {?} AND uid IN {?}", $this->id, $this->nl->id, $sent);
1175
1176             sleep(60);
1177         }
1178         return $emailsCount;
1179     }
1180
1181     // }}}
1182 }
1183
1184 // }}}
1185 // {{{ class NLArticle
1186
1187 class NLArticle
1188 {
1189     // Maximum number of lines per article
1190     const MAX_LINES_PER_ARTICLE = 8;
1191     const MAX_CHARACTERS_PER_LINE = 68;
1192
1193     // {{{ properties
1194
1195     public $aid;
1196     public $cid;
1197     public $pos;
1198     public $title;
1199     public $body;
1200     public $append;
1201
1202     // }}}
1203     // {{{ constructor
1204
1205     function __construct($title='', $body='', $append='', $aid=-1, $cid=0, $pos=0)
1206     {
1207         $this->body   = $body;
1208         $this->title  = $title;
1209         $this->append = $append;
1210         $this->aid    = $aid;
1211         $this->cid    = $cid;
1212         $this->pos    = $pos;
1213     }
1214
1215     // }}}
1216     // {{{ function title()
1217
1218     public function title()
1219     { return trim($this->title); }
1220
1221     // }}}
1222     // {{{ function body()
1223
1224     public function body()
1225     { return trim($this->body); }
1226
1227     // }}}
1228     // {{{ function append()
1229
1230     public function append()
1231     { return trim($this->append); }
1232
1233     // }}}
1234     // {{{ function toText()
1235
1236     public function toText($hash = null, $login = null)
1237     {
1238         $title = '*'.$this->title().'*';
1239         $body = MiniWiki::WikiToText($this->body, true);
1240         $app = MiniWiki::WikiToText($this->append, false, 4);
1241         $text = trim("$title\n\n$body\n\n$app")."\n";
1242         if (!is_null($hash) && !is_null($login)) {
1243             $text = str_replace('%HASH%', "$hash/$login", $text);
1244         } else {
1245             $text = str_replace('%HASH%', '', $text);
1246         }
1247         return $text;
1248     }
1249
1250     // }}}
1251     // {{{ function toHtml()
1252
1253     public function toHtml($hash = null, $login = null)
1254     {
1255         $title = "<h2 class='xorg_nl'><a id='art{$this->aid}'></a>".pl_entities($this->title()).'</h2>';
1256         $body  = MiniWiki::WikiToHTML($this->body);
1257         $app   = MiniWiki::WikiToHTML($this->append);
1258
1259         $art   = "$title\n";
1260         $art  .= "<div class='art'>\n$body\n";
1261         if ($app) {
1262             $art .= "<div class='app'>$app</div>";
1263         }
1264         $art  .= "</div>\n";
1265         if (!is_null($hash) && !is_null($login)) {
1266             $art = str_replace('%HASH%', "$hash/$login", $art);
1267         } else {
1268             $art = str_replace('%HASH%', '', $art);
1269         }
1270
1271         return $art;
1272     }
1273
1274     // }}}
1275     // {{{ function check()
1276
1277     public function check()
1278     {
1279         $rest = $this->remain();
1280
1281         return $rest['remaining_lines'] >= 0;
1282     }
1283
1284     // }}}
1285     // {{{ function remain()
1286
1287     public function remain()
1288     {
1289         $text  = MiniWiki::WikiToText($this->body);
1290         $array = explode("\n", wordwrap($text, self::MAX_CHARACTERS_PER_LINE));
1291         $lines_count = 0;
1292         foreach ($array as $line) {
1293             if (trim($line) != '') {
1294                 ++$lines_count;
1295             }
1296         }
1297
1298         return array(
1299             'remaining_lines'                    => self::MAX_LINES_PER_ARTICLE - $lines_count,
1300             'remaining_characters_for_last_line' => self::MAX_CHARACTERS_PER_LINE - strlen($array[count($array) - 1])
1301        );
1302     }
1303     // }}}
1304     // {{{ function parseUrlsFromArticle()
1305
1306     protected function parseUrlsFromArticle()
1307     {
1308         $email_regex = '([a-z0-9.\-+_\$]+@([\-.+_]?[a-z0-9])+)';
1309         $url_regex = '((https?|ftp)://[a-zA-Z0-9._%#+/?=&~-]+)';
1310         $regex = '{' . $email_regex . '|' . $url_regex . '}i';
1311
1312         $matches = array();
1313         $body_matches = array();
1314         if (preg_match_all($regex, $this->body(), $body_matches)) {
1315             $matches = array_merge($matches, $body_matches[0]);
1316         }
1317
1318         $append_matches = array();
1319         if (preg_match_all($regex, $this->append(), $append_matches)) {
1320             $matches = array_merge($matches, $append_matches[0]);
1321         }
1322
1323         return $matches;
1324     }
1325
1326     // }}}
1327     // {{{ function getLinkIps()
1328
1329     public function getLinkIps(&$blacklist_host_resolution_count)
1330     {
1331         $matches = $this->parseUrlsFromArticle();
1332         $article_ips = array();
1333
1334         if (!empty($matches)) {
1335             global $globals;
1336
1337             foreach ($matches as $match) {
1338                 $host = parse_url($match, PHP_URL_HOST);
1339                 if ($host == '') {
1340                     list(, $host) = explode('@', $match);
1341                 }
1342
1343                 if ($blacklist_host_resolution_count >= $globals->mail->blacklist_host_resolution_limit) {
1344                    break;
1345                 }
1346
1347                 if (!preg_match('/^(' . str_replace(' ', '|', $globals->mail->domain_whitelist) . ')$/i', $host)) {
1348                     $article_ips = array_merge($article_ips, array(gethostbyname($host) => $host));
1349                     ++$blacklist_host_resolution_count;
1350                 }
1351             }
1352         }
1353
1354         return $article_ips;
1355     }
1356
1357     // }}}
1358 }
1359
1360 // }}}
1361
1362 // {{{ Functions
1363
1364 function format_text($input, $format, $indent = 0, $width = 68)
1365 {
1366     if ($format == 'text') {
1367         return MiniWiki::WikiToText($input, true, $indent, $width, "title");
1368     }
1369     return MiniWiki::WikiToHTML($input, "title");
1370 }
1371
1372 // function enriched_to_text($input,$html=false,$just=false,$indent=0,$width=68)
1373
1374 // }}}
1375
1376 // vim:set et sw=4 sts=4 sws=4 enc=utf-8:
1377 ?>