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