include/notifs.inc.php

   1 <?php
   2 /***************************************************************************
   3  *  Copyright (C) 2003-2013 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 abstract class WatchOperation
  23 {
  24     private static $false = null;
  25
  26     public function getTitle($count = 0)
  27     {
  28         if ($count == 1) {
  29             return str_replace(array('$x', '$s'), '', $this->title);
  30         } else {
  31             return str_replace(array('$x', '$s'), array('x', 's'), $this->title);
  32         }
  33     }
  34
  35     public function getCondition(Watch $watch)
  36     {
  37         if (!$watch->user()->watchType($this->flag)) {
  38             if (!self::$false) {
  39                 self::$false = new PFC_False();
  40             }
  41             return self::$false;
  42         } else {
  43             return $this->buildCondition($watch);
  44         }
  45     }
  46
  47     abstract protected function buildCondition(Watch $watch);
  48     abstract public function getOrder();
  49     abstract public function getDate(PlUser $user);
  50
  51     public function publicationDate(PlUser $user)
  52     {
  53         return $this->getDate($user);
  54     }
  55
  56     public function seen(PlUser $user, $last)
  57     {
  58         return strtotime($this->getDate($user)) > $last;
  59     }
  60
  61     public function getData(PlUser $user)
  62     {
  63         return null;
  64     }
  65 }
  66
  67 class WatchProfileUpdate extends WatchOperation
  68 {
  69     private static $order = null;
  70
  71     public $flag  = 'profile';
  72     public $title = 'Mise$s à jour de fiche';
  73     private $date = null;
  74
  75     public static function register(Profile $profile, $field)
  76     {
  77         XDB::execute('INSERT INTO  watch_profile (pid, ts, field)
  78                            VALUES  ({?}, NOW(), {?})
  79           ON DUPLICATE KEY UPDATE  ts = NOW()',
  80                      $profile->id(), $field);
  81     }
  82
  83     protected function buildCondition(Watch $watch)
  84     {
  85         $this->date = $watch->date();
  86         return new PFC_And(new UFC_ProfileUpdated('>', $watch->date()),
  87                            $watch->contactCondition());
  88     }
  89
  90     public function getOrder()
  91     {
  92         if (!self::$order) {
  93             self::$order = new UFO_ProfileUpdate();
  94         }
  95         return self::$order;
  96     }
  97
  98     public function getDate(PlUser $user)
  99     {
 100         return $user->profile()->last_change;
 101     }
 102
 103     public function getData(PlUser $user)
 104     {
 105         $data = XDB::fetchColumn("SELECT  field
 106                                     FROM  watch_profile
 107                                    WHERE  pid = {?} AND ts > FROM_UNIXTIME({?}) AND field != ''
 108                                 ORDER BY  ts",
 109                                  $user->profile()->id(), $this->date);
 110         if (count($data) == 0) {
 111             return null;
 112         } else {
 113             $text = array();
 114             foreach ($data as $f) {
 115                 $text[] = Profile::$descriptions[$f];
 116             }
 117             return $text;
 118         }
 119     }
 120 }
 121
 122 class WatchRegistration extends WatchOperation
 123 {
 124     private static $order = null;
 125
 126     public $flag  = 'registration';
 127     public $title = 'Inscription$s';
 128
 129     protected function buildCondition(Watch $watch)
 130     {
 131         return new PFC_And(new UFC_Registered(false, '>', $watch->date()),
 132                            new PFC_Or($watch->contactCondition(),
 133                                       $watch->promoCondition(),
 134                                       $watch->groupCondition()));
 135     }
 136
 137     public function getOrder()
 138     {
 139         if (!self::$order) {
 140             self::$order = new UFO_Registration();
 141         }
 142         return self::$order;
 143     }
 144
 145     public function getDate(PlUser $user)
 146     {
 147         return $user->registration_date;
 148     }
 149 }
 150
 151 class WatchDeath extends WatchOperation
 152 {
 153     private static $order = null;
 154
 155     public $flag  = 'death';
 156     public $title = 'Décès';
 157
 158     protected function buildCondition(Watch $watch)
 159     {
 160         return new PFC_And(new UFC_Dead('>', $watch->date(), true),
 161                            new PFC_Or($watch->contactCondition(),
 162                                       $watch->promoCondition(),
 163                                       $watch->groupCondition()));
 164     }
 165
 166     public function getOrder()
 167     {
 168         if (!self::$order) {
 169             self::$order = new UFO_Death();
 170         }
 171         return self::$order;
 172     }
 173
 174     public function getDate(PlUser $user)
 175     {
 176         return $user->profile()->deathdate;
 177     }
 178
 179     public function publicationDate(PlUser $user)
 180     {
 181         return $user->profile()->deathdate_rec;
 182     }
 183
 184     public function seen(PlUser $user, $last)
 185     {
 186         return strtotime($user->profile()->deathdate_rec) > $last;
 187     }
 188 }
 189
 190 class WatchBirthday extends WatchOperation
 191 {
 192     const WATCH_LIMIT = 604800; // 1 week
 193
 194     private static $order = null;
 195
 196     public $flag  = 'birthday';
 197     public $title = 'Anniversaire$s';
 198
 199     protected function buildCondition(Watch $watch)
 200     {
 201         $not_dead = new PFC_Not(new UFC_Dead());
 202         $select_date = new PFC_OR(new UFC_Birthday('=', time()),
 203                                   new PFC_And(new UFC_Birthday('<=', time() + self::WATCH_LIMIT),
 204                                               new UFC_Birthday('>', $watch->date() + self::WATCH_LIMIT)));
 205         $profile = $watch->profile();
 206         $cond = $watch->contactCondition();
 207         if ($profile) {
 208             $cond = new PFC_Or($cond,
 209                                new PFC_And($watch->promoCondition(),
 210                                            new UFC_Promo('>=', $profile->mainGrade(), $profile->yearpromo() - 1),
 211                                            new UFC_Promo('<=', $profile->mainGrade(), $profile->yearpromo() + 1)),
 212                                $watch->groupCondition());
 213         }
 214         return new PFC_And($not_dead, $select_date, $cond);
 215     }
 216
 217     public function getOrder()
 218     {
 219         if (!self::$order) {
 220             self::$order = new UFO_Birthday();
 221         }
 222         return self::$order;
 223     }
 224
 225     public function getDate(PlUser $user)
 226     {
 227         return $user->profile()->next_birthday;
 228     }
 229
 230     public function publicationDate(PlUser $user)
 231     {
 232         return date('Y-m-d', strtotime($user->profile()->next_birthday) - self::WATCH_LIMIT);
 233     }
 234
 235     public function seen(PlUser $user, $last)
 236     {
 237         $birthday = strtotime($user->profile()->next_birthday);
 238         return $birthday >  $last + self::WATCH_LIMIT
 239             || date('Ymd', $birthday) == date('Ymd');
 240     }
 241 }
 242
 243 class Watch
 244 {
 245     private static  $classes = array('WatchRegistration',
 246                                      'WatchProfileUpdate',
 247                                      'WatchDeath',
 248                                      'WatchBirthday');
 249     private static $events = array();
 250
 251     private $user = null;
 252     private $date = null;
 253     private $contactCond = null;
 254     private $promoCond = null;
 255     private $groupCond = null;
 256
 257     private $filters = array();
 258
 259     public function __construct(PlUser $user, $date = null)
 260     {
 261         $this->user = $user;
 262         $this->date = self::getDate($user, $date);
 263     }
 264
 265     public function user()
 266     {
 267         return $this->user;
 268     }
 269
 270     public function profile()
 271     {
 272         return $this->user->profile();
 273     }
 274
 275     public function date()
 276     {
 277         return $this->date;
 278     }
 279
 280     public function contactCondition()
 281     {
 282         if (!$this->contactCond) {
 283             $this->contactCond = new UFC_WatchContact($this->user);
 284         }
 285         return $this->contactCond;
 286     }
 287
 288     public function promoCondition()
 289     {
 290         if (!$this->promoCond) {
 291             $this->promoCond = new UFC_WatchPromo($this->user);
 292         }
 293         return $this->promoCond;
 294     }
 295
 296     public function groupCondition()
 297     {
 298         if (!$this->groupCond) {
 299             $this->groupCond = new UFC_WatchGroup($this->user);
 300         }
 301         return $this->groupCond;
 302     }
 303
 304     private function fetchEventWatch($class)
 305     {
 306         if (!isset(self::$events[$class])) {
 307             self::$events[$class] = new $class();
 308         }
 309         return self::$events[$class];
 310     }
 311
 312     private function fetchFilter($class)
 313     {
 314
 315         if (!isset($this->filters[$class])) {
 316             $event = $this->fetchEventWatch($class);
 317             $this->filters[$class] = new UserFilter($event->getCondition($this),
 318                                                     array($event->getOrder(), new UFO_Name()));
 319         }
 320         return $this->filters[$class];
 321     }
 322
 323     public function count()
 324     {
 325         $count = 0;
 326         foreach (self::$classes as $class) {
 327             $uf = $this->fetchFilter($class);
 328             $count += $uf->getTotalCount();
 329         }
 330         return $count;
 331     }
 332
 333
 334     private function fetchEvents($class)
 335     {
 336         $obj = $this->fetchEventWatch($class);
 337         $uf = $this->fetchFilter($class);
 338         $users = $uf->getUsers();
 339         if (count($users) == 0) {
 340             return null;
 341         } else {
 342             return array('type'      => $obj->flag,
 343                          'operation' => $obj,
 344                          'title'     => $obj->getTitle(count($users)),
 345                          'users'     => $users);
 346         }
 347     }
 348
 349     public function events()
 350     {
 351         $events = array();
 352         foreach (self::$classes as $class) {
 353             $e = $this->fetchEvents($class);
 354             if (!is_null($e)) {
 355                 $events[] = $e;
 356             }
 357         }
 358         return $events;
 359     }
 360
 361
 362     private static function getDate(PlUser $user, $date)
 363     {
 364         if (is_null($date)) {
 365             $date = $user->watchLast();
 366             $limit = time() - (7 * 86400);
 367             if ($date < $limit) {
 368                 $date = $limit;
 369             }
 370         }
 371         return $date;
 372     }
 373
 374     public static function getCount(PlUser $user, $date = null)
 375     {
 376         $watch = new Watch($user, $date);
 377         return $watch->count();
 378     }
 379
 380     public static function getEvents(PlUser $user, $date = null)
 381     {
 382         $watch = new Watch($user, $date);
 383         return $watch->events();
 384     }
 385 }
 386
 387 // vim:set et sw=4 sts=4 sws=4 foldmethod=marker enc=utf-8:
 388 ?>