include/validations.inc.php

   1 <?php
   2 /***************************************************************************
   3  *  Copyright (C) 2003-2009 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 define('SIZE_MAX', 32768);
  23
  24 global $globals;
  25 require_once $globals->spoolroot . '/core/classes/xdb.php';
  26
  27 /**
  28  * Iterator class, that lists objects through the database
  29  */
  30 class ValidateIterator extends XOrgDBIterator
  31 {
  32     // {{{ constuctor
  33
  34     public function __construct ()
  35     {
  36         parent::__construct('SELECT data, DATE_FORMAT(stamp, "%Y%m%d%H%i%s") FROM requests ORDER BY stamp', MYSQL_NUM);
  37     }
  38
  39     // }}}
  40     // {{{ function next()
  41
  42     public function next ()
  43     {
  44         if (list($result, $stamp) = parent::next()) {
  45             $result = Validate::unserialize($result);
  46             $result->stamp = $stamp;
  47             return($result);
  48         } else {
  49             return null;
  50         }
  51     }
  52
  53     // }}}
  54 }
  55
  56 /** classe "virtuelle" à dériver pour chaque nouvelle implémentation
  57  */
  58 abstract class Validate
  59 {
  60     // {{{ properties
  61
  62     public $user;
  63
  64     public $stamp;
  65     public $unique;
  66     // enable the refuse button
  67     public $refuse = true;
  68
  69     public $type;
  70     public $comments = Array();
  71     // the validations rules : comments for admins
  72     public $rules = "Mieux vaut laisser une demande de validation à un autre admin que de valider une requête illégale ou que de refuser une demande légitime";
  73
  74     // }}}
  75     // {{{ constructor
  76
  77     /** constructeur
  78      * @param       $_user      user object
  79      * @param       $_unique    requête pouvant être multiple ou non
  80      * @param       $_type      type de la donnée comme dans le champ type de x4dat.requests
  81      */
  82     public function __construct(User &$_user, $_unique, $_type)
  83     {
  84         $this->user   = &$_user;
  85         $this->stamp  = date('YmdHis');
  86         $this->unique = $_unique;
  87         $this->type   = $_type;
  88     }
  89
  90     // }}}
  91     // {{{ function submit()
  92
  93     /** fonction à utiliser pour envoyer les données à la modération
  94      * cette fonction supprimme les doublons sur un couple ($user,$type) si $this->unique est vrai
  95      */
  96     public function submit()
  97     {
  98         if ($this->unique) {
  99             XDB::execute('DELETE FROM requests WHERE user_id={?} AND type={?}', $this->user->id(), $this->type);
 100         }
 101
 102         $this->stamp = date('YmdHis');
 103         XDB::execute('INSERT INTO requests (user_id, type, data, stamp) VALUES ({?}, {?}, {?}, {?})',
 104                 $this->user->id(), $this->type, $this, $this->stamp);
 105
 106         global $globals;
 107         $globals->updateNbValid();
 108         return true;
 109     }
 110
 111     // }}}
 112     // {{{ function update()
 113
 114     protected function update()
 115     {
 116         XDB::execute('UPDATE requests SET data={?}, stamp=stamp
 117                        WHERE user_id={?} AND type={?} AND stamp={?}',
 118                      $this, $this->user->id(), $this->type, $this->stamp);
 119         return true;
 120     }
 121
 122     // }}}
 123     // {{{ function clean()
 124
 125     /** fonction à utiliser pour nettoyer l'entrée de la requête dans la table requests
 126      * attention, tout est supprimé si c'est un unique
 127      */
 128     public function clean()
 129     {
 130         global $globals;
 131
 132         if ($this->unique) {
 133             $success = XDB::execute('DELETE FROM requests WHERE user_id={?} AND type={?}',
 134                                     $this->user->id(), $this->type);
 135         } else {
 136             $success =  XDB::execute('DELETE FROM requests WHERE user_id={?} AND type={?} AND stamp={?}',
 137                                       $this->user->id(), $this->type, $this->stamp);
 138         }
 139         $globals->updateNbValid();
 140         return $success;
 141     }
 142
 143     // }}}
 144     // {{{ function handle_formu()
 145
 146     /** fonction à réaliser en cas de validation du formulaire
 147      */
 148     public function handle_formu()
 149     {
 150         if (Env::has('delete')) {
 151             $this->clean();
 152             $this->trigSuccess('Requête supprimée');
 153             return true;
 154         }
 155
 156         // mise à jour des informations
 157         if (Env::has('edit')) {
 158             if ($this->handle_editor()) {
 159                 $this->update();
 160                 $this->trigSuccess('Requête mise à jour');
 161                 return true;
 162             }
 163             return false;
 164         }
 165
 166         // ajout d'un commentaire
 167         if (Env::has('hold') && Env::has('comm')) {
 168             $formid = Env::i('formid');
 169             foreach ($this->comments as $comment) {
 170                 if ($comment[2] === $formid) {
 171                     return true;
 172                 }
 173             }
 174             if (!strlen(trim(Env::v('comm')))) {
 175                 return true;
 176             }
 177             $this->comments[] = Array(S::user()->login(), Env::v('comm'), $formid);
 178
 179             // envoi d'un mail à hotliners
 180             global $globals;
 181             $mailer = new PlMailer();
 182             $mailer->setSubject("Commentaires de validation {$this->type}");
 183             $mailer->setFrom("validation+{$this->type}@{$globals->mail->domain}");
 184             $mailer->addTo($globals->core->admin_email);
 185
 186             $body = "Validation {$this->type} pour {$this->user->login()}\n\n"
 187               . S::user()->login() . " a ajouté le commentaire :\n\n"
 188               . Env::v('comm') . "\n\n"
 189               . "cf la discussion sur : " . $globals->baseurl . "/admin/validate";
 190
 191             $mailer->setTxtBody(wordwrap($body));
 192             $mailer->send();
 193
 194             $this->update();
 195             $this->trigSuccess('Commentaire ajouté');
 196             return true;
 197         }
 198
 199         if (Env::has('accept')) {
 200             if ($this->commit()) {
 201                 $this->sendmail(true);
 202                 $this->clean();
 203                 $this->trigSuccess('Email de validation envoyé');
 204                 return true;
 205             } else {
 206                 $this->trigError('Erreur lors de la validation');
 207                 return false;
 208             }
 209         }
 210
 211         if (Env::has('refuse')) {
 212             if (Env::v('comm')) {
 213                 $this->sendmail(false);
 214                 $this->clean();
 215                 $this->trigSuccess('Email de refus envoyé');
 216                 return true;
 217             } else {
 218                 $this->trigError('pas de motivation pour le refus !!!');
 219             }
 220         }
 221
 222         return false;
 223     }
 224
 225     // }}}
 226     // {{{ function sendmail
 227
 228     protected function sendmail($isok)
 229     {
 230         global $globals;
 231         $mailer = new PlMailer();
 232         $mailer->setSubject($this->_mail_subj());
 233         $mailer->setFrom("validation+{$this->type}@{$globals->mail->domain}");
 234         $mailer->addTo("\"{$this->user->fullName()}\" <{$this->user->bestEmail()}>");
 235         $mailer->addCc("validation+{$this->type}@{$globals->mail->domain}");
 236
 237         $body = ($this->user->isFemale() ? "Chère camarade,\n\n" : "Cher camarade,\n\n")
 238               . $this->_mail_body($isok)
 239               . (Env::has('comm') ? "\n\n" . Env::v('comm') : '')
 240               . "\n\nCordialement,\n-- \nL'équipe de Polytechnique.org\n";
 241         if (!is_null($this->_mail_ps($isok))) {
 242             $body .= $this->_mail_ps($isok);
 243         }
 244
 245         $mailer->setTxtBody(wordwrap($body));
 246         $mailer->send();
 247     }
 248
 249     // }}}
 250     // {{{ function trig()
 251
 252     protected function trigError($msg)
 253     {
 254         Platal::page()->trigError($msg);
 255     }
 256
 257     protected function trigWarning($msg)
 258     {
 259         Platal::page()->trigWarning($msg);
 260     }
 261
 262     protected function trigSuccess($msg)
 263     {
 264         Platal::page()->trigSuccess($msg);
 265     }
 266
 267     // }}}
 268     // {{{ function get_typed_request()
 269
 270     /** fonction statique qui renvoie la requête de l'utilisateur d'id $uidau timestamp $t
 271      * @param   $uid    l'id de l'utilisateur concerné
 272      * @param   $type   le type de la requête
 273      * @param   $stamp  le timestamp de la requête
 274      *
 275      * XXX fonction "statique" XXX
 276      * à utiliser uniquement pour récupérer un objet dans la BD avec Validate::get_typed_request(...)
 277      */
 278     static public function get_typed_request($uid, $type, $stamp = -1)
 279     {
 280         if ($stamp == -1) {
 281             $res = XDB::query('SELECT data FROM requests WHERE user_id={?} and type={?}', $uid, $type);
 282         } else {
 283             $res = XDB::query('SELECT data, DATE_FORMAT(stamp, "%Y%m%d%H%i%s") FROM requests WHERE user_id={?} AND type={?} and stamp={?}', $uid, $type, $stamp);
 284         }
 285         if ($result = $res->fetchOneCell()) {
 286             $result = Validate::unserialize($result);
 287         } else {
 288             $result = false;
 289         }
 290         return($result);
 291     }
 292
 293     // }}}
 294     // {{{ function get_request_by_id()
 295
 296     static public function get_request_by_id($id)
 297     {
 298         list($uid, $type, $stamp) = explode('_', $id, 3);
 299         return Validate::get_typed_request($uid, $type, $stamp);
 300     }
 301
 302     // }}}
 303     // {{{ function get_typed_requests()
 304
 305     /** same as get_typed_request() but return an array of objects
 306      */
 307     static public function get_typed_requests($uid, $type)
 308     {
 309         $res = XDB::iterRow('SELECT data FROM requests WHERE user_id={?} and type={?}', $uid, $type);
 310         $array = array();
 311         while (list($data) = $res->next()) {
 312             $array[] = Validate::unserialize($data);
 313         }
 314         return $array;
 315     }
 316
 317     // }}}
 318     // {{{ function get_typed_requests_count()
 319
 320     /** same as get_typed_requests() but return the count of available requests.
 321      */
 322     static public function get_typed_requests_count($uid, $type)
 323     {
 324         $res = XDB::query('SELECT COUNT(data) FROM requests WHERE user_id={?} and type={?}', $uid, $type);
 325         return $res->fetchOneCell();
 326     }
 327
 328     // }}}
 329     // {{{ function _mail_body
 330
 331     abstract protected function _mail_body($isok);
 332
 333     // }}}
 334     // {{{ function _mail_subj
 335
 336     abstract protected function _mail_subj();
 337
 338     // }}}
 339     // {{{ function _mail_ps
 340
 341     protected function _mail_ps($isok)
 342     {
 343         return null;
 344     }
 345
 346     // }}}
 347     // {{{ function commit()
 348
 349     /** fonction à utiliser pour insérer les données dans x4dat
 350      */
 351     abstract public function commit();
 352
 353     // }}}
 354     // {{{ function formu()
 355
 356     /** nom du template qui contient le formulaire */
 357     abstract public function formu();
 358
 359     // }}}
 360     // {{{ function editor()
 361
 362     /** nom du formulaire d'édition */
 363     public function editor()
 364     {
 365         return null;
 366     }
 367
 368     // }}}
 369     // {{{ function answers()
 370
 371     /** automatic answers table for this type of validation */
 372     public function answers()
 373     {
 374         static $answers_table;
 375         if (!isset($answers_table[$this->type])) {
 376             $r = XDB::query("SELECT id, title, answer FROM requests_answers WHERE category = {?}", $this->type);
 377             $answers_table[$this->type] = $r->fetchAllAssoc();
 378         }
 379         return $answers_table[$this->type];
 380     }
 381
 382     // }}}
 383     // {{{ function id()
 384
 385     public function id()
 386     {
 387         return $this->user->id() . '_' . $this->type . '_' . $this->stamp;
 388     }
 389
 390     // }}}
 391     // {{{ function ruleText()
 392
 393     public function ruleText()
 394     {
 395         return str_replace('\'', '\\\'', $this->rules);
 396     }
 397
 398     // }}}
 399     // {{{ function unserialize()
 400     public static function unserialize($data)
 401     {
 402         $obj = unserialize($data);
 403         /* XXX: Temporary for hruid migration */
 404         if (!isset($obj->user) || !is_object($obj)) {
 405             $obj->user =& User::get($obj->forlife);
 406         }
 407         /* XXX: End temporary block */
 408         return $obj;
 409     }
 410 }
 411
 412 foreach (glob(dirname(__FILE__).'/validations/*.inc.php') as $file) {
 413     require_once($file);
 414 }
 415
 416 /* vim: set expandtab shiftwidth=4 tabstop=4 softtabstop=4 foldmethod=marker enc=utf-8: */
 417 ?>