galette/lib/Galette/Core/Preferences.php

   1 <?php
   2
   3 /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
   4
   5 /**
   6  * Preferences handling
   7  *
   8  * PHP version 5
   9  *
  10  * Copyright © 2007-2014 The Galette Team
  11  *
  12  * This file is part of Galette (http://galette.tuxfamily.org).
  13  *
  14  * Galette is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation, either version 3 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * Galette is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  *  GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with Galette. If not, see <http://www.gnu.org/licenses/>.
  26  *
  27  * @category  Core
  28  * @package   Galette
  29  *
  30  * @author    Johan Cwiklinski <johan@x-tnd.be>
  31  * @copyright 2007-2014 The Galette Team
  32  * @license   http://www.gnu.org/licenses/gpl-3.0.html GPL License 3.0 or (at your option) any later version
  33  * @version   SVN: $Id$
  34  * @link      http://galette.tuxfamily.org
  35  * @since     Available since 0.7dev - 2007-10-14
  36  */
  37
  38 namespace Galette\Core;
  39
  40 use Analog\Analog;
  41 use Galette\Entity\Adherent;
  42 use Galette\Entity\Status;
  43 use Galette\Core\Db;
  44 use Galette\IO\PdfMembersCards;
  45 use Galette\Repository\Members;
  46
  47 /**
  48  * Preferences for galette
  49  *
  50  * @category  Core
  51  * @name      Preferences
  52  * @package   Galette
  53  * @author    Johan Cwiklinski <johan@x-tnd.be>
  54  * @copyright 2007-2014 The Galette Team
  55  * @license   http://www.gnu.org/licenses/gpl-3.0.html GPL License 3.0 or (at your option) any later version
  56  * @link      http://galette.tuxfamily.org
  57  * @since     Available since 0.7dev - 2007-10-14
  58  */
  59 class Preferences
  60 {
  61     private $zdb;
  62     private $prefs;
  63     private $errors = [];
  64
  65     const TABLE = 'preferences';
  66     const PK = 'nom_pref';
  67
  68     /** Postal address will be the one given in the preferences */
  69     const POSTAL_ADDRESS_FROM_PREFS = 0;
  70     /** Postal address will be the one of the selected staff member */
  71     const POSTAL_ADDRESS_FROM_STAFF = 1;
  72
  73     /** Public pages stuff */
  74     /** Public pages are publically visibles */
  75     const PUBLIC_PAGES_VISIBILITY_PUBLIC = 0;
  76     /** Public pages are visibles for up to date members only */
  77     const PUBLIC_PAGES_VISIBILITY_RESTRICTED = 1;
  78     /** Public pages are visibles for admin and staff members only */
  79     const PUBLIC_PAGES_VISIBILITY_PRIVATE = 2;
  80
  81     const LOG_DISABLED = 0;
  82     const LOG_ENABLED = 1;
  83
  84     private static $fields = array(
  85         'nom_pref',
  86         'val_pref'
  87     );
  88
  89     private static $defaults = array(
  90         'pref_admin_login'    =>    'admin',
  91         'pref_admin_pass'    =>    'admin',
  92         'pref_nom'        =>    'Galette',
  93         'pref_slogan'        =>    '',
  94         'pref_adresse'        =>    '-',
  95         'pref_adresse2'        =>    '',
  96         'pref_cp'        =>    '',
  97         'pref_ville'        =>    '',
  98         'pref_pays'        =>    '',
  99         'pref_postal_adress'  => self::POSTAL_ADDRESS_FROM_PREFS,
 100         'pref_postal_staff_member' => '',
 101         'pref_lang'        =>    I18n::DEFAULT_LANG,
 102         'pref_numrows'        =>    30,
 103         'pref_log'        =>    self::LOG_ENABLED,
 104         'pref_statut'        =>    Status::DEFAULT_STATUS,
 105         /* Preferences for mails */
 106         'pref_email_nom'    =>    'Galette',
 107         'pref_email'        =>    'mail@domain.com',
 108         'pref_email_newadh'    =>    'mail@domain.com',
 109         'pref_bool_mailadh'    =>    false,
 110         'pref_editor_enabled'    =>    false,
 111         'pref_mail_method'    =>    GaletteMail::METHOD_DISABLED,
 112         'pref_mail_smtp'    =>    '',
 113         'pref_mail_smtp_host'   => '',
 114         'pref_mail_smtp_auth'   => false,
 115         'pref_mail_smtp_secure' => false,
 116         'pref_mail_smtp_port'   => '',
 117         'pref_mail_smtp_user'   => '',
 118         'pref_mail_smtp_password'   => '',
 119         'pref_membership_ext'    =>    12,
 120         'pref_beg_membership'    =>    '',
 121         'pref_email_reply_to'    =>    '',
 122         'pref_website'        =>    '',
 123         /* Preferences for labels */
 124         'pref_etiq_marges_v'    =>    10,
 125         'pref_etiq_marges_h'    =>    10,
 126         'pref_etiq_hspace'    =>    10,
 127         'pref_etiq_vspace'    =>    5,
 128         'pref_etiq_hsize'    =>    90,
 129         'pref_etiq_vsize'    =>    35,
 130         'pref_etiq_cols'    =>    2,
 131         'pref_etiq_rows'    =>    7,
 132         'pref_etiq_corps'    =>    12,
 133         /* Preferences for members cards */
 134         'pref_card_abrev'    =>    'GALETTE',
 135         'pref_card_strip'    =>    'Gestion d\'Adherents en Ligne Extrêmement Tarabiscotée',
 136         'pref_card_tcol'    =>    'FFFFFF',
 137         'pref_card_scol'    =>    '8C2453',
 138         'pref_card_bcol'    =>    '53248C',
 139         'pref_card_hcol'    =>    '248C53',
 140         'pref_bool_display_title'    =>    false,
 141         'pref_card_address'    =>    1,
 142         'pref_card_year'    =>    '',
 143         'pref_card_marges_v'    =>    15,
 144         'pref_card_marges_h'    =>    20,
 145         'pref_card_vspace'    =>    5,
 146         'pref_card_hspace'    =>    10,
 147         'pref_card_self'    =>    1,
 148         'pref_theme'        =>    'default',
 149         'pref_bool_publicpages' => true,
 150         'pref_publicpages_visibility' => self::PUBLIC_PAGES_VISIBILITY_RESTRICTED,
 151         'pref_bool_selfsubscribe' => true,
 152         'pref_googleplus' => '',
 153         'pref_facebook' => '',
 154         'pref_twitter' => '',
 155         'pref_viadeo' => '',
 156         'pref_linkedin' => '',
 157         'pref_mail_sign' => "{NAME}\r\n\r\n{WEBSITE}\r\n{GOOGLEPLUS}\r\n{FACEBOOK}\r\n{TWITTER}\r\n{LINKEDIN}\r\n{VIADEO}",
 158         /* New contribution script */
 159         'pref_new_contrib_script' => '',
 160         'pref_bool_wrap_mails' => true,
 161         'pref_rss_url' => 'http://galette.eu/dc/index.php/feed/atom',
 162         'pref_show_id' => false,
 163         'pref_adhesion_form' => '\Galette\IO\PdfAdhesionForm',
 164         'pref_mail_allow_unsecure' => false,
 165         'pref_instance_uuid' => '',
 166         'pref_registration_uuid' => '',
 167         'pref_telemetry_date' => '',
 168         'pref_registration_date' => '',
 169         'pref_footer' => '',
 170         'pref_filter_account' => Members::ALL_ACCOUNTS,
 171         'pref_galette_url' => '',
 172         'pref_redirect_on_create' => Adherent::AFTER_ADD_DEFAULT
 173     );
 174
 175     // flagging required fields
 176     private $required = array(
 177         'pref_nom',
 178         'pref_lang',
 179         'pref_numrows',
 180         'pref_log',
 181         'pref_etiq_marges_v',
 182         'pref_etiq_marges_h',
 183         'pref_etiq_hspace',
 184         'pref_etiq_vspace',
 185         'pref_etiq_hsize',
 186         'pref_etiq_vsize',
 187         'pref_etiq_cols',
 188         'pref_etiq_rows',
 189         'pref_etiq_corps',
 190         'pref_card_abrev',
 191         'pref_card_strip',
 192         'pref_card_marges_v',
 193         'pref_card_marges_h',
 194         'pref_card_hspace',
 195         'pref_card_vspace'
 196     );
 197
 198     /**
 199      * Default constructor
 200      *
 201      * @param Db      $zdb  Db instance
 202      * @param boolean $load Automatically load preferences on load
 203      *
 204      * @return void
 205      */
 206     public function __construct(Db $zdb, $load = true)
 207     {
 208         $this->zdb = $zdb;
 209         if ($load) {
 210             $this->load();
 211             $this->checkUpdate();
 212         }
 213     }
 214
 215     /**
 216      * Check if all fields referenced in the default array does exists,
 217      * create them if not
 218      *
 219      * @return void
 220      */
 221     private function checkUpdate()
 222     {
 223         $proceed = false;
 224         $params = array();
 225         foreach (self::$defaults as $k => $v) {
 226             if (!isset($this->prefs[$k])) {
 227                 $this->prefs[$k] = $v;
 228                 Analog::log(
 229                     'The field `' . $k . '` does not exists, Galette will attempt to create it.',
 230                     Analog::INFO
 231                 );
 232                 $proceed = true;
 233                 $params[] = array(
 234                     'nom_pref'  => $k,
 235                     'val_pref'  => $v
 236                 );
 237             }
 238         }
 239         if ($proceed !== false) {
 240             try {
 241                 $insert = $this->zdb->insert(self::TABLE);
 242                 $insert->values(
 243                     array(
 244                         'nom_pref'  => ':nom_pref',
 245                         'val_pref'  => ':val_pref'
 246                     )
 247                 );
 248                 $stmt = $this->zdb->sql->prepareStatementForSqlObject($insert);
 249
 250                 foreach ($params as $p) {
 251                     $stmt->execute(
 252                         array(
 253                             'nom_pref' => $p['nom_pref'],
 254                             'val_pref' => $p['val_pref']
 255                         )
 256                     );
 257                 }
 258             } catch (\Exception $e) {
 259                 Analog::log(
 260                     'Unable to add missing preferences.' . $e->getMessage(),
 261                     Analog::WARNING
 262                 );
 263                 return false;
 264             }
 265
 266             Analog::log(
 267                 'Missing preferences were successfully stored into database.',
 268                 Analog::INFO
 269             );
 270         }
 271     }
 272
 273     /**
 274      * Load current preferences from database.
 275      *
 276      * @return boolean
 277      */
 278     public function load()
 279     {
 280         $this->prefs = array();
 281
 282         try {
 283             $result = $this->zdb->selectAll(self::TABLE);
 284             foreach ($result as $pref) {
 285                 $this->prefs[$pref->nom_pref] = $pref->val_pref;
 286             }
 287             return true;
 288         } catch (\Exception $e) {
 289             Analog::log(
 290                 'Preferences cannot be loaded. Galette should not work without ' .
 291                 'preferences. Exiting.',
 292                 Analog::URGENT
 293             );
 294             return false;
 295         }
 296     }
 297
 298     /**
 299      * Set default preferences at install time
 300      *
 301      * @param staing $lang      language selected at install screen
 302      * @param string $adm_login admin login entered at install time
 303      * @param string $adm_pass  admin password entered at install time
 304      *
 305      * @return boolean|Exception
 306      */
 307     public function installInit($lang, $adm_login, $adm_pass)
 308     {
 309         try {
 310             //first, we drop all values
 311             $delete = $this->zdb->delete(self::TABLE);
 312             $this->zdb->execute($delete);
 313
 314             //we then replace default values with the ones user has selected
 315             $values = self::$defaults;
 316             $values['pref_lang'] = $lang;
 317             $values['pref_admin_login'] = $adm_login;
 318             $values['pref_admin_pass'] = $adm_pass;
 319             $values['pref_card_year'] = date('Y');
 320
 321             $insert = $this->zdb->insert(self::TABLE);
 322             $insert->values(
 323                 array(
 324                     'nom_pref'  => ':nom_pref',
 325                     'val_pref'  => ':val_pref'
 326                 )
 327             );
 328             $stmt = $this->zdb->sql->prepareStatementForSqlObject($insert);
 329
 330             foreach ($values as $k => $v) {
 331                 $stmt->execute(
 332                     array(
 333                         'nom_pref' => $k,
 334                         'val_pref' => $v
 335                     )
 336                 );
 337             }
 338
 339             Analog::log(
 340                 'Default preferences were successfully stored into database.',
 341                 Analog::INFO
 342             );
 343             return true;
 344         } catch (\Exception $e) {
 345             Analog::log(
 346                 'Unable to initialize default preferences.' . $e->getMessage(),
 347                 Analog::WARNING
 348             );
 349             return $e;
 350         }
 351     }
 352
 353     /**
 354      * Returns all preferences keys
 355      *
 356      * @return array
 357      */
 358     public function getFieldsNames()
 359     {
 360         return array_keys($this->prefs);
 361     }
 362
 363     /**
 364      * Check values
 365      *
 366      * @param array $values Values
 367      * @param Login $login  Logged in user
 368      *
 369      * @return boolean
 370      */
 371     public function check(array $values, Login $login)
 372     {
 373         $insert_values = array();
 374         if ($login->isSuperAdmin() && GALETTE_MODE !== 'DEMO') {
 375             $this->required[] = 'pref_admin_login';
 376         }
 377
 378         // obtain fields
 379         foreach ($this->getFieldsNames() as $fieldname) {
 380             if (isset($values[$fieldname])) {
 381                 $value = trim($values[$fieldname]);
 382             } else {
 383                 $value="";
 384             }
 385
 386             // now, check validity
 387             if ($value != '') {
 388                 switch ($fieldname) {
 389                     case 'pref_admin_login':
 390                         if (GALETTE_MODE === 'DEMO') {
 391                             Analog::log(
 392                                 'Trying to set superadmin login while in DEMO.',
 393                                 Analog::WARNING
 394                             );
 395                         } else {
 396                             if (strlen($value) < 4) {
 397                                 $this->errors[] = _T("- The username must be composed of at least 4 characters!");
 398                             } else {
 399                                 //check if login is already taken
 400                                 if ($login->loginExists($value)) {
 401                                     $this->errors[] = _T("- This username is already used by another member !");
 402                                 }
 403                             }
 404                         }
 405                         break;
 406                     case 'pref_numrows':
 407                         if (!is_numeric($value) || $value < 0) {
 408                             $this->errors[] = _T("- The numbers and measures have to be integers!");
 409                         }
 410                         break;
 411                     case 'pref_etiq_marges_h':
 412                     case 'pref_etiq_marges_v':
 413                     case 'pref_etiq_hspace':
 414                     case 'pref_etiq_vspace':
 415                     case 'pref_etiq_hsize':
 416                     case 'pref_etiq_vsize':
 417                     case 'pref_etiq_cols':
 418                     case 'pref_etiq_rows':
 419                     case 'pref_etiq_corps':
 420                     case 'pref_card_marges_v':
 421                     case 'pref_card_marges_h':
 422                     case 'pref_card_hspace':
 423                     case 'pref_card_vspace':
 424                         // prevent division by zero
 425                         if ($fieldname=='pref_numrows' && $value=='0') {
 426                             $value = '10';
 427                         }
 428                         if (!is_numeric($value) || $value < 0) {
 429                             $this->errors[] = _T("- The numbers and measures have to be integers!");
 430                         }
 431                         break;
 432                     case 'pref_card_tcol':
 433                         // Set strip text color to white
 434                         if (! preg_match("/#([0-9A-F]{6})/i", $value)) {
 435                             $value = '#FFFFFF';
 436                         }
 437                         break;
 438                     case 'pref_card_scol':
 439                     case 'pref_card_bcol':
 440                     case 'pref_card_hcol':
 441                         // Set strip background colors to black
 442                         if (!preg_match("/#([0-9A-F]{6})/i", $value)) {
 443                             $value = '#000000';
 444                         }
 445                         break;
 446                     case 'pref_admin_pass':
 447                         if (GALETTE_MODE == 'DEMO') {
 448                             Analog::log(
 449                                 'Trying to set superadmin pass while in DEMO.',
 450                                 Analog::WARNING
 451                             );
 452                         } else {
 453                             if (strlen($value) < 4) {
 454                                 $this->errors[] = _T("- The password must be of at least 4 characters!");
 455                             }
 456                         }
 457                         break;
 458                     case 'pref_membership_ext':
 459                         if (!is_numeric($value) || $value < 0) {
 460                             $this->errors[] = _T("- Invalid number of months of membership extension.");
 461                         }
 462                         break;
 463                     case 'pref_beg_membership':
 464                         $beg_membership = explode("/", $value);
 465                         if (count($beg_membership) != 2) {
 466                             $this->errors[] = _T("- Invalid format of beginning of membership.");
 467                         } else {
 468                             $now = getdate();
 469                             if (!checkdate($beg_membership[1], $beg_membership[0], $now['year'])) {
 470                                 $this->errors[] = _T("- Invalid date for beginning of membership.");
 471                             }
 472                         }
 473                         break;
 474                     case 'pref_card_year':
 475                         if (!preg_match('/^(?:\d{4}|\d{2})(\D?)(?:\d{4}|\d{2})$/', $value)) {
 476                             $this->errors[] = _T("- Invalid year for cards.");
 477                         }
 478                         break;
 479                 }
 480             }
 481
 482             $insert_values[$fieldname] = $value;
 483         }
 484
 485         // missing relations
 486         if (GALETTE_MODE !== 'DEMO'
 487             && isset($insert_values['pref_mail_method'])
 488         ) {
 489             if ($insert_values['pref_mail_method'] > GaletteMail::METHOD_DISABLED) {
 490                 if (!isset($insert_values['pref_email_nom'])
 491                     || $insert_values['pref_email_nom'] == ''
 492                 ) {
 493                     $this->errors[] = _T("- You must indicate a sender name for emails!");
 494                 }
 495                 if (!isset($insert_values['pref_email'])
 496                     || $insert_values['pref_email'] == ''
 497                 ) {
 498                     $this->errors[] = _T("- You must indicate an email address Galette should use to send emails!");
 499                 }
 500                 if ($insert_values['pref_mail_method'] == GaletteMail::METHOD_SMTP) {
 501                     if (!isset($insert_values['pref_mail_smtp_host'])
 502                         || $insert_values['pref_mail_smtp_host'] == ''
 503                     ) {
 504                         $this->errors[] = _T("- You must indicate the SMTP server you want to use!");
 505                     }
 506                 }
 507                 if ($insert_values['pref_mail_method'] == GaletteMail::METHOD_GMAIL
 508                     || ($insert_values['pref_mail_method'] == GaletteMail::METHOD_SMTP
 509                     && $insert_values['pref_mail_smtp_auth'])
 510                 ) {
 511                     if (!isset($insert_values['pref_mail_smtp_user'])
 512                         || trim($insert_values['pref_mail_smtp_user']) == ''
 513                     ) {
 514                         $this->errors[] = _T("- You must provide a login for SMTP authentication.");
 515                     }
 516                     if (!isset($insert_values['pref_mail_smtp_password'])
 517                         || ($insert_values['pref_mail_smtp_password']) == ''
 518                     ) {
 519                         $this->errors[] = _T("- You must provide a password for SMTP authentication.");
 520                     }
 521                 }
 522             }
 523         }
 524
 525         if (isset($insert_values['pref_beg_membership'])
 526             && $insert_values['pref_beg_membership'] != ''
 527             && isset($insert_values['pref_membership_ext'])
 528             && $insert_values['pref_membership_ext'] != ''
 529         ) {
 530             $this->errors[] =_T("- Default membership extention and beginning of membership are mutually exclusive.");
 531         }
 532
 533         // missing required fields?
 534         foreach ($this->required as $val) {
 535             if (!isset($values[$val]) || isset($values[$val]) && trim($values[$val]) == '') {
 536                 $this->errors[] = str_replace(
 537                     '%field',
 538                     $val,
 539                     _T("- Mandatory field %field empty.")
 540                 );
 541             }
 542         }
 543
 544         if (GALETTE_MODE !== 'DEMO') {
 545             // Check passwords. Hash will be done into the Preferences class
 546             if (strcmp($insert_values['pref_admin_pass'], $values['pref_admin_pass_check']) != 0) {
 547                 $this->errors[] = _T("Passwords mismatch");
 548             }
 549         }
 550
 551         //postal address
 552         if (isset($insert_values['pref_postal_adress'])) {
 553             $value = $insert_values['pref_postal_adress'];
 554             if ($value == Preferences::POSTAL_ADDRESS_FROM_PREFS) {
 555                 if (isset($insert_values['pref_postal_staff_member'])) {
 556                     unset($insert_values['pref_postal_staff_member']);
 557                 }
 558             } elseif ($value == Preferences::POSTAL_ADDRESS_FROM_STAFF) {
 559                 if (!isset($value) || $value < 1) {
 560                     $this->errors[] = _T("You have to select a staff member");
 561                 }
 562             }
 563         }
 564
 565         // update preferences
 566         foreach ($insert_values as $champ => $valeur) {
 567             if ($login->isSuperAdmin()
 568                 || (!$login->isSuperAdmin()
 569                 && ($champ != 'pref_admin_pass' && $champ != 'pref_admin_login'))
 570             ) {
 571                 if (($champ == "pref_admin_pass" && $_POST['pref_admin_pass'] !=  '')
 572                     || ($champ != "pref_admin_pass")
 573                 ) {
 574                     $this->$champ = $valeur;
 575                 }
 576             }
 577         }
 578
 579         return 0 === count($this->errors);
 580     }
 581
 582     /**
 583      * Will store all preferences in the database
 584      *
 585      * @return boolean
 586      */
 587     public function store()
 588     {
 589         try {
 590             $this->zdb->connection->beginTransaction();
 591             $update = $this->zdb->update(self::TABLE);
 592             $update->set(
 593                 array(
 594                     'val_pref'  => ':val_pref'
 595                 )
 596             )->where->equalTo('nom_pref', ':nom_pref');
 597
 598             $stmt = $this->zdb->sql->prepareStatementForSqlObject($update);
 599
 600             foreach (self::$defaults as $k => $v) {
 601                 Analog::log('Storing ' . $k, Analog::DEBUG);
 602
 603                 $value = $this->prefs[$k];
 604                 //do not store pdf_adhesion_form, it's designed to be overriden by plugin
 605                 if ($k === 'pref_adhesion_form') {
 606                     if (trim($v) == '') {
 607                         //Reset to default, should not be empty
 608                         $v = self::$defaults['pref_adhesion_form'];
 609                     }
 610                     $value = $v;
 611                 }
 612
 613                 $stmt->execute(
 614                     array(
 615                         'val_pref'  => $value,
 616                         'where1'    => $k
 617                     )
 618                 );
 619             }
 620             $this->zdb->connection->commit();
 621             Analog::log(
 622                 'Preferences were successfully stored into database.',
 623                 Analog::INFO
 624             );
 625             return true;
 626         } catch (\Exception $e) {
 627             $this->zdb->connection->rollBack();
 628
 629             $messages = array();
 630             do {
 631                 $messages[] = $e->getMessage();
 632             } while ($e = $e->getPrevious());
 633
 634             Analog::log(
 635                 'Unable to store preferences | ' . print_r($messages, true),
 636                 Analog::WARNING
 637             );
 638             return false;
 639         }
 640     }
 641
 642     /**
 643      * Returns postal address
 644      *
 645      * @return string postal address
 646      */
 647     public function getPostalAddress()
 648     {
 649         $regs = array(
 650           '/%name/',
 651           '/%complement/',
 652           '/%address/',
 653           '/%zip/',
 654           '/%town/',
 655           '/%country/',
 656         );
 657
 658         $replacements = null;
 659
 660         if ($this->prefs['pref_postal_adress'] == self::POSTAL_ADDRESS_FROM_PREFS) {
 661             $_address = $this->prefs['pref_adresse'];
 662             if ($this->prefs['pref_adresse2'] && $this->prefs['pref_adresse2'] != '') {
 663                 $_address .= "\n" . $this->prefs['pref_adresse2'];
 664             }
 665             $replacements = array(
 666                 '',
 667                 '',
 668                 $_address,
 669                 $this->prefs['pref_cp'],
 670                 $this->prefs['pref_ville'],
 671                 $this->prefs['pref_pays']
 672             );
 673         } else {
 674             //get selected staff member address
 675             $adh = new Adherent($this->zdb, (int)$this->prefs['pref_postal_staff_member']);
 676             $_complement = preg_replace(
 677                 array('/%name/', '/%status/'),
 678                 array($this->prefs['pref_nom'], $adh->sstatus),
 679                 _T("%name association's %status")
 680             ) . "\n";
 681             $_address = $adh->address;
 682             if ($adh->address_continuation && $adh->address_continuation != '') {
 683                 $_address .= "\n" . $adh->address_continuation;
 684             }
 685             $replacements = array(
 686                 $adh->sfullname . "\n",
 687                 $_complement,
 688                 $_address,
 689                 $adh->zipcode,
 690                 $adh->town,
 691                 $adh->country
 692             );
 693         }
 694
 695         /*FIXME: i18n fails :/ */
 696         /*$r = preg_replace(
 697             $regs,
 698             $replacements,
 699             _T("%name\n%complement\n%address\n%zip %town - %country")
 700         );*/
 701         $r = preg_replace(
 702             $regs,
 703             $replacements,
 704             "%name%complement%address\n%zip %town - %country"
 705         );
 706         return $r;
 707     }
 708
 709     /**
 710      * Are public pages visibles?
 711      *
 712      * @param Authentication $login Authenticaqtion instance
 713      *
 714      * @return boolean
 715      */
 716     public function showPublicPages(Authentication $login)
 717     {
 718         if ($this->prefs['pref_bool_publicpages']) {
 719             //if public pages are actives, let's check if we
 720             //display them for curent call
 721             switch ($this->prefs['pref_publicpages_visibility']) {
 722                 case self::PUBLIC_PAGES_VISIBILITY_PUBLIC:
 723                     //pages are publically visibles
 724                     return true;
 725                     break;
 726                 case self::PUBLIC_PAGES_VISIBILITY_RESTRICTED:
 727                     //pages should be displayed only for up to date members
 728                     if ($login->isUp2Date()
 729                         || $login->isAdmin()
 730                         || $login->isStaff()
 731                     ) {
 732                         return true;
 733                     } else {
 734                         return false;
 735                     }
 736                     break;
 737                 case self::PUBLIC_PAGES_VISIBILITY_PRIVATE:
 738                     //pages should be displayed only for staff and admins
 739                     if ($login->isAdmin() || $login->isStaff()) {
 740                         return true;
 741                     } else {
 742                         return false;
 743                     }
 744                     break;
 745                 default:
 746                     //should never be there
 747                     return false;
 748                     break;
 749             }
 750         } else {
 751             return false;
 752         }
 753     }
 754
 755     /**
 756      * Global getter method
 757      *
 758      * @param string $name name of the property we want to retrive
 759      *
 760      * @return false|object the called property
 761      */
 762     public function __get($name)
 763     {
 764         $forbidden = array('logged', 'admin', 'active', 'defaults');
 765         $virtuals = array('vpref_email_newadh');
 766
 767         if (!in_array($name, $forbidden) && isset($this->prefs[$name])) {
 768             if (GALETTE_MODE === 'DEMO'
 769                 && $name == 'pref_mail_method'
 770             ) {
 771                 return GaletteMail::METHOD_DISABLED;
 772             } else {
 773                 if ($name == 'pref_adhesion_form' && $this->prefs[$name] == '') {
 774                     $this->prefs[$name] = self::$defaults['pref_adhesion_form'];
 775                 }
 776                 $value = $this->prefs[$name];
 777                 if (TYPE_DB === \Galette\Core\Db::PGSQL) {
 778                     if ($value === 'f') {
 779                         $value = false;
 780                     }
 781                 }
 782
 783                 if (in_array($name, ['pref_email_newadh'])) {
 784                     $values = explode(',', $value);
 785                     $value = $values[0]; //take first as default
 786                 }
 787
 788                 return $value;
 789             }
 790         } elseif (in_array($name, $virtuals)) {
 791             $virtual = str_replace('vpref_', 'pref_', $name);
 792             return explode(',', $this->prefs[$virtual]);
 793         } else {
 794             Analog::log(
 795                 'Preference `' . $name . '` is not set or is forbidden',
 796                 Analog::INFO
 797             );
 798             return false;
 799         }
 800     }
 801
 802     /**
 803      * Get default preferences
 804      *
 805      * @return array
 806      */
 807     public function getDefaults()
 808     {
 809         return self::$defaults;
 810     }
 811
 812     /**
 813      * Global setter method
 814      *
 815      * @param string $name  name of the property we want to assign a value to
 816      * @param object $value a relevant value for the property
 817      *
 818      * @return void
 819      */
 820     public function __set($name, $value)
 821     {
 822         //does this pref exists ?
 823         if (!array_key_exists($name, self::$defaults)) {
 824             Analog::log(
 825                 'Trying to set a preference value which does not seem to exist ('
 826                 . $name . ')',
 827                 Analog::WARNING
 828             );
 829             return false;
 830         }
 831
 832         if ($name == 'pref_email'
 833             || $name == 'pref_email_newadh'
 834             || $name == 'pref_email_reply_to'
 835         ) {
 836             if (GALETTE_MODE === 'DEMO') {
 837                 Analog::log(
 838                     'Trying to set pref_email while in DEMO.',
 839                     Analog::WARNING
 840                 );
 841                 return;
 842             }
 843
 844             //check emails validity
 845             //may be a comma separated list of valid mails identifiers:
 846             //"The Name <mail@domain.com>,The Other <other@mail.com>" expect for reply_to.
 847             $addresses = [];
 848             if (trim($value) != '') {
 849                 if ($name == 'pref_email_newadh') {
 850                     $addresses = explode(',', $value);
 851                 } else {
 852                     $addresses = [$value];
 853                 }
 854             }
 855             foreach ($addresses as $address) {
 856                 if (!GaletteMail::isValidEmail($address)) {
 857                     $msg =  str_replace('%s', $address, _T("Invalid E-Mail address: %s"));
 858                     Analog::log($msg, Analog::WARNING);
 859                     $this->errors[] = $msg;
 860                 }
 861             }
 862         }
 863
 864         //some values need to be changed (eg. passwords)
 865         if ($name == 'pref_admin_pass') {
 866             $value = password_hash($value, PASSWORD_BCRYPT);
 867         }
 868
 869         //okay, let's update value
 870         $this->prefs[$name] = $value;
 871     }
 872
 873     /**
 874      * Get instance URL from configuration (if set) or guessed if not
 875      *
 876      * @return string
 877      */
 878     public function getURL()
 879     {
 880         $url = null;
 881         if (isset($this->prefs['pref_galette_url']) && !empty($this->prefs['pref_galette_url'])) {
 882             $url = $this->prefs['pref_galette_url'];
 883         } else {
 884             $url = $this->getDefaultURL();
 885         }
 886         return $url;
 887     }
 888
 889     /**
 890      * Get default URL (when not setted by user in preferences)
 891      *
 892      * @return string
 893      */
 894     public function getDefaultURL()
 895     {
 896         $scheme = (isset($_SERVER['HTTPS']) ? 'https' : 'http');
 897         $uri = $scheme . '://' . $_SERVER['HTTP_HOST'];
 898         return $uri;
 899     }
 900
 901     /**
 902      * Check member cards sizes
 903      * Always a A4/portrait
 904      *
 905      * @return array
 906      */
 907     public function checkCardsSizes()
 908     {
 909         $warning_detected = [];
 910         //check page width
 911         $max = 210;
 912         //margins
 913         $size = $this->pref_card_marges_h * 2;
 914         //cards
 915         $size += PdfMembersCards::getWidth() * PdfMembersCards::getCols();
 916         //spacing
 917         $size += $this->pref_card_hspace * (PdfMembersCards::getCols() - 1);
 918         if ($size > $max) {
 919             $warning_detected[] = _T('Current cards configuration may exceed page width!');
 920         }
 921
 922         $max = 297;
 923         //margins
 924         $size = $this->pref_card_marges_v * 2;
 925         //cards
 926         $size += PdfMembersCards::getHeight() * PdfMembersCards::getRows();
 927         //spacing
 928         $size += $this->pref_card_vspace * (PdfMembersCards::getRows() - 1);
 929         if ($size > $max) {
 930             $warning_detected[] = _T('Current cards configuration may exceed page height!');
 931         }
 932
 933         return $warning_detected;
 934     }
 935
 936     /**
 937      * Get errors
 938      *
 939      * @return array
 940      */
 941     public function getErrors()
 942     {
 943         return $this->errors;
 944     }
 945 }