galette/lib/Galette/Entity/DynamicsTrait.php

   1 <?php
   2
   3 /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
   4
   5 /**
   6  * Dynamics fields trait
   7  *
   8  * PHP version 5
   9  *
  10  * Copyright © 2017-2021 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  Entity
  28  * @package   Galette
  29  *
  30  * @author    Johan Cwiklinski <johan@x-tnd.be>
  31  * @copyright 2017-2021 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  * @link      http://galette.tuxfamily.org
  34  * @since     Available since 0.9dev - 2017-05-26
  35  */
  36
  37 namespace Galette\Entity;
  38
  39 use Throwable;
  40 use Analog\Analog;
  41 use Galette\DynamicFields\File;
  42 use Galette\DynamicFields\Date;
  43 use Galette\DynamicFields\Boolean;
  44
  45 /**
  46  * Dynamics fields trait
  47  *
  48  * @category  Entity
  49  * @name      DynamicsTrait
  50  * @package   Galette
  51  * @author    Johan Cwiklinski <johan@x-tnd.be>
  52  * @copyright 2017-2021 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.9dev - 2017-05-26
  56  */
  57
  58 trait DynamicsTrait
  59 {
  60     /** @var string */
  61     protected $name_pattern = 'info_field_';
  62
  63     /** @var DynamicFieldsHandle */
  64     protected $dynamics;
  65
  66     /**
  67      * Load dynamic fields for member
  68      *
  69      * @return void
  70      */
  71     private function loadDynamicFields()
  72     {
  73         if (!property_exists($this, 'login')) {
  74             global $login;
  75         } else {
  76             $login = $this->login;
  77         }
  78         $this->dynamics = new DynamicFieldsHandle($this->zdb, $login, $this);
  79     }
  80
  81     /**
  82      * Get dynamic fields
  83      *
  84      * @return array
  85      */
  86     public function getDynamicFields()
  87     {
  88         if (null === $this->dynamics) {
  89             $this->loadDynamicFields();
  90         }
  91         return $this->dynamics;
  92     }
  93
  94     /**
  95      * Extract posted values for dynamic fields
  96      *
  97      * @param array $post     Posted values
  98      * @param array $required Array of required fields
  99      * @param array $disabled Array of disabled fields
 100      *
 101      * @return boolean
 102      */
 103     protected function dynamicsCheck(array $post, array $required, array $disabled)
 104     {
 105         if ($this->dynamics === null) {
 106             Analog::log(
 107                 'Dynamics fields have not been loaded, cannot be checked. (from: ' . __METHOD__ . ')',
 108                 Analog::WARNING
 109             );
 110             $this->loadDynamicFields();
 111         }
 112
 113         if ($post != null) {
 114             $valid = true;
 115             $fields = $this->dynamics->getFields();
 116
 117             $dynamic_fields = [];
 118             //posted fields
 119             foreach ($post as $key => $value) {
 120                 // if the field is enabled, and match patterns check it
 121                 if (isset($disabled[$key]) || substr($key, 0, 11) != $this->name_pattern) {
 122                     continue;
 123                 }
 124
 125                 list($field_id, $val_index) = explode('_', str_replace($this->name_pattern, '', $key));
 126                 if (!is_numeric($field_id) || !is_numeric($val_index)) {
 127                     continue;
 128                 }
 129
 130                 $dynamic_fields[$key] = [
 131                     'value'     => $value,
 132                     'field_id'  => $field_id,
 133                     'val_index' => $val_index
 134                 ];
 135             }
 136
 137             //some fields may be mising in posted values (checkboxes)
 138             foreach ($fields as $field) {
 139                 $pattern = '/' . $this->name_pattern . $field->getId() . '_(\d)/';
 140                 if ($field instanceof Boolean && !preg_grep($pattern, array_keys($dynamic_fields))) {
 141                     $dynamic_fields[$this->name_pattern . $field->getId() . '_1'] = [
 142                         'value'     => '',
 143                         'field_id'  => $field->getId(),
 144                         'val_index' => 1
 145                     ];
 146                 }
 147             }
 148
 149             foreach ($dynamic_fields as $key => $dfield_values) {
 150                 $field_id = $dfield_values['field_id'];
 151                 $value = $dfield_values['value'];
 152                 $val_index = $dfield_values['val_index'];
 153
 154                 if ($fields[$field_id]->isRequired() && (trim($value) === '' || $value == null)) {
 155                     $this->errors[] = str_replace(
 156                         '%field',
 157                         $fields[$field_id]->getName(),
 158                         _T('Missing required field %field')
 159                     );
 160                 } else {
 161                     if ($fields[$field_id] instanceof File) {
 162                         //delete checkbox
 163                         $filename = sprintf(
 164                             'member_%d_field_%d_value_%d',
 165                             $this->id,
 166                             $field_id,
 167                             $val_index
 168                         );
 169                         if (file_exists(GALETTE_FILES_PATH . $filename)) {
 170                             unlink(GALETTE_FILES_PATH . $filename);
 171                         }
 172                         $this->dynamics->setValue($this->id, $field_id, $val_index, '');
 173                     } else {
 174                         if ($fields[$field_id] instanceof Date && !empty(trim($value))) {
 175                             //check date format
 176                             try {
 177                                 $d = \DateTime::createFromFormat(__("Y-m-d"), $value);
 178                                 if ($d === false) {
 179                                     //try with non localized date
 180                                     $d = \DateTime::createFromFormat("Y-m-d", $value);
 181                                     if ($d === false) {
 182                                         throw new \Exception('Incorrect format');
 183                                     }
 184                                 }
 185                             } catch (Throwable $e) {
 186                                 $valid = false;
 187                                 Analog::log(
 188                                     'Wrong date format. field: ' . $field_id .
 189                                     ', value: ' . $value . ', expected fmt: ' .
 190                                     __("Y-m-d") . ' | ' . $e->getMessage(),
 191                                     Analog::INFO
 192                                 );
 193                                 $this->errors[] = str_replace(
 194                                     array(
 195                                         '%date_format',
 196                                         '%field'
 197                                     ),
 198                                     array(
 199                                         __("Y-m-d"),
 200                                         $fields[$field_id]->getName()
 201                                     ),
 202                                     _T("- Wrong date format (%date_format) for %field!")
 203                                 );
 204                             }
 205                         }
 206                         //actual field value
 207                         if ($value !== null && trim($value) !== '') {
 208                             $this->dynamics->setValue($this->id, $field_id, $val_index, $value);
 209                         } else {
 210                             $this->dynamics->unsetValue($this->id, $field_id, $val_index);
 211                         }
 212                     }
 213                 }
 214             }
 215
 216             return $valid;
 217         }
 218     }
 219
 220     /**
 221      * Stores dynamic fields
 222      *
 223      * @param boolean $transaction True if a transaction already exists
 224      *
 225      * @return boolean
 226      */
 227     protected function dynamicsStore($transaction = false)
 228     {
 229         if ($this->dynamics === null) {
 230             Analog::log(
 231                 'Dynamics fields have not been loaded, cannot be stored. (from: ' . __METHOD__ . ')',
 232                 Analog::WARNING
 233             );
 234             $this->loadDynamicFields();
 235         }
 236         $return = $this->dynamics->storeValues($this->id, $transaction);
 237         if (method_exists($this, 'updateModificationDate') && $this->dynamics->hasChanged()) {
 238             $this->updateModificationDate();
 239         }
 240         return $return;
 241     }
 242
 243     /**
 244      * Store dynamic Files
 245      *
 246      * @param array $files Posted files
 247      *
 248      * @return void
 249      */
 250     protected function dynamicsFiles($files)
 251     {
 252         $this->loadDynamicFields();
 253         $fields = $this->dynamics->getFields();
 254         $store = false;
 255
 256         foreach ($files as $key => $file) {
 257             // if the field is disabled, skip it
 258             if (isset($disabled[$key])) {
 259                 continue;
 260             }
 261
 262             if (substr($key, 0, 11) != $this->name_pattern) {
 263                 continue;
 264             }
 265
 266             list($field_id, $val_index) = explode('_', str_replace($this->name_pattern, '', $key));
 267             if (!is_numeric($field_id) || !is_numeric($val_index)) {
 268                 continue;
 269             }
 270
 271             if (
 272                 $file['error'] == UPLOAD_ERR_NO_FILE
 273                 && $file['name'] == ''
 274                 && $file['tmp_name'] == ''
 275             ) {
 276                 //not upload atempt.
 277                 continue;
 278             } elseif ($file['error'] !== UPLOAD_ERR_OK) {
 279                 Analog::log("file upload error", Analog::ERROR);
 280                 continue;
 281             }
 282
 283             $tmp_filename = $file['tmp_name'];
 284             if ($tmp_filename == '') {
 285                 Analog::log("empty temporary filename", Analog::ERROR);
 286                 continue;
 287             }
 288
 289             if (!is_uploaded_file($tmp_filename)) {
 290                 Analog::log("not an uploaded file", Analog::ERROR);
 291                 continue;
 292             }
 293
 294             $max_size =
 295                 $fields[$field_id]->getSize() ?
 296                 $fields[$field_id]->getSize() * 1024 : File::DEFAULT_MAX_FILE_SIZE * 1024;
 297             if ($file['size'] > $max_size) {
 298                 Analog::log(
 299                     "file too large: " . $file['size'] . " Ko, vs $max_size Ko allowed",
 300                     Analog::ERROR
 301                 );
 302                 $this->errors[] = preg_replace(
 303                     '|%d|',
 304                     $max_size,
 305                     _T("File is too big. Maximum allowed size is %dKo")
 306                 );
 307                 continue;
 308             }
 309
 310             $new_filename = sprintf(
 311                 'member_%d_field_%d_value_%d',
 312                 $this->id,
 313                 $field_id,
 314                 $val_index
 315             );
 316             Analog::log("new file: $new_filename", Analog::DEBUG);
 317
 318             move_uploaded_file(
 319                 $tmp_filename,
 320                 GALETTE_FILES_PATH . $new_filename
 321             );
 322             $this->dynamics->setValue($this->id, $field_id, $val_index, $file['name']);
 323             $store = true;
 324         }
 325
 326         if ($store === true) {
 327             $this->dynamicsStore();
 328         }
 329     }
 330
 331     /**
 332      * Remove dynamic fields values
 333      *
 334      * @param boolean $transaction True if a transaction already exists
 335      *
 336      * @return boolean
 337      */
 338     protected function dynamicsRemove($transaction = false)
 339     {
 340         if ($this->dynamics === null) {
 341             Analog::log(
 342                 'Dynamics fields have not been loaded, cannot be removed. (from: ' . __METHOD__ . ')',
 343                 Analog::WARNING
 344             );
 345             $this->loadDynamicFields();
 346         }
 347         $return = $this->dynamics->removeValues($this->id, $transaction);
 348         return $return;
 349     }
 350
 351
 352
 353     /**
 354      * Get errors
 355      *
 356      * @return array
 357      */
 358     public function getErrors()
 359     {
 360         return $this->errors;
 361     }
 362
 363     /**
 364      * Validate data for dynamic fields
 365      * Set valid data in current object, also resets errors list
 366      *
 367      * @param array  $values Dynamic fields values
 368      * @param string $prefix Prefix to replace, default to 'dynfield_'
 369      *
 370      * @return void
 371      */
 372     public function dynamicsValidate($values, $prefix = 'dynfield_')
 373     {
 374         $dfields = [];
 375         foreach ($values as $key => $value) {
 376             $dfields[str_replace($prefix, $this->name_pattern, $key)] = $value;
 377         }
 378         return $this->dynamicsCheck($dfields, [], []);
 379     }
 380 }