galette/lib/Galette/Controllers/GaletteController.php

   1 <?php
   2
   3 /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
   4
   5 /**
   6  * Galette main controller
   7  *
   8  * PHP version 5
   9  *
  10  * Copyright © 2019-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  Entity
  28  * @package   Galette
  29  *
  30  * @author    Johan Cwiklinski <johan@x-tnd.be>
  31  * @copyright 2019-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  * @version   SVN: $Id$
  34  * @link      http://galette.tuxfamily.org
  35  * @since     Available since 0.9.4dev - 2019-12-02
  36  */
  37
  38 namespace Galette\Controllers;
  39
  40 use Slim\Http\Request;
  41 use Slim\Http\Response;
  42 use Galette\Core\Logo;
  43 use Galette\Core\PrintLogo;
  44 use Galette\Core\GaletteMail;
  45 use Galette\Core\SysInfos;
  46 use Galette\Entity\Contribution;
  47 use Galette\Entity\FieldsCategories;
  48 use Galette\Entity\Status;
  49 use Galette\Entity\Texts;
  50 use Galette\Filters\MembersList;
  51 use Galette\IO\News;
  52 use Galette\IO\Charts;
  53 use Galette\IO\PdfMembersCards;
  54 use Galette\IO\PdfContribution;
  55 use Galette\Repository\Members;
  56 use Galette\Repository\Reminders;
  57 use Analog\Analog;
  58
  59 /**
  60  * Galette main controller
  61  *
  62  * @category  Controllers
  63  * @name      GaletteController
  64  * @package   Galette
  65  * @author    Johan Cwiklinski <johan@x-tnd.be>
  66  * @copyright 2019-2020 The Galette Team
  67  * @license   http://www.gnu.org/licenses/gpl-3.0.html GPL License 3.0 or (at your option) any later version
  68  * @link      http://galette.tuxfamily.org
  69  * @since     Available since 0.9.4dev - 2019-12-02
  70  */
  71
  72 class GaletteController extends AbstractController
  73 {
  74     /**
  75      * Main route
  76      *
  77      * @param Request  $request  PSR Request
  78      * @param Response $response PSR Response
  79      * @param array    $args     Request arguments
  80      *
  81      * @return Response
  82      */
  83     public function slash(Request $request, Response $response, array $args = []): Response
  84     {
  85         return $this->galetteRedirect($request, $response, $args);
  86     }
  87
  88     /**
  89      * System information
  90      *
  91      * @param Request  $request  PSR Request
  92      * @param Response $response PSR Response
  93      *
  94      * @return Response
  95      */
  96     public function systemInformation(Request $request, Response $response): Response
  97     {
  98         $sysinfos = new SysInfos();
  99         $raw_infos = $sysinfos->getRawData(
 100             $this->zdb,
 101             $this->preferences,
 102             $this->plugins
 103         );
 104
 105         // display page
 106         $this->view->render(
 107             $response,
 108             'sysinfos.tpl',
 109             array(
 110                 'page_title'    => _T("System information"),
 111                 'rawinfos'      => $raw_infos
 112             )
 113         );
 114         return $response;
 115     }
 116
 117     /**
 118      * Dashboard page
 119      *
 120      * @param Request  $request  PSR Request
 121      * @param Response $response PSR Response
 122      *
 123      * @return Response
 124      */
 125     public function dashboard(Request $request, Response $response): Response
 126     {
 127         $news = new News($this->preferences->pref_rss_url);
 128
 129         $params = [
 130             'page_title'        => _T("Dashboard"),
 131             'contentcls'        => 'desktop',
 132             'news'              => $news->getPosts(),
 133             'show_dashboard'    => $_COOKIE['show_galette_dashboard']
 134         ];
 135
 136         $hide_telemetry = true;
 137         if ($this->login->isAdmin()) {
 138             $telemetry = new \Galette\Util\Telemetry(
 139                 $this->zdb,
 140                 $this->preferences,
 141                 $this->plugins
 142             );
 143             $params['reguuid'] = $telemetry->getRegistrationUuid();
 144             $params['telemetry_sent'] = $telemetry->isSent();
 145             $params['registered'] = $telemetry->isRegistered();
 146
 147             $hide_telemetry = $telemetry->isSent() && $telemetry->isRegistered()
 148                 || isset($_COOKIE['hide_galette_telemetry']) && $_COOKIE['hide_galette_telemetry'];
 149         }
 150         $params['hide_telemetry'] = $hide_telemetry;
 151
 152         // display page
 153         $this->view->render(
 154             $response,
 155             'desktop.tpl',
 156             $params
 157         );
 158         return $response;
 159     }
 160
 161     /**
 162      * Preferences page
 163      *
 164      * @param Request  $request  PSR Request
 165      * @param Response $response PSR Response
 166      *
 167      * @return Response
 168      */
 169     public function preferences(Request $request, Response $response): Response
 170     {
 171         // flagging required fields
 172         $required = array(
 173             'pref_nom'              => 1,
 174             'pref_lang'             => 1,
 175             'pref_numrows'          => 1,
 176             'pref_log'              => 1,
 177             'pref_statut'           => 1,
 178             'pref_etiq_marges_v'    => 1,
 179             'pref_etiq_marges_h'    => 1,
 180             'pref_etiq_hspace'      => 1,
 181             'pref_etiq_vspace'      => 1,
 182             'pref_etiq_hsize'       => 1,
 183             'pref_etiq_vsize'       => 1,
 184             'pref_etiq_cols'        => 1,
 185             'pref_etiq_rows'        => 1,
 186             'pref_etiq_corps'       => 1,
 187             'pref_card_abrev'       => 1,
 188             'pref_card_strip'       => 1,
 189             'pref_card_marges_v'    => 1,
 190             'pref_card_marges_h'    => 1,
 191             'pref_card_hspace'      => 1,
 192             'pref_card_vspace'      => 1
 193         );
 194
 195         if ($this->login->isSuperAdmin() && GALETTE_MODE !== 'DEMO') {
 196             $required['pref_admin_login'] = 1;
 197         }
 198
 199         $prefs_fields = $this->preferences->getFieldsNames();
 200         // collect data
 201         foreach ($prefs_fields as $fieldname) {
 202             $pref[$fieldname] = $this->preferences->$fieldname;
 203         }
 204
 205         //on error, user values are stored into session
 206         if ($this->session->entered_preferences) {
 207             $pref = array_merge($pref, $this->session->entered_preferences);
 208             $this->session->entered_preferences = null;
 209         }
 210
 211         //List available themes
 212         $themes = array();
 213         $d = dir(GALETTE_THEMES_PATH);
 214         while (($entry = $d->read()) !== false) {
 215             $full_entry = GALETTE_THEMES_PATH . $entry;
 216             if (
 217                 $entry != '.'
 218                 && $entry != '..'
 219                 && is_dir($full_entry)
 220                 && file_exists($full_entry . '/page.tpl')
 221             ) {
 222                 $themes[] = $entry;
 223             }
 224         }
 225         $d->close();
 226
 227         $m = new Members();
 228         $s = new Status($this->zdb);
 229
 230         // display page
 231         $this->view->render(
 232             $response,
 233             'preferences.tpl',
 234             array(
 235                 'page_title'            => _T("Settings"),
 236                 'staff_members'         => $m->getStaffMembersList(true),
 237                 'time'                  => time(),
 238                 'pref'                  => $pref,
 239                 'pref_numrows_options'  => array(
 240                     10 => '10',
 241                     20 => '20',
 242                     50 => '50',
 243                     100 => '100'
 244                 ),
 245                 'print_logo'            => $this->print_logo,
 246                 'required'              => $required,
 247                 'themes'                => $themes,
 248                 'statuts'               => $s->getList(),
 249                 'accounts_options'      => array(
 250                     Members::ALL_ACCOUNTS       => _T("All accounts"),
 251                     Members::ACTIVE_ACCOUNT     => _T("Active accounts"),
 252                     Members::INACTIVE_ACCOUNT   => _T("Inactive accounts")
 253                 )
 254             )
 255         );
 256         return $response;
 257     }
 258
 259     /**
 260      * Store preferences
 261      *
 262      * @param Request  $request  PSR Request
 263      * @param Response $response PSR Response
 264      *
 265      * @return Response
 266      */
 267     public function storePreferences(Request $request, Response $response): Response
 268     {
 269         $post = $request->getParsedBody();
 270         $error_detected = [];
 271         $warning_detected = [];
 272
 273         // Validation
 274         if (isset($post['valid']) && $post['valid'] == '1') {
 275             if ($this->preferences->check($post, $this->login)) {
 276                 if (!$this->preferences->store()) {
 277                     $error_detected[] = _T("An SQL error has occurred while storing preferences. Please try again, and contact the administrator if the problem persists.");
 278                 } else {
 279                     $this->flash->addMessage(
 280                         'success_detected',
 281                         _T("Preferences has been saved.")
 282                     );
 283                 }
 284                 $warning_detected = array_merge($warning_detected, $this->preferences->checkCardsSizes());
 285
 286                 // picture upload
 287                 if (GALETTE_MODE !== 'DEMO' &&  isset($_FILES['logo'])) {
 288                     if ($_FILES['logo']['error'] === UPLOAD_ERR_OK) {
 289                         if ($_FILES['logo']['tmp_name'] != '') {
 290                             if (is_uploaded_file($_FILES['logo']['tmp_name'])) {
 291                                 $res = $this->logo->store($_FILES['logo']);
 292                                 if ($res < 0) {
 293                                     $error_detected[] = $this->logo->getErrorMessage($res);
 294                                 } else {
 295                                     $this->logo = new Logo();
 296                                 }
 297                             }
 298                         }
 299                     } elseif ($_FILES['logo']['error'] !== UPLOAD_ERR_NO_FILE) {
 300                         Analog::log(
 301                             $this->logo->getPhpErrorMessage($_FILES['logo']['error']),
 302                             Analog::WARNING
 303                         );
 304                         $error_detected[] = $this->logo->getPhpErrorMessage(
 305                             $_FILES['logo']['error']
 306                         );
 307                     }
 308                 }
 309
 310                 if (GALETTE_MODE !== 'DEMO' && isset($post['del_logo'])) {
 311                     if (!$this->logo->delete()) {
 312                         $error_detected[] = _T("Delete failed");
 313                     } else {
 314                         $this->logo = new Logo(); //get default Logo
 315                     }
 316                 }
 317
 318                 // Card logo upload
 319                 if (GALETTE_MODE !== 'DEMO' && isset($_FILES['card_logo'])) {
 320                     if ($_FILES['card_logo']['error'] === UPLOAD_ERR_OK) {
 321                         if ($_FILES['card_logo']['tmp_name'] != '') {
 322                             if (is_uploaded_file($_FILES['card_logo']['tmp_name'])) {
 323                                 $res = $this->print_logo->store($_FILES['card_logo']);
 324                                 if ($res < 0) {
 325                                     $error_detected[] = $this->print_logo->getErrorMessage($res);
 326                                 } else {
 327                                     $this->print_logo = new PrintLogo();
 328                                 }
 329                             }
 330                         }
 331                     } elseif ($_FILES['card_logo']['error'] !== UPLOAD_ERR_NO_FILE) {
 332                         Analog::log(
 333                             $this->print_logo->getPhpErrorMessage($_FILES['card_logo']['error']),
 334                             Analog::WARNING
 335                         );
 336                         $error_detected[] = $this->print_logo->getPhpErrorMessage(
 337                             $_FILES['card_logo']['error']
 338                         );
 339                     }
 340                 }
 341
 342                 if (GALETTE_MODE !== 'DEMO' && isset($post['del_card_logo'])) {
 343                     if (!$this->print_logo->delete()) {
 344                         $error_detected[] = _T("Delete failed");
 345                     } else {
 346                         $this->print_logo = new PrintLogo();
 347                     }
 348                 }
 349             } else {
 350                 $error_detected = $this->preferences->getErrors();
 351             }
 352
 353             if (count($error_detected) > 0) {
 354                 $this->session->entered_preferences = $post;
 355                 //report errors
 356                 foreach ($error_detected as $error) {
 357                     $this->flash->addMessage(
 358                         'error_detected',
 359                         $error
 360                     );
 361                 }
 362             }
 363
 364             if (count($warning_detected) > 0) {
 365                 //report warnings
 366                 foreach ($warning_detected as $warning) {
 367                     $this->flash->addMessage(
 368                         'warning_detected',
 369                         $warning
 370                     );
 371                 }
 372             }
 373         }
 374
 375         return $response
 376             ->withStatus(301)
 377             ->withHeader('Location', $this->router->pathFor('preferences'));
 378     }
 379
 380     /**
 381      * Test mail parameters
 382      *
 383      * @param Request  $request  PSR Request
 384      * @param Response $response PSR Response
 385      *
 386      * @return Response
 387      */
 388     public function testEmail(Request $request, Response $response): Response
 389     {
 390         $sent = false;
 391         if (!$this->preferences->pref_mail_method > GaletteMail::METHOD_DISABLED) {
 392             $this->flash->addMessage(
 393                 'error_detected',
 394                 _T("You asked Galette to send a test email, but email has been disabled in the preferences.")
 395             );
 396         } else {
 397             $get = $request->getQueryParams();
 398             $dest = (isset($get['adress']) ? $get['adress'] : $this->preferences->pref_email_newadh);
 399             if (GaletteMail::isValidEmail($dest)) {
 400                 $mail = new GaletteMail($this->preferences);
 401                 $mail->setSubject(_T('Test message'));
 402                 $mail->setRecipients(
 403                     array(
 404                         $dest => _T("Galette admin")
 405                     )
 406                 );
 407                 $mail->setMessage(_T('Test message.'));
 408                 $sent = $mail->send();
 409
 410                 if ($sent) {
 411                     $this->flash->addMessage(
 412                         'success_detected',
 413                         str_replace(
 414                             '%email',
 415                             $dest,
 416                             _T("An email has been sent to %email")
 417                         )
 418                     );
 419                 } else {
 420                     $this->flash->addMessage(
 421                         'error_detected',
 422                         str_replace(
 423                             '%email',
 424                             $dest,
 425                             _T("No email sent to %email")
 426                         )
 427                     );
 428                 }
 429             } else {
 430                 $this->flash->addMessage(
 431                     'error_detected',
 432                     _T("Invalid email adress!")
 433                 );
 434             }
 435         }
 436
 437         if (!$request->isXhr()) {
 438             return $response
 439                 ->withStatus(301)
 440                 ->withHeader('Location', $this->router->pathFor('preferences'));
 441         } else {
 442             return $response->withJson(
 443                 [
 444                     'sent'  => $sent
 445                 ]
 446             );
 447         }
 448     }
 449
 450     /**
 451      * Charts page
 452      *
 453      * @param Request  $request  PSR Request
 454      * @param Response $response PSR Response
 455      *
 456      * @return Response
 457      */
 458     public function charts(Request $request, Response $response): Response
 459     {
 460         $charts = new Charts(
 461             array(
 462                 Charts::MEMBERS_STATUS_PIE,
 463                 Charts::MEMBERS_STATEDUE_PIE,
 464                 Charts::CONTRIBS_TYPES_PIE,
 465                 Charts::COMPANIES_OR_NOT,
 466                 Charts::CONTRIBS_ALLTIME
 467             )
 468         );
 469
 470         // display page
 471         $this->view->render(
 472             $response,
 473             'charts.tpl',
 474             array(
 475                 'page_title'        => _T("Charts"),
 476                 'charts'            => $charts->getCharts(),
 477                 'require_charts'    => true
 478             )
 479         );
 480         return $response;
 481     }
 482
 483     /**
 484      * Core fields configuration page
 485      *
 486      * @param Request  $request  PSR Request
 487      * @param Response $response PSR Response
 488      *
 489      * @return Response
 490      */
 491     public function configureCoreFields(Request $request, Response $response): Response
 492     {
 493         $fc = $this->fields_config;
 494
 495         $params = [
 496             'page_title'            => _T("Fields configuration"),
 497             'time'                  => time(),
 498             'categories'            => FieldsCategories::getList($this->zdb),
 499             'categorized_fields'    => $fc->getCategorizedFields(),
 500             'non_required'          => $fc->getNonRequired()
 501         ];
 502
 503         // display page
 504         $this->view->render(
 505             $response,
 506             'config_fields.tpl',
 507             $params
 508         );
 509         return $response;
 510     }
 511
 512     /**
 513      * Process core fields configuration
 514      *
 515      * @param Request  $request  PSR Request
 516      * @param Response $response PSR Response
 517      *
 518      * @return Response
 519      */
 520     public function storeCoreFieldsConfig(Request $request, Response $response): Response
 521     {
 522         $post = $request->getParsedBody();
 523         $fc = $this->fields_config;
 524
 525         $pos = 0;
 526         $current_cat = 0;
 527         $res = array();
 528         foreach ($post['fields'] as $abs_pos => $field) {
 529             if ($current_cat != $post[$field . '_category']) {
 530                 //reset position when category has changed
 531                 $pos = 0;
 532                 //set new current category
 533                 $current_cat = $post[$field . '_category'];
 534             }
 535
 536             $required = null;
 537             if (isset($post[$field . '_required'])) {
 538                 $required = $post[$field . '_required'];
 539             } else {
 540                 $required = false;
 541             }
 542
 543             $res[$current_cat][] = array(
 544                 'field_id'  =>  $field,
 545                 'label'     =>  $post[$field . '_label'],
 546                 'category'  =>  $post[$field . '_category'],
 547                 'visible'   =>  $post[$field . '_visible'],
 548                 'required'  =>  $required
 549             );
 550             $pos++;
 551         }
 552         //okay, we've got the new array, we send it to the
 553         //Object that will store it in the database
 554         $success = $fc->setFields($res);
 555         FieldsCategories::setCategories($this->zdb, $post['categories']);
 556         if ($success === true) {
 557             $this->flash->addMessage(
 558                 'success_detected',
 559                 _T("Fields configuration has been successfully stored")
 560             );
 561         } else {
 562             $this->flash->addMessage(
 563                 'error_detected',
 564                 _T("An error occurred while storing fields configuration :(")
 565             );
 566         }
 567
 568         return $response
 569             ->withStatus(301)
 570             ->withHeader('Location', $this->router->pathFor('configureCoreFields'));
 571     }
 572
 573     /**
 574      * Core lists configuration page
 575      *
 576      * @param Request  $request  PSR Request
 577      * @param Response $response PSR Response
 578      * @param array    $args     Request arguments
 579      *
 580      * @return Response
 581      */
 582     public function configureListFields(Request $request, Response $response, array $args = []): Response
 583     {
 584         $table = $args['table'];
 585         //TODO: check if type table exists
 586
 587         $lc = $this->lists_config;
 588
 589         $params = [
 590             'page_title'    => _T("Lists configuration"),
 591             'table'         => $table,
 592             'time'          => time(),
 593             'listed_fields' => $lc->getListedFields(),
 594             'remaining_fields'  => $lc->getRemainingFields()
 595         ];
 596
 597         // display page
 598         $this->view->render(
 599             $response,
 600             'config_lists.tpl',
 601             $params
 602         );
 603         return $response;
 604     }
 605
 606     /**
 607      * Process list fields configuration
 608      *
 609      * @param Request  $request  PSR Request
 610      * @param Response $response PSR Response
 611      * @param array    $args     Request arguments
 612      *
 613      * @return Response
 614      */
 615     public function storeListFields(Request $request, Response $response, array $args = []): Response
 616     {
 617         $post = $request->getParsedBody();
 618
 619         $lc = $this->lists_config;
 620         $fields = [];
 621         foreach ($post['fields'] as $field) {
 622             $fields[] = $lc->getField($field);
 623         }
 624         $success = $lc->setListFields($fields);
 625
 626         if ($success === true) {
 627             $this->flash->addMessage(
 628                 'success_detected',
 629                 _T("List configuration has been successfully stored")
 630             );
 631         } else {
 632             $this->flash->addMessage(
 633                 'error_detected',
 634                 _T("An error occurred while storing list configuration :(")
 635             );
 636         }
 637
 638         return $response
 639             ->withStatus(301)
 640             ->withHeader('Location', $this->router->pathFor('configureListFields', $args));
 641     }
 642
 643     /**
 644      * Fake data page
 645      *
 646      * @param Request  $request  PSR Request
 647      * @param Response $response PSR Response
 648      *
 649      * @return Response
 650      */
 651     public function fakeData(Request $request, Response $response): Response
 652     {
 653         $params = [
 654             'page_title'            => _T('Generate fake data'),
 655             'number_members'        => \Galette\Util\FakeData::DEFAULT_NB_MEMBERS,
 656             'number_contrib'        => \Galette\Util\FakeData::DEFAULT_NB_CONTRIB,
 657             'number_groups'         => \Galette\Util\FakeData::DEFAULT_NB_GROUPS,
 658             'number_transactions'   => \Galette\Util\FakeData::DEFAULT_NB_TRANSACTIONS,
 659             'photos'                => \Galette\Util\FakeData::DEFAULT_PHOTOS
 660         ];
 661
 662         // display page
 663         $this->view->render(
 664             $response,
 665             'fake_data.tpl',
 666             $params
 667         );
 668         return $response;
 669     }
 670
 671     /**
 672      * Generate fake data
 673      *
 674      * @param Request  $request  PSR Request
 675      * @param Response $response PSR Response
 676      *
 677      * @return Response
 678      */
 679     public function doFakeData(Request $request, Response $response): Response
 680     {
 681         $post = $request->getParsedBody();
 682
 683         $fakedata = new \Galette\Util\FakeData($this->zdb, $this->i18n);
 684
 685         $fakedata->setDependencies(
 686             $this->preferences,
 687             $this->members_fields,
 688             $this->history,
 689             $this->login
 690         );
 691
 692         $fakedata
 693             ->setNbMembers($post['number_members'])
 694             ->setNbGroups($post['number_groups'])
 695             ->setNbTransactions($post['number_transactions'])
 696             ->setMaxContribs($post['number_contrib'])
 697             ->setWithPhotos(isset($post['photos']));
 698
 699         $fakedata->generate();
 700
 701         $report = $fakedata->getReport();
 702
 703         foreach ($report['success'] as $success) {
 704             $this->flash->addMessage(
 705                 'success_detected',
 706                 $success
 707             );
 708         }
 709
 710         foreach ($report['errors'] as $error) {
 711             $this->flash->addMessage(
 712                 'error_detected',
 713                 $error
 714             );
 715         }
 716
 717         foreach ($report['warnings'] as $warning) {
 718             $this->flash->addMessage(
 719                 'warning_detected',
 720                 $warning
 721             );
 722         }
 723
 724         return $response
 725             ->withStatus(301)
 726             ->withHeader('Location', $this->router->pathFor('slash'));
 727     }
 728
 729     /**
 730      * Reminders page
 731      *
 732      * @param Request  $request  PSR Request
 733      * @param Response $response PSR Response
 734      *
 735      * @return Response
 736      */
 737     public function reminders(Request $request, Response $response): Response
 738     {
 739         $texts = new Texts($this->preferences, $this->router);
 740
 741         $previews = array(
 742             'impending' => $texts->getTexts('impendingduedate', $this->preferences->pref_lang),
 743             'late'      => $texts->getTexts('lateduedate', $this->preferences->pref_lang)
 744         );
 745
 746         $members = new Members();
 747         $reminders = $members->getRemindersCount();
 748
 749         // display page
 750         $this->view->render(
 751             $response,
 752             'reminder.tpl',
 753             [
 754                 'page_title'                => _T("Reminders"),
 755                 'previews'                  => $previews,
 756                 'count_impending'           => $reminders['impending'],
 757                 'count_impending_nomail'    => $reminders['nomail']['impending'],
 758                 'count_late'                => $reminders['late'],
 759                 'count_late_nomail'         => $reminders['nomail']['late']
 760             ]
 761         );
 762         return $response;
 763     }
 764
 765     /**
 766      * Main route
 767      *
 768      * @param Request  $request  PSR Request
 769      * @param Response $response PSR Response
 770      *
 771      * @return Response
 772      */
 773     public function doReminders(Request $request, Response $response): Response
 774     {
 775         $error_detected = [];
 776         $warning_detected = [];
 777         $success_detected = [];
 778
 779         $post = $request->getParsedBody();
 780         $texts = new Texts($this->preferences, $this->router);
 781         $selected = null;
 782         if (isset($post['reminders'])) {
 783             $selected = $post['reminders'];
 784         }
 785         $reminders = new Reminders($selected);
 786
 787         $labels = false;
 788         $labels_members = array();
 789         if (isset($post['reminder_wo_mail'])) {
 790             $labels = true;
 791         }
 792
 793         $list_reminders = $reminders->getList($this->zdb, $labels);
 794         if (count($list_reminders) == 0) {
 795             $warning_detected[] = _T("No reminder to send for now.");
 796         } else {
 797             foreach ($list_reminders as $reminder) {
 798                 if ($labels === false) {
 799                     //send reminders by email
 800                     $sent = $reminder->send($texts, $this->history, $this->zdb);
 801
 802                     if ($sent === true) {
 803                         $success_detected[] = $reminder->getMessage();
 804                     } else {
 805                         $error_detected[] = $reminder->getMessage();
 806                     }
 807                 } else {
 808                     //generate labels for members without email address
 809                     $labels_members[] = $reminder->member_id;
 810                 }
 811             }
 812
 813             if ($labels === true) {
 814                 if (count($labels_members) > 0) {
 815                     $session_var = 'filters_reminders_labels';
 816                     $labels_filters = new MembersList();
 817                     $labels_filters->selected = $labels_members;
 818                     $this->session->$session_var = $labels_filters;
 819                     return $response
 820                         ->withStatus(307)
 821                         ->withHeader(
 822                             'Location',
 823                             $this->router->pathFor('pdf-member-labels') . '?session_var=' . $session_var
 824                         );
 825                 } else {
 826                     $error_detected[] = _T("There are no member to proceed.");
 827                 }
 828             }
 829
 830             if (count($error_detected) > 0) {
 831                 array_unshift(
 832                     $error_detected,
 833                     _T("Reminder has not been sent:")
 834                 );
 835             }
 836
 837             if (count($success_detected) > 0) {
 838                 array_unshift(
 839                     $success_detected,
 840                     _T("Sent reminders:")
 841                 );
 842             }
 843         }
 844
 845         //flash messages if any
 846         if (count($error_detected) > 0) {
 847             foreach ($error_detected as $error) {
 848                 $this->flash->addMessage('error_detected', $error);
 849             }
 850         }
 851         if (count($warning_detected) > 0) {
 852             foreach ($warning_detected as $warning) {
 853                 $this->flash->addMessage('warning_detected', $warning);
 854             }
 855         }
 856         if (count($success_detected) > 0) {
 857             foreach ($success_detected as $success) {
 858                 $this->flash->addMessage('success_detected', $success);
 859             }
 860         }
 861
 862         return $response
 863             ->withStatus(301)
 864             ->withHeader('Location', $this->router->pathFor('reminders'));
 865     }
 866
 867     /**
 868      * Main route
 869      *
 870      * @param Request  $request  PSR Request
 871      * @param Response $response PSR Response
 872      * @param array    $args     Request arguments
 873      *
 874      * @return Response
 875      */
 876     public function filterReminders(Request $request, Response $response, array $args = []): Response
 877     {
 878         //always reset filters
 879         $filters = new MembersList();
 880         $filters->filter_account = Members::ACTIVE_ACCOUNT;
 881
 882         $membership = ($args['membership'] === 'nearly' ?
 883             Members::MEMBERSHIP_NEARLY :
 884             Members::MEMBERSHIP_LATE);
 885         $filters->membership_filter = $membership;
 886
 887         //TODO: filter on reminder may take care of parent email as well
 888         $mail = ($args['mail'] === 'withmail' ?
 889             Members::FILTER_W_EMAIL :
 890             Members::FILTER_WO_EMAIL);
 891         $filters->email_filter = $mail;
 892
 893         $this->session->filter_members = $filters;
 894
 895         return $response
 896             ->withStatus(301)
 897             ->withHeader('Location', $this->router->pathFor('members'));
 898     }
 899
 900     /**
 901      * Direct document page
 902      *
 903      * @param Request  $request  PSR Request
 904      * @param Response $response PSR Response
 905      * @param array    $args     Request arguments
 906      *
 907      * @return Response
 908      */
 909     public function documentLink(Request $request, Response $response, array $args = []): Response
 910     {
 911         // display page
 912         $this->view->render(
 913             $response,
 914             'directlink.tpl',
 915             array(
 916                 'hash'          => $args['hash'],
 917                 'page_title'    => _T('Download document')
 918             )
 919         );
 920         return $response;
 921     }
 922 }