galette/lib/Galette/Entity/SavedSearch.php

   1 <?php
   2
   3 /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
   4
   5 /**
   6  * Saved search
   7  *
   8  * PHP version 5
   9  *
  10  * Copyright © 2019-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 2019-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.9.3dev - 2019-03-25
  35  */
  36
  37 namespace Galette\Entity;
  38
  39 use Throwable;
  40 use Galette\Core;
  41 use Galette\Core\Db;
  42 use Galette\Core\Login;
  43 use Analog\Analog;
  44
  45 /**
  46  * Saved search
  47  *
  48  * @category  Entity
  49  * @name      SavedSearch
  50  * @package   Galette
  51  * @author    Johan Cwiklinski <johan@x-tnd.be>
  52  * @copyright 2019-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.9.3dev - 2019-03-25
  56  */
  57
  58 class SavedSearch
  59 {
  60     public const TABLE = 'searches';
  61     public const PK = 'search_id';
  62
  63     private $zdb;
  64     private $id;
  65     private $name;
  66     private $parameters = [];
  67     private $author_id;
  68     private $creation_date;
  69     private $form;
  70
  71     private $login;
  72     private $errors = [];
  73
  74     /**
  75      * Main constructor
  76      *
  77      * @param Db    $zdb   Database instance
  78      * @param Login $login Login instance
  79      * @param mixed $args  Arguments
  80      */
  81     public function __construct(Db $zdb, Login $login, $args = null)
  82     {
  83         $this->zdb = $zdb;
  84         $this->login = $login;
  85         $this->creation_date = date('Y-m-d H:i:s');
  86
  87         if (is_int($args)) {
  88             $this->load($args);
  89         } elseif ($args !== null && is_object($args)) {
  90             $this->loadFromRs($args);
  91         }
  92     }
  93
  94     /**
  95      * Load a saved search from its identifier
  96      *
  97      * @param integer $id Identifier
  98      *
  99      * @return void
 100      */
 101     private function load($id)
 102     {
 103         try {
 104             $select = $this->zdb->select(self::TABLE);
 105             $select->limit(1)->where([self::PK => $id]);
 106             if ($this->login->isSuperAdmin()) {
 107                 $select->where(Adherent::PK . ' IS NULL');
 108             } else {
 109                 $select->where([Adherent::PK => $this->login->id]);
 110             }
 111
 112             $results = $this->zdb->execute($select);
 113             $res = $results->current();
 114
 115             $this->loadFromRs($res);
 116         } catch (Throwable $e) {
 117             Analog::log(
 118                 'An error occurred loading saved search #' . $id . "Message:\n" .
 119                 $e->getMessage(),
 120                 Analog::ERROR
 121             );
 122             throw $e;
 123         }
 124     }
 125
 126     /**
 127      * Load a saved search from a db ResultSet
 128      *
 129      * @param ResultSet $rs ResultSet
 130      *
 131      * @return void
 132      */
 133     private function loadFromRs($rs)
 134     {
 135         $pk = self::PK;
 136         $this->id = $rs->$pk;
 137         $this->name = $rs->name;
 138         $this->parameters = json_decode($rs->parameters, true);
 139         $this->author_id = $rs->id_adh;
 140         $this->creation_date = $rs->creation_date;
 141         $this->form = $rs->form;
 142     }
 143
 144     /**
 145      * Check and set values
 146      *
 147      * @param array $values Values to set
 148      *
 149      * @return boolean
 150      */
 151     public function check($values)
 152     {
 153         $this->errors = [];
 154         $mandatory = [
 155             'form'  => _T('Form is mandatory!')
 156         ];
 157
 158         foreach ($values as $key => $value) {
 159             if (in_array($key, ['nbshow', 'page'])) {
 160                 continue;
 161             }
 162             if (empty($value) && isset($mandatory[$key])) {
 163                 $this->errors[] = $mandatory[$key];
 164             }
 165             $this->$key = $value;
 166             unset($mandatory[$key]);
 167         }
 168
 169         if (count($mandatory)) {
 170             $this->errors = array_merge($this->errors, $mandatory);
 171         }
 172
 173         if ($this->id === null && !$this->login->isSuperAdmin()) {
 174             //set author for new searches
 175             $this->author_id = $this->login->id;
 176         }
 177
 178         return (count($this->errors) === 0);
 179     }
 180
 181     /**
 182      * Store saved search in database
 183      *
 184      * @return boolean|null
 185      */
 186     public function store()
 187     {
 188         $parameters = json_encode($this->parameters);
 189         $data = array(
 190             'name'              => $this->name,
 191             'parameters'        => $parameters,
 192             'id_adh'            => $this->author_id,
 193             'creation_date'     => ($this->creation_date !== null ? $this->creation_date : date('Y-m-d H:i:s')),
 194             'form'              => $this->form
 195         );
 196
 197         try {
 198             $insert = $this->zdb->insert(self::TABLE);
 199             $insert->values($data);
 200             $add = $this->zdb->execute($insert);
 201             if (!$add->count() > 0) {
 202                 Analog::log('Not stored!', Analog::ERROR);
 203                 return false;
 204             }
 205             return true;
 206         } catch (Throwable $e) {
 207             Analog::log(
 208                 'An error occurred storing saved search: ' . $e->getMessage() .
 209                 "\n" . print_r($data, true),
 210                 Analog::ERROR
 211             );
 212             throw $e;
 213         }
 214     }
 215
 216     /**
 217      * Remove current saved search
 218      *
 219      * @return boolean
 220      */
 221     public function remove()
 222     {
 223         $id = (int)$this->id;
 224         try {
 225             $delete = $this->zdb->delete(self::TABLE);
 226             $delete->where([self::PK => $id]);
 227             $this->zdb->execute($delete);
 228             Analog::log(
 229                 'Saved search #' . $id . ' (' . $this->name
 230                 . ') deleted successfully.',
 231                 Analog::INFO
 232             );
 233             return true;
 234         } catch (\RuntimeException $re) {
 235             throw $re;
 236         } catch (Throwable $e) {
 237             Analog::log(
 238                 'Unable to delete saved search ' . $id . ' | ' . $e->getMessage(),
 239                 Analog::ERROR
 240             );
 241             throw $e;
 242         }
 243     }
 244
 245     /**
 246      * Getter
 247      *
 248      * @param string $name Property name
 249      *
 250      * @return mixed
 251      */
 252     public function __get($name)
 253     {
 254         $forbidden = [];
 255         $virtuals = ['sparameters'];
 256         if (
 257             in_array($name, $virtuals)
 258             || !in_array($name, $forbidden)
 259             && isset($this->$name)
 260         ) {
 261             switch ($name) {
 262                 case 'creation_date':
 263                     if ($this->$name != '') {
 264                         try {
 265                             $d = new \DateTime($this->$name);
 266                             return $d->format(__("Y-m-d"));
 267                         } catch (Throwable $e) {
 268                             //oops, we've got a bad date :/
 269                             Analog::log(
 270                                 'Bad date (' . $this->$name . ') | ' .
 271                                 $e->getMessage(),
 272                                 Analog::INFO
 273                             );
 274                             return $this->$name;
 275                         }
 276                     }
 277                     break;
 278                 case 'sparameters':
 279                     include_once GALETTE_ROOT . 'includes/fields_defs/members_fields.php';
 280                     $parameters = [];
 281                     foreach ((array)$this->parameters as $key => $parameter) {
 282                         if (isset($members_fields[$key])) {
 283                             $key = $members_fields[$key]['label'];
 284                         }
 285                         if (is_array($parameter) || is_object($parameter)) {
 286                             $parameter = json_encode($parameter);
 287                         }
 288                         $parameters[$key] = $parameter;
 289                     }
 290                     return $parameters;
 291                     break;
 292                 default:
 293                     if (!property_exists($this, $name)) {
 294                         Analog::log(
 295                             "Unknown property '$name'",
 296                             Analog::WARNING
 297                         );
 298                         return null;
 299                     } else {
 300                         return $this->$name;
 301                     }
 302                     break;
 303             }
 304         }
 305     }
 306
 307     /**
 308      * Setter
 309      *
 310      * @param string $name  Property name
 311      * @param mixed  $value Property value
 312      *
 313      * @return void
 314      */
 315     public function __set($name, $value)
 316     {
 317         switch ($name) {
 318             case 'form':
 319                 if (!in_array($value, $this->getKnownForms())) {
 320                     $this->errors[] = str_replace('%form', $value, _T("Unknown form %form!"));
 321                 }
 322                 $this->form = $value;
 323                 break;
 324             case 'parameters':
 325                 if (!is_array($value)) {
 326                     Analog::log(
 327                         'Search parameters must be an array!',
 328                         Analog::ERROR
 329                     );
 330                 }
 331                 $this->parameters = $value;
 332                 break;
 333             case 'name':
 334                 if (trim($value) === '') {
 335                     $this->errors[] = _T("Name cannot be empty!");
 336                 }
 337                 $this->name = $value;
 338                 break;
 339             case 'author_id':
 340                 $this->author_id = (int)$value;
 341                 break;
 342             default:
 343                 Analog::log(
 344                     str_replace(
 345                         ['%class', '%property'],
 346                         [self::class, $name],
 347                         'Unable to set %class property %property'
 348                     ),
 349                     Analog::WARNING
 350                 );
 351                 break;
 352         }
 353     }
 354
 355     /**
 356      * Get known forms
 357      *
 358      * @return array
 359      */
 360     public function getKnownForms()
 361     {
 362         return [
 363             'Adherent'
 364         ];
 365     }
 366
 367     /**
 368      * Get errors
 369      *
 370      * @return array
 371      */
 372     public function getErrors()
 373     {
 374         return $this->errors;
 375     }
 376 }