galette/lib/Galette/Controllers/Crud/DynamicFieldsController.php

   1 <?php
   2
   3 /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
   4
   5 /**
   6  * Galette dynamic fields controller
   7  *
   8  * PHP version 5
   9  *
  10  * Copyright © 2020 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  Controllers
  28  * @package   Galette
  29  *
  30  * @author    Johan Cwiklinski <johan@x-tnd.be>
  31  * @copyright 2020 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.4dev - 2020-05-02
  35  */
  36
  37 namespace Galette\Controllers\Crud;
  38
  39 use Throwable;
  40 use Galette\Controllers\CrudController;
  41 use Slim\Http\Request;
  42 use Slim\Http\Response;
  43 use Galette\DynamicFields\DynamicField;
  44 use Analog\Analog;
  45
  46 /**
  47  * Galette dynamic fields controller
  48  *
  49  * @category  Controllers
  50  * @name      DynamicFieldsController
  51  * @package   Galette
  52  * @author    Johan Cwiklinski <johan@x-tnd.be>
  53  * @copyright 2020 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.9.4dev - 2020-05-02
  57  */
  58
  59 class DynamicFieldsController extends CrudController
  60 {
  61     // CRUD - Create
  62
  63     /**
  64      * Add page
  65      *
  66      * @param Request  $request  PSR Request
  67      * @param Response $response PSR Response
  68      * @param array    $args     Request arguments
  69      *
  70      * @return Response
  71      */
  72     public function add(Request $request, Response $response, array $args = []): Response
  73     {
  74         $form_name = $args['form_name'];
  75
  76         $df = null;
  77         if ($this->session->dynamicfieldtype) {
  78             $df = $this->session->dynamicfieldtype;
  79             $this->session->dynamicfieldtype = null;
  80         }
  81
  82         $params = [
  83             'page_title'        => _T("Add field"),
  84             'form_name'         => $form_name,
  85             'action'            => 'add',
  86             'perm_names'        => DynamicField::getPermsNames(),
  87             'mode'              => ($request->isXhr() ? 'ajax' : ''),
  88             'field_type_names'  => DynamicField::getFieldsTypesNames()
  89         ];
  90
  91         // display page
  92         $this->view->render(
  93             $response,
  94             'editer_champ.tpl',
  95             $params
  96         );
  97         return $response;
  98     }
  99
 100     /**
 101      * Add action
 102      *
 103      * @param Request  $request  PSR Request
 104      * @param Response $response PSR Response
 105      * @param array    $args     Request arguments
 106      *
 107      * @return Response
 108      */
 109     public function doAdd(Request $request, Response $response, array $args = []): Response
 110     {
 111         $post = $request->getParsedBody();
 112         $post['form_name'] = $args['form_name'];
 113
 114         $error_detected = [];
 115         $warning_detected = [];
 116
 117         $df = DynamicField::getFieldType($this->zdb, $post['field_type']);
 118
 119         try {
 120             $df->store($post);
 121             $error_detected = $df->getErrors();
 122             $warning_detected = $df->getWarnings();
 123         } catch (Throwable $e) {
 124             $msg = 'An error occurred adding new dynamic field.';
 125             Analog::log(
 126                 $msg . ' | ' .
 127                 $e->getMessage(),
 128                 Analog::ERROR
 129             );
 130             if (GALETTE_MODE == 'DEV') {
 131                 throw $e;
 132             }
 133             $error_detected[] = _T('An error occurred adding dynamic field :(');
 134         }
 135
 136         //flash messages
 137         if (count($error_detected) > 0) {
 138             foreach ($error_detected as $error) {
 139                 $this->flash->addMessage(
 140                     'error_detected',
 141                     $error
 142                 );
 143             }
 144         } else {
 145             $this->flash->addMessage(
 146                 'success_detected',
 147                 _T('Dynamic field has been successfully stored!')
 148             );
 149         }
 150
 151         if (count($warning_detected) > 0) {
 152             foreach ($warning_detected as $warning) {
 153                 $this->flash->addMessage(
 154                     'warning_detected',
 155                     $warning
 156                 );
 157             }
 158         }
 159
 160         //handle redirections
 161         if (count($error_detected) > 0) {
 162             //something went wrong :'(
 163             $this->session->dynamicfieldtype = $df;
 164             return $response
 165                 ->withStatus(301)
 166                 ->withHeader(
 167                     'Location',
 168                     $this->router->pathFor(
 169                         'addDynamicField',
 170                         $args
 171                     )
 172                 );
 173         } else {
 174             if (!$df instanceof \Galette\DynamicFields\Separator) {
 175                 return $response
 176                     ->withStatus(301)
 177                     ->withHeader(
 178                         'Location',
 179                         $this->router->pathFor(
 180                             'editDynamicField',
 181                             [
 182                                 'form_name' => $args['form_name'],
 183                                 'id'        => $df->getId()
 184                             ]
 185                         )
 186                     );
 187             }
 188
 189             return $response
 190                 ->withStatus(301)
 191                 ->withHeader(
 192                     'Location',
 193                     $this->router->pathFor(
 194                         'configureDynamicFields',
 195                         ['form_name' => $args['form_name']]
 196                     )
 197                 );
 198         }
 199     }
 200
 201     // /CRUD - Create
 202     // CRUD - Read
 203
 204     /**
 205      * List page
 206      *
 207      * @param Request  $request  PSR Request
 208      * @param Response $response PSR Response
 209      * @param array    $args     Request arguments
 210      *
 211      * @return Response
 212      */
 213     public function list(Request $request, Response $response, array $args = []): Response
 214     {
 215         $form_name = $args['form'] ?? 'adh';
 216         if (isset($_POST['form_name']) && trim($_POST['form_name']) != '') {
 217             $form_name = $_POST['form_name'];
 218         }
 219         $fields = new \Galette\Repository\DynamicFieldsSet($this->zdb, $this->login);
 220         $fields_list = $fields->getList($form_name, $this->login);
 221
 222         $field_type_names = DynamicField::getFieldsTypesNames();
 223
 224         $params = [
 225             'fields_list'       => $fields_list,
 226             'form_name'         => $form_name,
 227             'form_title'        => DynamicField::getFormTitle($form_name),
 228             'page_title'        => _T("Dynamic fields configuration")
 229         ];
 230
 231         $tpl = 'configurer_fiches.tpl';
 232         //Render directly template if we called from ajax,
 233         //render in a full page otherwise
 234         if (
 235             $request->isXhr()
 236             || isset($request->getQueryParams()['ajax'])
 237             && $request->getQueryParams()['ajax'] == 'true'
 238         ) {
 239             $tpl = 'configurer_fiche_content.tpl';
 240         } else {
 241             $all_forms = DynamicField::getFormsNames();
 242             $params['all_forms'] = $all_forms;
 243         }
 244
 245         // display page
 246         $this->view->render(
 247             $response,
 248             $tpl,
 249             $params
 250         );
 251         return $response;
 252     }
 253
 254     /**
 255      * Filtering
 256      *
 257      * @param Request  $request  PSR Request
 258      * @param Response $response PSR Response
 259      *
 260      * @return Response
 261      */
 262     public function filter(Request $request, Response $response): Response
 263     {
 264         //no filtering
 265     }
 266
 267     // /CRUD - Read
 268     // CRUD - Update
 269
 270     /**
 271      * Edit page
 272      *
 273      * @param Request  $request  PSR Request
 274      * @param Response $response PSR Response
 275      * @param array    $args     Request arguments
 276      *
 277      * @return Response
 278      */
 279     public function edit(Request $request, Response $response, array $args = []): Response
 280     {
 281         $id_dynf = (int)$args['id'];
 282         $form_name = $args['form_name'];
 283
 284         $df = null;
 285         if ($this->session->dynamicfieldtype) {
 286             $df = $this->session->dynamicfieldtype;
 287             $this->session->dynamicfieldtype = null;
 288         } else {
 289             $df = DynamicField::loadFieldType($this->zdb, $id_dynf);
 290             if ($df === false) {
 291                 $this->flash->addMessage(
 292                     'error_detected',
 293                     _T("Unable to retrieve field information.")
 294                 );
 295                 return $response
 296                     ->withStatus(301)
 297                     ->withHeader('Location', $this->router->pathFor('configureDynamicFields'));
 298             }
 299         }
 300
 301         $params = [
 302             'page_title'    => _T("Edit field"),
 303             'action'        => 'edit',
 304             'form_name'     => $form_name,
 305             'perm_names'    => DynamicField::getPermsNames(),
 306             'mode'          => ($request->isXhr() ? 'ajax' : ''),
 307             'df'            => $df
 308         ];
 309
 310         // display page
 311         $this->view->render(
 312             $response,
 313             'editer_champ.tpl',
 314             $params
 315         );
 316         return $response;
 317     }
 318
 319     /**
 320      * Edit action
 321      *
 322      * @param Request  $request  PSR Request
 323      * @param Response $response PSR Response
 324      * @param array    $args     Request arguments
 325      *
 326      * @return Response
 327      */
 328     public function doEdit(Request $request, Response $response, array $args = []): Response
 329     {
 330         $post = $request->getParsedBody();
 331         $post['form_name'] = $args['form_name'];
 332
 333         $error_detected = [];
 334         $warning_detected = [];
 335
 336         $field_id = (int)$args['id'];
 337         $df = DynamicField::loadFieldType($this->zdb, $field_id);
 338
 339         try {
 340             $df->store($post);
 341             $error_detected = $df->getErrors();
 342             $warning_detected = $df->getWarnings();
 343         } catch (Throwable $e) {
 344             $msg = 'An error occurred storing dynamic field ' . $df->getId() . '.';
 345             Analog::log(
 346                 $msg . ' | ' .
 347                 $e->getMessage(),
 348                 Analog::ERROR
 349             );
 350             if (GALETTE_MODE == 'DEV') {
 351                 throw $e;
 352             }
 353             $error_detected[] = _T('An error occurred editing dynamic field :(');
 354         }
 355
 356         //flash messages
 357         if (count($error_detected) > 0) {
 358             foreach ($error_detected as $error) {
 359                 $this->flash->addMessage(
 360                     'error_detected',
 361                     $error
 362                 );
 363             }
 364         } else {
 365             $this->flash->addMessage(
 366                 'success_detected',
 367                 _T('Dynamic field has been successfully stored!')
 368             );
 369         }
 370
 371         if (count($warning_detected) > 0) {
 372             foreach ($warning_detected as $warning) {
 373                 $this->flash->addMessage(
 374                     'warning_detected',
 375                     $warning
 376                 );
 377             }
 378         }
 379
 380         //handle redirections
 381         if (count($error_detected) > 0) {
 382             //something went wrong :'(
 383             $this->session->dynamicfieldtype = $df;
 384             return $response
 385                 ->withStatus(301)
 386                 ->withHeader(
 387                     'Location',
 388                     $this->router->pathFor(
 389                         'editDynamicField',
 390                         $args
 391                     )
 392                 );
 393         } else {
 394             return $response
 395                 ->withStatus(301)
 396                 ->withHeader(
 397                     'Location',
 398                     $this->router->pathFor(
 399                         'configureDynamicFields',
 400                         ['form_name' => $args['form_name']]
 401                     )
 402                 );
 403         }
 404     }
 405
 406     // /CRUD - Update
 407     // CRUD - Delete
 408
 409     /**
 410      * Get redirection URI
 411      *
 412      * @param array $args Route arguments
 413      *
 414      * @return string
 415      */
 416     public function redirectUri(array $args = [])
 417     {
 418         return $this->router->pathFor('configureDynamicFields');
 419     }
 420
 421     /**
 422      * Get form URI
 423      *
 424      * @param array $args Route arguments
 425      *
 426      * @return string
 427      */
 428     public function formUri(array $args = [])
 429     {
 430         return $this->router->pathFor(
 431             'doRemoveDynamicField',
 432             ['id' => $args['id'], 'form_name' => $args['form_name']]
 433         );
 434     }
 435
 436     /**
 437      * Get confirmation removal page title
 438      *
 439      * @param array $args Route arguments
 440      *
 441      * @return string
 442      */
 443     public function confirmRemoveTitle(array $args = [])
 444     {
 445         $field = DynamicField::loadFieldType($this->zdb, (int)$args['id']);
 446         if ($field === false) {
 447             $this->flash->addMessage(
 448                 'error_detected',
 449                 _T("Requested field does not exists!")
 450             );
 451             return $response
 452                 ->withStatus(301)
 453                 ->withHeader('Location', $this->router->pathFor('configureDynamicFields', ['form_name' => $args['form_name']]));
 454         }
 455
 456         return sprintf(
 457             _T('Remove dynamic field %1$s'),
 458             $field->getName()
 459         );
 460     }
 461
 462     /**
 463      * Remove object
 464      *
 465      * @param array $args Route arguments
 466      * @param array $post POST values
 467      *
 468      * @return boolean
 469      */
 470     protected function doDelete(array $args, array $post)
 471     {
 472         $field_id = (int)$post['id'];
 473         $field = DynamicField::loadFieldType($this->zdb, $field_id);
 474         return $field->remove();
 475     }
 476
 477     // /CRUD - Delete
 478     // /CRUD
 479
 480     /**
 481      * Move field
 482      *
 483      * @param Request  $request  PSR Request
 484      * @param Response $response PSR Response
 485      * @param array    $args     Request arguments
 486      *
 487      * @return Response
 488      */
 489     public function move(Request $request, Response $response, array $args = []): Response
 490     {
 491         $field_id = (int)$args['id'];
 492         $form_name = $args['form_name'];
 493
 494         $field = DynamicField::loadFieldType($this->zdb, $field_id);
 495         if ($field->move($args['direction'])) {
 496             $this->flash->addMessage(
 497                 'success_detected',
 498                 _T("Field has been successfully moved")
 499             );
 500         } else {
 501             $this->flash->addMessage(
 502                 'error_detected',
 503                 _T("An error occurred moving field :(")
 504             );
 505         }
 506
 507         return $response
 508             ->withStatus(301)
 509             ->withHeader('Location', $this->router->pathFor('configureDynamicFields', ['form_name' => $form_name]));
 510     }
 511 }