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-2018 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-2018 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-2018 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                         unlink(GALETTE_FILES_PATH . $filename);
 170                         $this->dynamics->setValue($this->id, $field_id, $val_index, '');
 171                     } else {
 172                         if ($fields[$field_id] instanceof Date && !empty(trim($value))) {
 173                             //check date format
 174                             try {
 175                                 $d = \DateTime::createFromFormat(__("Y-m-d"), $value);
 176                                 if ($d === false) {
 177                                     //try with non localized date
 178                                     $d = \DateTime::createFromFormat("Y-m-d", $value);
 179                                     if ($d === false) {
 180                                         throw new \Exception('Incorrect format');
 181                                     }
 182                                 }
 183                             } catch (Throwable $e) {
 184                                 $valid = false;
 185                                 Analog::log(
 186                                     'Wrong date format. field: ' . $field_id .
 187                                     ', value: ' . $value . ', expected fmt: ' .
 188                                     __("Y-m-d") . ' | ' . $e->getMessage(),
 189                                     Analog::INFO
 190                                 );
 191                                 $this->errors[] = str_replace(
 192                                     array(
 193                                         '%date_format',
 194                                         '%field'
 195                                     ),
 196                                     array(
 197                                         __("Y-m-d"),
 198                                         $fields[$field_id]->getName()
 199                                     ),
 200                                     _T("- Wrong date format (%date_format) for %field!")
 201                                 );
 202                             }
 203                         }
 204                         //actual field value
 205                         if ($value !== null && trim($value) !== '') {
 206                             $this->dynamics->setValue($this->id, $field_id, $val_index, $value);
 207                         } else {
 208                             $this->dynamics->unsetValue($this->id, $field_id, $val_index);
 209                         }
 210                     }
 211                 }
 212             }
 213
 214             return $valid;
 215         }
 216     }
 217
 218     /**
 219      * Stores dynamic fields
 220      *
 221      * @param boolean $transaction True if a transaction already exists
 222      *
 223      * @return boolean
 224      */
 225     protected function dynamicsStore($transaction = false)
 226     {
 227         if ($this->dynamics === null) {
 228             Analog::log(
 229                 'Dynamics fields have not been loaded, cannot be stored. (from: ' . __METHOD__ . ')',
 230                 Analog::WARNING
 231             );
 232             $this->loadDynamicFields();
 233         }
 234         $return = $this->dynamics->storeValues($this->id, $transaction);
 235         if (method_exists($this, 'updateModificationDate') && $this->dynamics->hasChanged()) {
 236             $this->updateModificationDate();
 237         }
 238         return $return;
 239     }
 240
 241     /**
 242      * Store dynamic Files
 243      *
 244      * @param array $files Posted files
 245      *
 246      * @return void
 247      */
 248     protected function dynamicsFiles($files)
 249     {
 250         if ($this->dynamics === null) {
 251             Analog::log(
 252                 'Dynamics fields have not been loaded, cannot be stored. (from: ' . __METHOD__ . ')',
 253                 Analog::WARNING
 254             );
 255             $this->loadDynamicFields();
 256         }
 257         $fields = $this->dynamics->getFields();
 258         $store = false;
 259
 260         foreach ($files as $key => $file) {
 261             // if the field is disabled, skip it
 262             if (isset($disabled[$key])) {
 263                 continue;
 264             }
 265
 266             if (substr($key, 0, 11) != $this->name_pattern) {
 267                 continue;
 268             }
 269
 270             list($field_id, $val_index) = explode('_', str_replace($this->name_pattern, '', $key));
 271             if (!is_numeric($field_id) || !is_numeric($val_index)) {
 272                 continue;
 273             }
 274
 275             if (
 276                 $file['error'] == UPLOAD_ERR_NO_FILE
 277                 && $file['name'] == ''
 278                 && $file['tmp_name'] == ''
 279             ) {
 280                 //not upload atempt.
 281                 continue;
 282             } elseif ($file['error'] !== UPLOAD_ERR_OK) {
 283                 Analog::log("file upload error", Analog::ERROR);
 284                 continue;
 285             }
 286
 287             $tmp_filename = $file['tmp_name'];
 288             if ($tmp_filename == '') {
 289                 Analog::log("empty temporary filename", Analog::ERROR);
 290                 continue;
 291             }
 292
 293             if (!is_uploaded_file($tmp_filename)) {
 294                 Analog::log("not an uploaded file", Analog::ERROR);
 295                 continue;
 296             }
 297
 298             $max_size =
 299                 $fields[$field_id]->getSize() ?
 300                 $fields[$field_id]->getSize() * 1024 : File::DEFAULT_MAX_FILE_SIZE * 1024;
 301             if ($file['size'] > $max_size) {
 302                 Analog::log(
 303                     "file too large: " . $file['size'] . " Ko, vs $max_size Ko allowed",
 304                     Analog::ERROR
 305                 );
 306                 $this->errors[] = preg_replace(
 307                     '|%d|',
 308                     $max_size,
 309                     _T("File is too big. Maximum allowed size is %dKo")
 310                 );
 311                 continue;
 312             }
 313
 314             $new_filename = sprintf(
 315                 'member_%d_field_%d_value_%d',
 316                 $this->id,
 317                 $field_id,
 318                 $val_index
 319             );
 320             Analog::log("new file: $new_filename", Analog::DEBUG);
 321
 322             move_uploaded_file(
 323                 $tmp_filename,
 324                 GALETTE_FILES_PATH . $new_filename
 325             );
 326             $this->dynamics->setValue($this->id, $field_id, $val_index, $file['name']);
 327             $store = true;
 328         }
 329
 330         if ($store === true) {
 331             $this->dynamicsStore();
 332         }
 333     }
 334
 335     /**
 336      * Remove dynamic fields values
 337      *
 338      * @param boolean $transaction True if a transaction already exists
 339      *
 340      * @return boolean
 341      */
 342     protected function dynamicsRemove($transaction = false)
 343     {
 344         if ($this->dynamics === null) {
 345             Analog::log(
 346                 'Dynamics fields have not been loaded, cannot be removed. (from: ' . __METHOD__ . ')',
 347                 Analog::WARNING
 348             );
 349             $this->loadDynamicFields();
 350         }
 351         $return = $this->dynamics->removeValues($this->id, $transaction);
 352         return $return;
 353     }
 354
 355
 356
 357     /**
 358      * Get errors
 359      *
 360      * @return array
 361      */
 362     public function getErrors()
 363     {
 364         return $this->errors;
 365     }
 366
 367     /**
 368      * Validate data for dynamic fields
 369      * Set valid data in current object, also resets errors list
 370      *
 371      * @param array  $values Dynamic fields values
 372      * @param string $prefix Prefix to replace, default to 'dynfield_'
 373      *
 374      * @return void
 375      */
 376     public function dynamicsValidate($values, $prefix = 'dynfield_')
 377     {
 378         $dfields = [];
 379         foreach ($values as $key => $value) {
 380             $dfields[str_replace($prefix, $this->name_pattern, $key)] = $value;
 381         }
 382         return $this->dynamicsCheck($dfields, [], []);
 383     }
 384 }