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