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

   1 <?php
   2
   3 /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
   4
   5 /**
   6  * Galette members 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  Controllers
  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\Crud;
  39
  40 use Galette\Controllers\CrudController;
  41 use Slim\Http\Request;
  42 use Slim\Http\Response;
  43 use Galette\Core\Authentication;
  44 use Galette\Core\GaletteMail;
  45 use Galette\Core\Password;
  46 use Galette\Core\PasswordImage;
  47 use Galette\Core\Picture;
  48 use Galette\Entity\Adherent;
  49 use Galette\Entity\Contribution;
  50 use Galette\Entity\ContributionsTypes;
  51 use Galette\Entity\DynamicFieldsHandle;
  52 use Galette\Entity\Group;
  53 use Galette\Entity\Status;
  54 use Galette\Entity\FieldsConfig;
  55 use Galette\Entity\Texts;
  56 use Galette\Filters\AdvancedMembersList;
  57 use Galette\Filters\MembersList;
  58 use Galette\IO\File;
  59 use Galette\IO\MembersCsv;
  60 use Galette\Repository\Groups;
  61 use Galette\Repository\Members;
  62 use Galette\Repository\PaymentTypes;
  63 use Galette\Repository\Titles;
  64 use Analog\Analog;
  65
  66 /**
  67  * Galette members controller
  68  *
  69  * @category  Controllers
  70  * @name      GaletteController
  71  * @package   Galette
  72  * @author    Johan Cwiklinski <johan@x-tnd.be>
  73  * @copyright 2019-2020 The Galette Team
  74  * @license   http://www.gnu.org/licenses/gpl-3.0.html GPL License 3.0 or (at your option) any later version
  75  * @link      http://galette.tuxfamily.org
  76  * @since     Available since 0.9.4dev - 2019-12-02
  77  */
  78
  79 class MembersController extends CrudController
  80 {
  81     // CRUD - Create
  82
  83     /**
  84      * Add page
  85      *
  86      * @param Request  $request  PSR Request
  87      * @param Response $response PSR Response
  88      * @param array    $args     Request arguments
  89      *
  90      * @return Response
  91      */
  92     public function add(Request $request, Response $response, array $args = []): Response
  93     {
  94         return $this->edit($request, $response, $args);
  95     }
  96
  97     /**
  98      * Self subscription page
  99      *
 100      * @param Request  $request  PSR Request
 101      * @param Response $response PSR Response
 102      * @param array    $args     Request arguments
 103      *
 104      * @return Response
 105      */
 106     public function selfSubscribe(Request $request, Response $response, array $args = []): Response
 107     {
 108         if (!$this->preferences->pref_bool_selfsubscribe || $this->login->isLogged()) {
 109             return $response
 110                 ->withStatus(301)
 111                 ->withHeader('Location', $this->router->pathFor('slash'));
 112         }
 113
 114         if ($this->session->member !== null) {
 115             $member = $this->session->member;
 116             $this->session->member = null;
 117         } else {
 118             $deps = [
 119                 'dynamics'  => true
 120             ];
 121             $member = new Adherent($this->zdb, null, $deps);
 122         }
 123
 124         //mark as self membership
 125         $member->setSelfMembership();
 126
 127         // flagging required fields
 128         $fc = $this->fields_config;
 129         $form_elements = $fc->getFormElements($this->login, true, true);
 130
 131         //image to defeat mass filling forms
 132         $spam = new PasswordImage();
 133         $spam_pass = $spam->newImage();
 134         $spam_img = $spam->getImage();
 135
 136         // members
 137         $m = new Members();
 138         $members = $m->getSelectizedMembers(
 139             $this->zdb,
 140             $member->hasParent() ? $member->parent->id : null
 141         );
 142
 143         $params = [
 144             'members' => [
 145                 'filters'   => $m->getFilters(),
 146                 'count'     => $m->getCount()
 147             ]
 148         ];
 149
 150         if (count($members)) {
 151             $params['members']['list'] = $members;
 152         }
 153
 154         // display page
 155         $this->view->render(
 156             $response,
 157             'member.tpl',
 158             array(
 159                 'page_title'        => _T("Subscription"),
 160                 'parent_tpl'        => 'public_page.tpl',
 161                 'member'            => $member,
 162                 'self_adh'          => true,
 163                 'autocomplete'      => true,
 164                 // pseudo random int
 165                 'time'              => time(),
 166                 'titles_list'       => Titles::getList($this->zdb),
 167                 //self_adh specific
 168                 'spam_pass'         => $spam_pass,
 169                 'spam_img'          => $spam_img,
 170                 'fieldsets'         => $form_elements['fieldsets'],
 171                 'hidden_elements'   => $form_elements['hiddens']
 172             ) + $params
 173         );
 174         return $response;
 175     }
 176
 177     /**
 178      * Add action
 179      *
 180      * @param Request  $request  PSR Request
 181      * @param Response $response PSR Response
 182      * @param array    $args     Request arguments
 183      *
 184      * @return Response
 185      */
 186     public function doAdd(Request $request, Response $response, array $args = []): Response
 187     {
 188         return $this->store($request, $response, $args);
 189     }
 190
 191     /**
 192      * Duplicate action
 193      *
 194      * @param Request  $request  PSR Request
 195      * @param Response $response PSR Response
 196      * @param array    $args     Request arguments
 197      *
 198      * @return Response
 199      */
 200     public function duplicate(Request $request, Response $response, array $args = []): Response
 201     {
 202         $id_adh = (int)$args[Adherent::PK];
 203         $adh = new Adherent($this->zdb, $id_adh, ['dynamics' => true, 'parent' => true]);
 204         $adh->setDuplicate();
 205
 206         //store entity in session
 207         $this->session->member = $adh;
 208
 209         return $response
 210             ->withStatus(301)
 211             ->withHeader('Location', $this->router->pathFor('editmember', ['action' => 'add']));
 212     }
 213
 214     // /CRUD - Create
 215     // CRUD - Read
 216
 217     /**
 218      * Display member card
 219      *
 220      * @param Request  $request  PSR Request
 221      * @param Response $response PSR Response
 222      * @param array    $args     Request arguments
 223      *
 224      * @return Response
 225      */
 226     public function show(Request $request, Response $response, array $args): Response
 227     {
 228         $id = (int)$args['id'];
 229
 230         $deps = array(
 231             'picture'   => true,
 232             'groups'    => true,
 233             'dues'      => true,
 234             'parent'    => true,
 235             'children'  => true,
 236             'dynamics'  => true
 237         );
 238         $member = new Adherent($this->zdb, $id, $deps);
 239
 240         if (!$member->canEdit($this->login)) {
 241             $this->flash->addMessage(
 242                 'error_detected',
 243                 _T("You do not have permission for requested URL.")
 244             );
 245
 246             return $response
 247                 ->withStatus(301)
 248                 ->withHeader(
 249                     'Location',
 250                     $this->router->pathFor('me')
 251                 );
 252         }
 253
 254         if ($member->id == null) {
 255             //member does not exists!
 256             $this->flash->addMessage(
 257                 'error_detected',
 258                 str_replace('%id', $args['id'], _T("No member #%id."))
 259             );
 260
 261             return $response
 262                 ->withStatus(404)
 263                 ->withHeader(
 264                     'Location',
 265                     $this->router->pathFor('slash')
 266                 );
 267         }
 268
 269         // flagging fields visibility
 270         $fc = $this->fields_config;
 271         $display_elements = $fc->getDisplayElements($this->login);
 272
 273         // display page
 274         $this->view->render(
 275             $response,
 276             'voir_adherent.tpl',
 277             array(
 278                 'page_title'        => _T("Member Profile"),
 279                 'member'            => $member,
 280                 'pref_lang'         => $this->i18n->getNameFromId($member->language),
 281                 'pref_card_self'    => $this->preferences->pref_card_self,
 282                 'groups'            => Groups::getSimpleList(),
 283                 'time'              => time(),
 284                 'display_elements'  => $display_elements
 285             )
 286         );
 287         return $response;
 288     }
 289
 290     /**
 291      * Own card show
 292      *
 293      * @param Request  $request  PSR Request
 294      * @param Response $response PSR Response
 295      * @param array    $args     Request arguments
 296      *
 297      * @return Response
 298      */
 299     public function showMe(Request $request, Response $response, array $args = []): Response
 300     {
 301         if ($this->login->isSuperAdmin()) {
 302             return $response
 303                 ->withStatus(301)
 304                 ->withHeader('Location', $this->router->pathFor('slash'));
 305         }
 306         $args['show_me'] = true;
 307         $args['id'] = $this->login->id;
 308         return $this->show($request, $response, $args);
 309     }
 310
 311     /**
 312      * Public pages (trombinoscope, public list)
 313      *
 314      * @param Request  $request  PSR Request
 315      * @param Response $response PSR Response
 316      * @param array    $args     Request arguments
 317      *
 318      * @return Response
 319      */
 320     public function publicList(Request $request, Response $response, array $args = []): Response
 321     {
 322         $option = null;
 323         $type = $args['type'];
 324         if (isset($args['option'])) {
 325             $option = $args['option'];
 326         }
 327         $value = null;
 328         if (isset($args['value'])) {
 329             $value = $args['value'];
 330         }
 331
 332         $varname = 'public_filter_' . $type;
 333         if (isset($this->session->$varname)) {
 334             $filters = $this->session->$varname;
 335         } else {
 336             $filters = new MembersList();
 337         }
 338
 339         if ($option !== null) {
 340             switch ($option) {
 341                 case 'page':
 342                     $filters->current_page = (int)$value;
 343                     break;
 344                 case 'order':
 345                     $filters->orderby = $value;
 346                     break;
 347             }
 348         }
 349
 350         $m = new Members($filters);
 351         $members = $m->getPublicList($type === 'trombi');
 352
 353         $this->session->$varname = $filters;
 354
 355         //assign pagination variables to the template and add pagination links
 356         $filters->setSmartyPagination($this->router, $this->view->getSmarty(), false);
 357
 358         // display page
 359         $this->view->render(
 360             $response,
 361             ($type === 'list' ? 'liste_membres' : 'trombinoscope') . '.tpl',
 362             array(
 363                 'page_title'    => ($type === 'list' ? _T("Members list") : _T('Trombinoscope')),
 364                 'additionnal_html_class'    => ($type === 'list' ? '' : 'trombinoscope'),
 365                 'type'          => $type,
 366                 'members'       => $members,
 367                 'nb_members'    => $m->getCount(),
 368                 'filters'       => $filters
 369             )
 370         );
 371         return $response;
 372     }
 373
 374     /**
 375      * Public pages (trombinoscope, public list)
 376      *
 377      * @param Request  $request  PSR Request
 378      * @param Response $response PSR Response
 379      * @param array    $args     Request arguments
 380      *
 381      * @return Response
 382      */
 383     public function filterPublicList(Request $request, Response $response, array $args = []): Response
 384     {
 385         $type = $args['type'];
 386         $post = $request->getParsedBody();
 387
 388         $varname = 'public_filter_' . $type;
 389         if (isset($this->session->$varname)) {
 390             $filters = $this->session->$varname;
 391         } else {
 392             $filters = new MembersList();
 393         }
 394
 395         //reintialize filters
 396         if (isset($post['clear_filter'])) {
 397             $filters->reinit();
 398         } else {
 399             //number of rows to show
 400             if (isset($post['nbshow'])) {
 401                 $filters->show = $post['nbshow'];
 402             }
 403         }
 404
 405         $this->session->$varname = $filters;
 406
 407         return $response
 408             ->withStatus(301)
 409             ->withHeader('Location', $this->router->pathFor('publicList', ['type' => $type]));
 410     }
 411
 412     /**
 413      * Get a dynamic file
 414      *
 415      * @param Request  $request  PSR Request
 416      * @param Response $response PSR Response
 417      * @param array    $args     Request arguments
 418      *
 419      * @return Response
 420      */
 421     public function getDynamicFile(Request $request, Response $response, array $args): Response
 422     {
 423         $id = (int)$args['id'];
 424         $deps = array(
 425             'picture'   => false,
 426             'groups'    => false,
 427             'dues'      => false,
 428             'parent'    => false,
 429             'children'  => false,
 430             'dynamics'  => true
 431         );
 432         $member = new Adherent($this->zdb, $id, $deps);
 433
 434         $denied = null;
 435         if (!$member->canEdit($this->login)) {
 436             $fields = $member->getDynamicFields()->getFields();
 437             if (!isset($fields[$args['fid']])) {
 438                 //field does not exists or access is forbidden
 439                 $denied = true;
 440             } else {
 441                 $denied = false;
 442             }
 443         }
 444
 445         if ($denied === true) {
 446             $this->flash->addMessage(
 447                 'error_detected',
 448                 _T("You do not have permission for requested URL.")
 449             );
 450
 451             return $response
 452                 ->withStatus(403)
 453                 ->withHeader(
 454                     'Location',
 455                     $this->router->pathFor(
 456                         'member',
 457                         ['id' => $id]
 458                     )
 459                 );
 460         }
 461
 462         $filename = str_replace(
 463             [
 464                 '%mid',
 465                 '%fid',
 466                 '%pos'
 467             ],
 468             [
 469                 $args['id'],
 470                 $args['fid'],
 471                 $args['pos']
 472             ],
 473             'member_%mid_field_%fid_value_%pos'
 474         );
 475
 476         if (file_exists(GALETTE_FILES_PATH . $filename)) {
 477             $type = File::getMimeType(GALETTE_FILES_PATH . $filename);
 478             $response = $response
 479                 ->withHeader('Content-Type', $type)
 480                 ->withHeader('Content-Disposition', 'attachment;filename="' . $args['name'] . '"')
 481                 ->withHeader('Pragma', 'no-cache');
 482             $response->write(readfile(GALETTE_FILES_PATH . $filename));
 483             return $response;
 484         } else {
 485             Analog::log(
 486                 'A request has been made to get an exported file named `' .
 487                 $filename . '` that does not exists.',
 488                 Analog::WARNING
 489             );
 490
 491             $this->flash->addMessage(
 492                 'error_detected',
 493                 _T("The file does not exists or cannot be read :(")
 494             );
 495
 496             return $response
 497                 ->withStatus(404)
 498                 ->withHeader(
 499                     'Location',
 500                     $this->router->pathFor('member', ['id' => $args['id']])
 501                 );
 502         }
 503     }
 504
 505     /**
 506      * Members list
 507      *
 508      * @param Request  $request  PSR Request
 509      * @param Response $response PSR Response
 510      * @param array    $args     Request arguments
 511      *
 512      * @return Response
 513      */
 514     public function list(Request $request, Response $response, array $args = []): Response
 515     {
 516         $option = $args['option'] ?? null;
 517         $value = $args['value'] ?? null;
 518
 519         if (isset($this->session->filter_members)) {
 520             $filters = $this->session->filter_members;
 521         } else {
 522             $filters = new MembersList();
 523         }
 524
 525         if ($option !== null) {
 526             switch ($option) {
 527                 case 'page':
 528                     $filters->current_page = (int)$value;
 529                     break;
 530                 case 'order':
 531                     $filters->orderby = $value;
 532                     break;
 533             }
 534         }
 535
 536         $members = new Members($filters);
 537
 538         $members_list = array();
 539         if ($this->login->isAdmin() || $this->login->isStaff()) {
 540             $members_list = $members->getMembersList(true);
 541         } else {
 542             $members_list = $members->getManagedMembersList(true);
 543         }
 544
 545         $groups = new Groups($this->zdb, $this->login);
 546         $groups_list = $groups->getList();
 547
 548         //assign pagination variables to the template and add pagination links
 549         $filters->setSmartyPagination($this->router, $this->view->getSmarty(), false);
 550         $filters->setViewCommonsFilters($this->preferences, $this->view->getSmarty());
 551
 552         $this->session->filter_members = $filters;
 553
 554         // display page
 555         $this->view->render(
 556             $response,
 557             'gestion_adherents.tpl',
 558             array(
 559                 'page_title'            => _T("Members management"),
 560                 'require_mass'          => true,
 561                 'members'               => $members_list,
 562                 'filter_groups_options' => $groups_list,
 563                 'nb_members'            => $members->getCount(),
 564                 'filters'               => $filters,
 565                 'adv_filters'           => $filters instanceof AdvancedMembersList,
 566                 'galette_list'          => $this->lists_config->getDisplayElements($this->login)
 567             )
 568         );
 569         return $response;
 570     }
 571
 572     /**
 573      * Members filtering
 574      *
 575      * @param Request  $request  PSR Request
 576      * @param Response $response PSR Response
 577      *
 578      * @return Response
 579      */
 580     public function filter(Request $request, Response $response): Response
 581     {
 582         $post = $request->getParsedBody();
 583         if (isset($this->session->filter_members)) {
 584             //CAUTION: this one may be simple or advanced, display must change
 585             $filters = $this->session->filter_members;
 586         } else {
 587             $filters = new MembersList();
 588         }
 589
 590         //reintialize filters
 591         if (isset($post['clear_filter'])) {
 592             $filters = new MembersList();
 593         } elseif (isset($post['clear_adv_filter'])) {
 594             $this->session->filter_members = null;
 595             unset($this->session->filter_members);
 596
 597             return $response
 598                 ->withStatus(301)
 599                 ->withHeader('Location', $this->router->pathFor('advanced-search'));
 600         } elseif (isset($post['adv_criteria'])) {
 601             return $response
 602                 ->withStatus(301)
 603                 ->withHeader('Location', $this->router->pathFor('advanced-search'));
 604         } else {
 605             //string to filter
 606             if (isset($post['filter_str'])) { //filter search string
 607                 $filters->filter_str = stripslashes(
 608                     htmlspecialchars($post['filter_str'], ENT_QUOTES)
 609                 );
 610             }
 611             //field to filter
 612             if (isset($post['field_filter'])) {
 613                 if (is_numeric($post['field_filter'])) {
 614                     $filters->field_filter = $post['field_filter'];
 615                 }
 616             }
 617             //membership to filter
 618             if (isset($post['membership_filter'])) {
 619                 if (is_numeric($post['membership_filter'])) {
 620                     $filters->membership_filter
 621                         = $post['membership_filter'];
 622                 }
 623             }
 624             //account status to filter
 625             if (isset($post['filter_account'])) {
 626                 if (is_numeric($post['filter_account'])) {
 627                     $filters->filter_account = $post['filter_account'];
 628                 }
 629             }
 630             //email filter
 631             if (isset($post['email_filter'])) {
 632                 $filters->email_filter = (int)$post['email_filter'];
 633             }
 634             //group filter
 635             if (
 636                 isset($post['group_filter'])
 637                 && $post['group_filter'] > 0
 638             ) {
 639                 $filters->group_filter = (int)$post['group_filter'];
 640             }
 641             //number of rows to show
 642             if (isset($post['nbshow'])) {
 643                 $filters->show = $post['nbshow'];
 644             }
 645
 646             if (isset($post['advanced_filtering'])) {
 647                 if (!$filters instanceof AdvancedMembersList) {
 648                     $filters = new AdvancedMembersList($filters);
 649                 }
 650                 //Advanced filters
 651                 $filters->reinit();
 652                 unset($post['advanced_filtering']);
 653                 $freed = false;
 654                 foreach ($post as $k => $v) {
 655                     if (strpos($k, 'free_', 0) === 0) {
 656                         if (!$freed) {
 657                             $i = 0;
 658                             foreach ($post['free_field'] as $f) {
 659                                 if (
 660                                     trim($f) !== ''
 661                                     && trim($post['free_text'][$i]) !== ''
 662                                 ) {
 663                                     $fs_search = $post['free_text'][$i];
 664                                     $log_op
 665                                         = (int)$post['free_logical_operator'][$i];
 666                                     $qry_op
 667                                         = (int)$post['free_query_operator'][$i];
 668                                     $type = (int)$post['free_type'][$i];
 669                                     $fs = array(
 670                                         'idx'       => $i,
 671                                         'field'     => $f,
 672                                         'type'      => $type,
 673                                         'search'    => $fs_search,
 674                                         'log_op'    => $log_op,
 675                                         'qry_op'    => $qry_op
 676                                     );
 677                                     $filters->free_search = $fs;
 678                                 }
 679                                 $i++;
 680                             }
 681                             $freed = true;
 682                         }
 683                     } elseif ($k == 'groups_search') {
 684                         $i = 0;
 685                         $filters->groups_search_log_op = (int)$post['groups_logical_operator'];
 686                         foreach ($post['groups_search'] as $g) {
 687                             if (trim($g) !== '') {
 688                                 $gs = array(
 689                                     'idx'       => $i,
 690                                     'group'     => $g
 691                                 );
 692                                 $filters->groups_search = $gs;
 693                             }
 694                             $i++;
 695                         }
 696                     } else {
 697                         switch ($k) {
 698                             case 'contrib_min_amount':
 699                             case 'contrib_max_amount':
 700                                 if (trim($v) !== '') {
 701                                     $v = (float)$v;
 702                                 } else {
 703                                     $v = null;
 704                                 }
 705                                 break;
 706                         }
 707                         $filters->$k = $v;
 708                     }
 709                 }
 710             }
 711         }
 712
 713         if (isset($post['savesearch'])) {
 714             return $response
 715                 ->withStatus(301)
 716                 ->withHeader(
 717                     'Location',
 718                     $this->router->pathFor(
 719                         'saveSearch',
 720                         $post
 721                     )
 722                 );
 723         }
 724
 725         $this->session->filter_members = $filters;
 726
 727         return $response
 728             ->withStatus(301)
 729             ->withHeader('Location', $this->router->pathFor('members'));
 730     }
 731
 732     /**
 733      * Advanced search page
 734      *
 735      * @param Request  $request  PSR Request
 736      * @param Response $response PSR Response
 737      *
 738      * @return Response
 739      */
 740     public function advancedSearch(Request $request, Response $response): Response
 741     {
 742         if (isset($this->session->filter_members)) {
 743             $filters = $this->session->filter_members;
 744             if (!$filters instanceof AdvancedMembersList) {
 745                 $filters = new AdvancedMembersList($filters);
 746             }
 747         } else {
 748             $filters = new AdvancedMembersList();
 749         }
 750
 751         $groups = new Groups($this->zdb, $this->login);
 752         $groups_list = $groups->getList();
 753
 754         //we want only visibles fields
 755         $fields = $this->members_fields;
 756         $fc = $this->fields_config;
 757         $visibles = $fc->getVisibilities();
 758         $access_level = $this->login->getAccessLevel();
 759
 760         //remove not searchable fields
 761         unset($fields['mdp_adh']);
 762
 763         foreach ($fields as $k => $f) {
 764             if (
 765                 $visibles[$k] == FieldsConfig::NOBODY ||
 766                 ($visibles[$k] == FieldsConfig::ADMIN &&
 767                     $access_level < Authentication::ACCESS_ADMIN) ||
 768                 ($visibles[$k] == FieldsConfig::STAFF &&
 769                     $access_level < Authentication::ACCESS_STAFF) ||
 770                 ($visibles[$k] == FieldsConfig::MANAGER &&
 771                     $access_level < Authentication::ACCESS_MANAGER)
 772             ) {
 773                 unset($fields[$k]);
 774             }
 775         }
 776
 777         //add status label search
 778         if ($pos = array_search(Status::PK, array_keys($fields))) {
 779             $fields = array_slice($fields, 0, $pos, true) +
 780                 ['status_label'  => ['label' => _T('Status label')]] +
 781                 array_slice($fields, $pos, count($fields) - 1, true);
 782         }
 783
 784         //dynamic fields
 785         $deps = array(
 786             'picture'   => false,
 787             'groups'    => false,
 788             'dues'      => false,
 789             'parent'    => false,
 790             'children'  => false,
 791             'dynamics'  => false
 792         );
 793         $member = new Adherent($this->zdb, $this->login->login, $deps);
 794         $adh_dynamics = new DynamicFieldsHandle($this->zdb, $this->login, $member);
 795
 796         $contrib = new Contribution($this->zdb, $this->login);
 797         $contrib_dynamics = new DynamicFieldsHandle($this->zdb, $this->login, $contrib);
 798
 799         //Status
 800         $statuts = new Status($this->zdb);
 801
 802         //Contributions types
 803         $ct = new ContributionsTypes($this->zdb);
 804
 805         //Payments types
 806         $ptypes = new PaymentTypes(
 807             $this->zdb,
 808             $this->preferences,
 809             $this->login
 810         );
 811         $ptlist = $ptypes->getList();
 812
 813         $filters->setViewCommonsFilters($this->preferences, $this->view->getSmarty());
 814
 815         // display page
 816         $this->view->render(
 817             $response,
 818             'advanced_search.tpl',
 819             array(
 820                 'page_title'            => _T("Advanced search"),
 821                 'filter_groups_options' => $groups_list,
 822                 'search_fields'         => $fields,
 823                 'adh_dynamics'          => $adh_dynamics->getFields(),
 824                 'contrib_dynamics'      => $contrib_dynamics->getFields(),
 825                 'statuts'               => $statuts->getList(),
 826                 'contributions_types'   => $ct->getList(),
 827                 'filters'               => $filters,
 828                 'payments_types'        => $ptlist
 829             )
 830         );
 831         return $response;
 832     }
 833
 834     /**
 835      * Members list for ajax
 836      *
 837      * @param Request  $request  PSR Request
 838      * @param Response $response PSR Response
 839      * @param array    $args     Request arguments
 840      *
 841      * @return Response
 842      */
 843     public function ajaxList(Request $request, Response $response, array $args = []): Response
 844     {
 845         $post = $request->getParsedBody();
 846
 847         if (isset($this->session->ajax_members_filters)) {
 848             $filters = $this->session->ajax_members_filters;
 849         } else {
 850             $filters = new MembersList();
 851         }
 852
 853         if (isset($args['option']) && $args['option'] == 'page') {
 854             $filters->current_page = (int)$args['value'];
 855         }
 856
 857         //numbers of rows to display
 858         if (isset($post['nbshow']) && is_numeric($post['nbshow'])) {
 859             $filters->show = $post['nbshow'];
 860         }
 861
 862         $members = new Members($filters);
 863         if (!$this->login->isAdmin() && !$this->login->isStaff()) {
 864             if ($this->login->isGroupManager()) {
 865                 $members_list = $members->getManagedMembersList(true);
 866             } else {
 867                 Analog::log(
 868                     str_replace(
 869                         ['%id', '%login'],
 870                         [$this->login->id, $this->login->login],
 871                         'Trying to list group members without access from #%id (%login)'
 872                     ),
 873                     Analog::ERROR
 874                 );
 875                 throw new \Exception('Access denied.');
 876             }
 877         } else {
 878             $members_list = $members->getMembersList(true);
 879         }
 880
 881         //assign pagination variables to the template and add pagination links
 882         $filters->setSmartyPagination($this->router, $this->view->getSmarty(), false);
 883
 884         $this->session->ajax_members_filters = $filters;
 885
 886         $selected_members = null;
 887         $unreachables_members = null;
 888         if (!isset($post['from'])) {
 889             $mailing = $this->session->mailing;
 890             if (!isset($post['members'])) {
 891                 $selected_members = $mailing->recipients;
 892                 $unreachables_members = $mailing->unreachables;
 893             } else {
 894                 $m = new Members();
 895                 $selected_members = $m->getArrayList($post['members']);
 896                 if (isset($post['unreachables']) && is_array($post['unreachables'])) {
 897                     $unreachables_members = $m->getArrayList($post['unreachables']);
 898                 }
 899             }
 900         } else {
 901             switch ($post['from']) {
 902                 case 'groups':
 903                     if (!isset($post['gid'])) {
 904                         Analog::log(
 905                             'Trying to list group members with no group id provided',
 906                             Analog::ERROR
 907                         );
 908                         throw new \Exception('A group id is required.');
 909                         exit(0);
 910                     }
 911                     if (!isset($post['members'])) {
 912                         $group = new Group((int)$post['gid']);
 913                         $selected_members = array();
 914                         if (!isset($post['mode']) || $post['mode'] == 'members') {
 915                             $selected_members = $group->getMembers();
 916                         } elseif ($post['mode'] == 'managers') {
 917                             $selected_members = $group->getManagers();
 918                         } else {
 919                             Analog::log(
 920                                 'Trying to list group members with unknown mode',
 921                                 Analog::ERROR
 922                             );
 923                             throw new \Exception('Unknown mode.');
 924                             exit(0);
 925                         }
 926                     } else {
 927                         $m = new Members();
 928                         $selected_members = $m->getArrayList($post['members']);
 929                         if (isset($post['unreachables']) && is_array($post['unreachables'])) {
 930                             $unreachables_members = $m->getArrayList($post['unreachables']);
 931                         }
 932                     }
 933                     break;
 934                 case 'attach':
 935                     if (!isset($post['id_adh'])) {
 936                         throw new \RuntimeException(
 937                             'Current selected member must be excluded while attaching!'
 938                         );
 939                         exit(0);
 940                     }
 941                     break;
 942             }
 943         }
 944
 945         $params = [
 946             'filters'               => $filters,
 947             'members_list'          => $members_list,
 948             'selected_members'      => $selected_members,
 949             'unreachables_members'  => $unreachables_members
 950         ];
 951
 952         if (isset($post['multiple'])) {
 953             $params['multiple'] = true;
 954         }
 955
 956         if (isset($post['gid'])) {
 957             $params['the_id'] = $post['gid'];
 958         }
 959
 960         if (isset($post['id_adh'])) {
 961             $params['excluded'] = $post['id_adh'];
 962         }
 963
 964         // display page
 965         $this->view->render(
 966             $response,
 967             'ajax_members.tpl',
 968             $params
 969         );
 970         return $response;
 971     }
 972
 973     /**
 974      * Batch actions handler
 975      *
 976      * @param Request  $request  PSR Request
 977      * @param Response $response PSR Response
 978      *
 979      * @return Response
 980      */
 981     public function handleBatch(Request $request, Response $response): Response
 982     {
 983         $post = $request->getParsedBody();
 984
 985         if (isset($post['member_sel'])) {
 986             if (isset($this->session->filter_members)) {
 987                 $filters = $this->session->filter_members;
 988             } else {
 989                 $filters = new MembersList();
 990             }
 991
 992             $filters->selected = $post['member_sel'];
 993             $this->session->filter_members = $filters;
 994
 995             if (isset($post['cards'])) {
 996                 return $response
 997                     ->withStatus(301)
 998                     ->withHeader('Location', $this->router->pathFor('pdf-members-cards'));
 999             }
1000
1001             if (isset($post['labels'])) {
1002                 return $response
1003                     ->withStatus(301)
1004                     ->withHeader('Location', $this->router->pathFor('pdf-members-labels'));
1005             }
1006
1007             if (isset($post['mailing'])) {
1008                 return $response
1009                     ->withStatus(301)
1010                     ->withHeader('Location', $this->router->pathFor('mailing') . '?mailing_new=new');
1011             }
1012
1013             if (isset($post['attendance_sheet'])) {
1014                 return $response
1015                     ->withStatus(301)
1016                     ->withHeader('Location', $this->router->pathFor('attendance_sheet_details'));
1017             }
1018
1019             if (isset($post['csv'])) {
1020                 return $response
1021                     ->withStatus(301)
1022                     ->withHeader('Location', $this->router->pathFor('csv-memberslist'));
1023             }
1024
1025             if (isset($post['delete'])) {
1026                 return $response
1027                     ->withStatus(301)
1028                     ->withHeader('Location', $this->router->pathFor('removeMembers'));
1029             }
1030
1031             if (isset($post['masschange'])) {
1032                 return $response
1033                     ->withStatus(301)
1034                     ->withHeader('Location', $this->router->pathFor('masschangeMembers'));
1035             }
1036
1037             throw new \RuntimeException('Does not know what to batch :(');
1038         } else {
1039             $this->flash->addMessage(
1040                 'error_detected',
1041                 _T("No member was selected, please check at least one name.")
1042             );
1043
1044             return $response
1045                 ->withStatus(301)
1046                 ->withHeader('Location', $this->router->pathFor('members'));
1047         }
1048     }
1049
1050     // /CRUD - Read
1051     // CRUD - Update
1052
1053     /**
1054      * Edit page
1055      *
1056      * @param Request  $request  PSR Request
1057      * @param Response $response PSR Response
1058      * @param array    $args     Request arguments
1059      *
1060      * @return Response
1061      */
1062     public function edit(Request $request, Response $response, array $args = []): Response
1063     {
1064         $action = $args['action'];
1065         $id = null;
1066         if (isset($args['id'])) {
1067             $id = (int)$args['id'];
1068         }
1069
1070         if ($action === 'edit' && $id === null) {
1071             throw new \RuntimeException(
1072                 _T("Member ID cannot ben null calling edit route!")
1073             );
1074         } elseif ($action === 'add' && $id !== null) {
1075             return $response
1076                 ->withStatus(301)
1077                 ->withHeader('Location', $this->router->pathFor('editmember', ['action' => 'add']));
1078         }
1079         $deps = array(
1080             'picture'   => true,
1081             'groups'    => true,
1082             'dues'      => true,
1083             'parent'    => true,
1084             'children'  => true,
1085             'dynamics'  => true
1086         );
1087
1088         if ($this->session->member !== null) {
1089             $member = $this->session->member;
1090             $this->session->member = null;
1091         } else {
1092             $member = new Adherent($this->zdb, $id, $deps);
1093         }
1094
1095         if ($id !== null) {
1096             $member->load($id);
1097             if (!$member->canEdit($this->login)) {
1098                 $this->flash->addMessage(
1099                     'error_detected',
1100                     _T("You do not have permission for requested URL.")
1101                 );
1102
1103                 return $response
1104                     ->withStatus(403)
1105                     ->withHeader(
1106                         'Location',
1107                         $this->router->pathFor('me')
1108                     );
1109             }
1110         } else {
1111             if ($member->id != $id) {
1112                 $member->load($this->login->id);
1113             }
1114         }
1115
1116         // flagging required fields
1117         $fc = $this->fields_config;
1118
1119         // password required if we create a new member
1120         if ($member->id != '') {
1121             $fc->setNotRequired('mdp_adh');
1122         }
1123
1124         //handle requirements for parent fields
1125         $parent_fields = $member->getParentFields();
1126         $tpl_parent_fields = []; //for JS when detaching
1127         foreach ($parent_fields as $field) {
1128             if ($fc->isRequired($field)) {
1129                 $tpl_parent_fields[] = $field;
1130                 if ($member->hasParent()) {
1131                     $fc->setNotRequired($field);
1132                 }
1133             }
1134         }
1135
1136         // flagging required fields invisible to members
1137         if ($this->login->isAdmin() || $this->login->isStaff()) {
1138             $fc->setNotRequired('activite_adh');
1139             $fc->setNotRequired('id_statut');
1140         }
1141
1142         // template variable declaration
1143         $title = _T("Member Profile");
1144         if ($member->id != '') {
1145             $title .= ' (' . _T("modification") . ')';
1146         } else {
1147             $title .= ' (' . _T("creation") . ')';
1148         }
1149
1150         //Status
1151         $statuts = new Status($this->zdb);
1152
1153         //Groups
1154         $groups = new Groups($this->zdb, $this->login);
1155         $groups_list = $groups->getSimpleList(true);
1156
1157         $form_elements = $fc->getFormElements(
1158             $this->login,
1159             $member->id == ''
1160         );
1161
1162         // members
1163         $m = new Members();
1164         $id = null;
1165         if ($member->hasParent()) {
1166             $id = ($member->parent instanceof Adherent ? $member->parent->id : $member->parent);
1167         }
1168         $members = $m->getSelectizedMembers(
1169             $this->zdb,
1170             $id
1171         );
1172
1173         $route_params['members'] = [
1174             'filters'   => $m->getFilters(),
1175             'count'     => $m->getCount()
1176         ];
1177
1178         if (count($members)) {
1179             $route_params['members']['list'] = $members;
1180         }
1181
1182         // display page
1183         $this->view->render(
1184             $response,
1185             'member.tpl',
1186             array(
1187                 'parent_tpl'        => 'page.tpl',
1188                 'autocomplete'      => true,
1189                 'page_title'        => $title,
1190                 'member'            => $member,
1191                 'self_adh'          => false,
1192                 // pseudo random int
1193                 'time'              => time(),
1194                 'titles_list'       => Titles::getList($this->zdb),
1195                 'statuts'           => $statuts->getList(),
1196                 'groups'            => $groups_list,
1197                 'fieldsets'         => $form_elements['fieldsets'],
1198                 'hidden_elements'   => $form_elements['hiddens'],
1199                 'parent_fields'     => $tpl_parent_fields
1200             ) + $route_params
1201         );
1202         return $response;
1203     }
1204
1205     /**
1206      * Edit action
1207      *
1208      * @param Request  $request  PSR Request
1209      * @param Response $response PSR Response
1210      * @param array    $args     Request arguments
1211      *
1212      * @return Response
1213      */
1214     public function doEdit(Request $request, Response $response, array $args = []): Response
1215     {
1216         return $this->store($request, $response, $args);
1217     }
1218
1219     /**
1220      * Massive change page
1221      *
1222      * @param Request  $request  PSR Request
1223      * @param Response $response PSR Response
1224      * @param array    $args     Request arguments
1225      *
1226      * @return Response
1227      */
1228     public function massChange(Request $request, Response $response, array $args = []): Response
1229     {
1230         $filters = $this->session->filter_members;
1231
1232         $data = [
1233             'id'            => $filters->selected,
1234             'redirect_uri'  => $this->router->pathFor('members')
1235         ];
1236
1237         $fc = $this->fields_config;
1238         $form_elements = $fc->getMassiveFormElements($this->members_fields, $this->login);
1239
1240         //dynamic fields
1241         $deps = array(
1242             'picture'   => false,
1243             'groups'    => false,
1244             'dues'      => false,
1245             'parent'    => false,
1246             'children'  => false,
1247             'dynamics'  => false
1248         );
1249         $member = new Adherent($this->zdb, null, $deps);
1250
1251         //Status
1252         $statuts = new Status($this->zdb);
1253
1254         // display page
1255         $this->view->render(
1256             $response,
1257             'mass_change_members.tpl',
1258             array(
1259                 'mode'          => $request->isXhr() ? 'ajax' : '',
1260                 'page_title'    => str_replace(
1261                     '%count',
1262                     count($data['id']),
1263                     _T('Mass change %count members')
1264                 ),
1265                 'form_url'      => $this->router->pathFor('masschangeMembersReview'),
1266                 'cancel_uri'    => $this->router->pathFor('members'),
1267                 'data'          => $data,
1268                 'member'        => $member,
1269                 'fieldsets'     => $form_elements['fieldsets'],
1270                 'titles_list'   => Titles::getList($this->zdb),
1271                 'statuts'       => $statuts->getList(),
1272                 'require_mass'  => true
1273             )
1274         );
1275         return $response;
1276     }
1277
1278     /**
1279      * Massive changes validation page
1280      *
1281      * @param Request  $request  PSR Request
1282      * @param Response $response PSR Response
1283      * @param array    $args     Request arguments
1284      *
1285      * @return Response
1286      */
1287     public function validateMassChange(Request $request, Response $response, array $args = []): Response
1288     {
1289         $post = $request->getParsedBody();
1290
1291         if (!isset($post['confirm'])) {
1292             $this->flash->addMessage(
1293                 'error_detected',
1294                 _T("Mass changes has not been confirmed!")
1295             );
1296         } else {
1297             //we want only visibles fields
1298             $fc = $this->fields_config;
1299             $form_elements = $fc->getMassiveFormElements($this->members_fields, $this->login);
1300
1301             $changes = [];
1302             foreach ($form_elements['fieldsets'] as $form_element) {
1303                 foreach ($form_element->elements as $field) {
1304                     if (isset($post[$field->field_id]) && isset($post['mass_' . $field->field_id])) {
1305                         $changes[$field->field_id] = [
1306                             'label' => $field->label,
1307                             'value' => $post[$field->field_id]
1308                         ];
1309                     }
1310                 }
1311             }
1312         }
1313
1314         $filters = $this->session->filter_members;
1315         $data = [
1316             'id'            => $filters->selected,
1317             'redirect_uri'  => $this->router->pathFor('members')
1318         ];
1319
1320         //Status
1321         $statuts = new Status($this->zdb);
1322
1323         // display page
1324         $this->view->render(
1325             $response,
1326             'mass_change_members.tpl',
1327             array(
1328                 'mode'          => $request->isXhr() ? 'ajax' : '',
1329                 'page_title'    => str_replace(
1330                     '%count',
1331                     count($data['id']),
1332                     _T('Review mass change %count members')
1333                 ),
1334                 'form_url'      => $this->router->pathFor('massstoremembers'),
1335                 'cancel_uri'    => $this->router->pathFor('members'),
1336                 'data'          => $data,
1337                 'titles_list'   => Titles::getList($this->zdb),
1338                 'statuts'       => $statuts->getList(),
1339                 'changes'       => $changes
1340             )
1341         );
1342         return $response;
1343     }
1344
1345     /**
1346      * Do massive changes
1347      *
1348      * @param Request  $request  PSR Request
1349      * @param Response $response PSR Response
1350      * @param array    $args     Request arguments
1351      *
1352      * @return Response
1353      */
1354     public function doMassChange(Request $request, Response $response, array $args = []): Response
1355     {
1356         $post = $request->getParsedBody();
1357         $redirect_url = $post['redirect_uri'];
1358         $error_detected = [];
1359         $mass = 0;
1360
1361         unset($post['redirect_uri']);
1362         if (!isset($post['confirm'])) {
1363             $error_detected[] = _T("Mass changes has not been confirmed!");
1364         } else {
1365             unset($post['confirm']);
1366             $ids = $post['id'];
1367             unset($post['id']);
1368
1369             $fc = $this->fields_config;
1370             $form_elements = $fc->getMassiveFormElements($this->members_fields, $this->login);
1371             $disabled = $this->members_fields;
1372             foreach (array_keys($post) as $key) {
1373                 $found = false;
1374                 foreach ($form_elements['fieldsets'] as $fieldset) {
1375                     if (isset($fieldset->elements[$key])) {
1376                         $found = true;
1377                         continue;
1378                     }
1379                 }
1380                 if (!$found) {
1381                     Analog::log(
1382                         'Permission issue mass editing field ' . $key,
1383                         Analog::WARNING
1384                     );
1385                     unset($post[$key]);
1386                 } else {
1387                     unset($disabled[$key]);
1388                 }
1389             }
1390
1391             if (!count($post)) {
1392                 $error_detected[] = _T("Nothing to do!");
1393             } else {
1394                 foreach ($ids as $id) {
1395                     $is_manager = !$this->login->isAdmin()
1396                         && !$this->login->isStaff()
1397                         && $this->login->isGroupManager();
1398                     $deps = array(
1399                         'picture'   => false,
1400                         'groups'    => $is_manager,
1401                         'dues'      => false,
1402                         'parent'    => false,
1403                         'children'  => false,
1404                         'dynamics'  => false
1405                     );
1406                     $member = new Adherent($this->zdb, (int)$id, $deps);
1407                     $member->setDependencies(
1408                         $this->preferences,
1409                         $this->members_fields,
1410                         $this->history
1411                     );
1412                     if (!$member->canEdit($this->login)) {
1413                         continue;
1414                     }
1415
1416                     $valid = $member->check($post, [], $disabled);
1417                     if ($valid === true) {
1418                         $done = $member->store();
1419                         if (!$done) {
1420                             $error_detected[] = _T("An error occurred while storing the member.");
1421                         } else {
1422                             ++$mass;
1423                         }
1424                     } else {
1425                         $error_detected = array_merge($error_detected, $valid);
1426                     }
1427                 }
1428             }
1429         }
1430
1431         if ($mass == 0 && !count($error_detected)) {
1432             $error_detected[] = _T('Something went wront during mass edition!');
1433         } else {
1434             $this->flash->addMessage(
1435                 'success_detected',
1436                 str_replace(
1437                     '%count',
1438                     $mass,
1439                     _T('%count members has been changed successfully!')
1440                 )
1441             );
1442         }
1443
1444         if (count($error_detected) > 0) {
1445             foreach ($error_detected as $error) {
1446                 $this->flash->addMessage(
1447                     'error_detected',
1448                     $error
1449                 );
1450             }
1451         }
1452
1453         if (!$request->isXhr()) {
1454             return $response
1455                 ->withStatus(301)
1456                 ->withHeader('Location', $redirect_url);
1457         } else {
1458             return $response->withJson(
1459                 [
1460                     'success'   => count($error_detected) === 0
1461                 ]
1462             );
1463         }
1464     }
1465
1466     /**
1467      * Store
1468      *
1469      * @param Request  $request  PSR Request
1470      * @param Response $response PSR Response
1471      * @param array    $args     Request arguments
1472      *
1473      * @return Response
1474      */
1475     public function store(Request $request, Response $response, array $args = []): Response
1476     {
1477         if (!$this->preferences->pref_bool_selfsubscribe && !$this->login->isLogged()) {
1478             return $response
1479                 ->withStatus(301)
1480                 ->withHeader('Location', $this->router->pathFor('slash'));
1481         }
1482
1483         $post = $request->getParsedBody();
1484         $deps = array(
1485             'picture'   => true,
1486             'groups'    => true,
1487             'dues'      => true,
1488             'parent'    => true,
1489             'children'  => true,
1490             'dynamics'  => true
1491         );
1492         $member = new Adherent($this->zdb, null, $deps);
1493         $member->setDependencies(
1494             $this->preferences,
1495             $this->members_fields,
1496             $this->history
1497         );
1498         if (isset($args['self'])) {
1499             //mark as self membership
1500             $member->setSelfMembership();
1501         }
1502
1503         $success_detected = [];
1504         $warning_detected = [];
1505         $error_detected = [];
1506
1507         //check captcha
1508         if (isset($args['self'])) {
1509             if (
1510                 !$post['mdp_crypt']
1511                 || !$post['mdp_adh']
1512                 || !crypt($post['mdp_adh'], $post['mdp_crypt']) == $post['mdp_crypt']
1513             ) {
1514                 $error_detected[] = __('Please repeat in the field the password shown in the image.');
1515             }
1516         }
1517
1518         // new or edit
1519         $adherent['id_adh'] = get_numeric_form_value('id_adh', '');
1520         if ($this->login->isAdmin() || $this->login->isStaff() || $this->login->isGroupManager()) {
1521             if ($adherent['id_adh']) {
1522                 $member->load((int)$adherent['id_adh']);
1523                 if (!$member->canEdit($this->login)) {
1524                     //redirection should have been done before. Just throw an Exception.
1525                     throw new \RuntimeException(
1526                         str_replace(
1527                             '%id',
1528                             $member->id,
1529                             'No right to store member #%id'
1530                         )
1531                     );
1532                 }
1533             }
1534         } else {
1535             $member->load($this->login->id);
1536             $adherent['id_adh'] = $this->login->id;
1537         }
1538
1539         // flagging required fields
1540         $fc = $this->fields_config;
1541
1542         // password required if we create a new member
1543         if ($member->id != '') {
1544             $fc->setNotRequired('mdp_adh');
1545         }
1546
1547         if (
1548             $member->hasParent() && !isset($post['detach_parent'])
1549             || isset($post['parent_id']) && !empty($post['parent_id'])
1550         ) {
1551             $parent_fields = $member->getParentFields();
1552             foreach ($parent_fields as $field) {
1553                 if ($fc->isRequired($field)) {
1554                     $fc->setNotRequired($field);
1555                 }
1556             }
1557         }
1558
1559         // flagging required fields invisible to members
1560         if ($this->login->isAdmin() || $this->login->isStaff()) {
1561             $fc->setNotRequired('activite_adh');
1562             $fc->setNotRequired('id_statut');
1563         }
1564
1565         $form_elements = $fc->getFormElements(
1566             $this->login,
1567             $member->id == '',
1568             isset($args['self'])
1569         );
1570         $fieldsets     = $form_elements['fieldsets'];
1571         $required      = array();
1572         $disabled      = array();
1573
1574         foreach ($fieldsets as $category) {
1575             foreach ($category->elements as $field) {
1576                 if ($field->required == true) {
1577                     $required[$field->field_id] = true;
1578                 }
1579                 if ($field->disabled == true) {
1580                     $disabled[$field->field_id] = true;
1581                 } elseif (!isset($post[$field->field_id])) {
1582                     switch ($field->field_id) {
1583                         //unchecked booleans are not sent from form
1584                         case 'bool_admin_adh':
1585                         case 'bool_exempt_adh':
1586                         case 'bool_display_info':
1587                             $post[$field->field_id] = 0;
1588                             break;
1589                     }
1590                 }
1591             }
1592         }
1593
1594         $real_requireds = array_diff(array_keys($required), array_keys($disabled));
1595
1596         // Validation
1597         $redirect_url = $this->router->pathFor('member', ['id' => $member->id]);
1598         if (isset($post[array_shift($real_requireds)])) {
1599             // regular fields
1600             $valid = $member->check($post, $required, $disabled);
1601             if ($valid !== true) {
1602                 $error_detected = array_merge($error_detected, $valid);
1603             }
1604
1605             if (count($error_detected) == 0) {
1606                 //all goes well, we can proceed
1607
1608                 $new = false;
1609                 if ($member->id == '') {
1610                     $new = true;
1611                 }
1612                 $store = $member->store();
1613                 if ($store === true) {
1614                     //member has been stored :)
1615                     if ($new) {
1616                         if (isset($args['self'])) {
1617                             $success_detected[] = _T("Your account has been created!");
1618                             if (
1619                                 $this->preferences->pref_mail_method > GaletteMail::METHOD_DISABLED
1620                                 && $member->getEmail() != ''
1621                             ) {
1622                                 $success_detected[] = _T("An email has been sent to you, check your inbox.");
1623                             }
1624                         } else {
1625                             $success_detected[] = _T("New member has been successfully added.");
1626                         }
1627                         //Send email to admin if preference checked
1628                         if (
1629                             $this->preferences->pref_mail_method > GaletteMail::METHOD_DISABLED
1630                             && $this->preferences->pref_bool_mailadh
1631                         ) {
1632                             $texts = new Texts(
1633                                 $this->preferences,
1634                                 $this->router,
1635                                 array(
1636                                     'name_adh'      => custom_html_entity_decode(
1637                                         $member->sname
1638                                     ),
1639                                     'firstname_adh' => custom_html_entity_decode(
1640                                         $member->surname
1641                                     ),
1642                                     'lastname_adh'  => custom_html_entity_decode(
1643                                         $member->name
1644                                     ),
1645                                     'mail_adh'      => custom_html_entity_decode(
1646                                         $member->email
1647                                     ),
1648                                     'login_adh'     => custom_html_entity_decode(
1649                                         $member->login
1650                                     )
1651                                 )
1652                             );
1653                             $mtxt = $texts->getTexts(
1654                                 (isset($args['self']) ? 'newselfadh' : 'newadh'),
1655                                 $this->preferences->pref_lang
1656                             );
1657
1658                             $mail = new GaletteMail($this->preferences);
1659                             $mail->setSubject($texts->getSubject());
1660                             $recipients = [];
1661                             foreach ($this->preferences->vpref_email_newadh as $pref_email) {
1662                                 $recipients[$pref_email] = $pref_email;
1663                             }
1664                             $mail->setRecipients($recipients);
1665                             $mail->setMessage($texts->getBody());
1666                             $sent = $mail->send();
1667
1668                             if ($sent == GaletteMail::MAIL_SENT) {
1669                                 $this->history->add(
1670                                     str_replace(
1671                                         '%s',
1672                                         $member->sname . ' (' . $member->email . ')',
1673                                         _T("New account email sent to admin for '%s'.")
1674                                     )
1675                                 );
1676                             } else {
1677                                 $str = str_replace(
1678                                     '%s',
1679                                     $member->sname . ' (' . $member->email . ')',
1680                                     _T("A problem happened while sending email to admin for account '%s'.")
1681                                 );
1682                                 $this->history->add($str);
1683                                 $warning_detected[] = $str;
1684                             }
1685                             unset($texts);
1686                         }
1687                     } else {
1688                         $success_detected[] = _T("Member account has been modified.");
1689                     }
1690
1691                     // send email to member
1692                     if (isset($args['self']) || isset($post['mail_confirm']) && $post['mail_confirm'] == '1') {
1693                         if ($this->preferences->pref_mail_method > GaletteMail::METHOD_DISABLED) {
1694                             if ($member->getEmail() == '' && !isset($args['self'])) {
1695                                 $error_detected[] = _T("- You can't send a confirmation by email if the member hasn't got an address!");
1696                             } else {
1697                                 $mreplaces = [
1698                                     'name_adh'      => custom_html_entity_decode(
1699                                         $member->sname
1700                                     ),
1701                                     'firstname_adh' => custom_html_entity_decode(
1702                                         $member->surname
1703                                     ),
1704                                     'lastname_adh'  => custom_html_entity_decode(
1705                                         $member->name
1706                                     ),
1707                                     'mail_adh'      => custom_html_entity_decode(
1708                                         $member->getEmail()
1709                                     ),
1710                                     'login_adh'     => custom_html_entity_decode(
1711                                         $member->login
1712                                     )
1713                                 ];
1714                                 if ($new) {
1715                                     $password = new Password($this->zdb);
1716                                     $res = $password->generateNewPassword($member->id);
1717                                     if ($res == true) {
1718                                         $link_validity = new \DateTime();
1719                                         $link_validity->add(new \DateInterval('PT24H'));
1720                                         $mreplaces['change_pass_uri'] = $this->preferences->getURL() .
1721                                             $this->router->pathFor(
1722                                                 'password-recovery',
1723                                                 ['hash' => base64_encode($password->getHash())]
1724                                             );
1725                                         $mreplaces['link_validity'] = $link_validity->format(_T("Y-m-d H:i:s"));
1726                                     } else {
1727                                         $str = str_replace(
1728                                             '%s',
1729                                             $member->sfullname,
1730                                             _T("An error occurred storing temporary password for %s. Please inform an admin.")
1731                                         );
1732                                         $this->history->add($str);
1733                                         $this->flash->addMessage(
1734                                             'error_detected',
1735                                             $str
1736                                         );
1737                                     }
1738                                 }
1739
1740                                 //send email to member
1741                                 // Get email text in database
1742                                 $texts = new Texts(
1743                                     $this->preferences,
1744                                     $this->router,
1745                                     $mreplaces
1746                                 );
1747                                 $mlang = $this->preferences->pref_lang;
1748                                 if (isset($post['pref_lang'])) {
1749                                     $mlang = $post['pref_lang'];
1750                                 }
1751                                 $mtxt = $texts->getTexts(
1752                                     (($new) ? 'sub' : 'accountedited'),
1753                                     $mlang
1754                                 );
1755
1756                                 $mail = new GaletteMail($this->preferences);
1757                                 $mail->setSubject($texts->getSubject());
1758                                 $mail->setRecipients(
1759                                     array(
1760                                         $member->getEmail() => $member->sname
1761                                     )
1762                                 );
1763                                 $mail->setMessage($texts->getBody());
1764                                 $sent = $mail->send();
1765
1766                                 if ($sent == GaletteMail::MAIL_SENT) {
1767                                     $msg = str_replace(
1768                                         '%s',
1769                                         $member->sname . ' (' . $member->getEmail() . ')',
1770                                         ($new) ?
1771                                         _T("New account email sent to '%s'.") : _T("Account modification email sent to '%s'.")
1772                                     );
1773                                     $this->history->add($msg);
1774                                     $success_detected[] = $msg;
1775                                 } else {
1776                                     $str = str_replace(
1777                                         '%s',
1778                                         $member->sname . ' (' . $member->getEmail() . ')',
1779                                         _T("A problem happened while sending account email to '%s'")
1780                                     );
1781                                     $this->history->add($str);
1782                                     $error_detected[] = $str;
1783                                 }
1784                             }
1785                         } elseif ($this->preferences->pref_mail_method == GaletteMail::METHOD_DISABLED) {
1786                             //if email has been disabled in the preferences, we should not be here ;
1787                             //we do not throw an error, just a simple warning that will be show later
1788                             $msg = _T("You asked Galette to send a confirmation email to the member, but email has been disabled in the preferences.");
1789                             $warning_detected[] = $msg;
1790                         }
1791                     }
1792
1793                     // send email to admin
1794                     if (
1795                         $this->preferences->pref_mail_method > GaletteMail::METHOD_DISABLED
1796                         && $this->preferences->pref_bool_mailadh
1797                         && !$new
1798                         && $member->id == $this->login->id
1799                     ) {
1800                         $mreplaces = [
1801                             'name_adh'      => custom_html_entity_decode(
1802                                 $member->sname
1803                             ),
1804                             'firstname_adh' => custom_html_entity_decode(
1805                                 $member->surname
1806                             ),
1807                             'lastname_adh'  => custom_html_entity_decode(
1808                                 $member->name
1809                             ),
1810                             'mail_adh'      => custom_html_entity_decode(
1811                                 $member->getEmail()
1812                             ),
1813                             'login_adh'     => custom_html_entity_decode(
1814                                 $member->login
1815                             )
1816                         ];
1817
1818                         //send email to member
1819                         // Get email text in database
1820                         $texts = new Texts(
1821                             $this->preferences,
1822                             $this->router,
1823                             $mreplaces
1824                         );
1825                         $mlang = $this->preferences->pref_lang;
1826
1827                         $mtxt = $texts->getTexts(
1828                             'admaccountedited',
1829                             $mlang
1830                         );
1831
1832                         $mail = new GaletteMail($this->preferences);
1833                         $mail->setSubject($texts->getSubject());
1834                         $recipients = [];
1835                         foreach ($this->preferences->vpref_email_newadh as $pref_email) {
1836                             $recipients[$pref_email] = $pref_email;
1837                         }
1838                         $mail->setRecipients($recipients);
1839
1840                         $mail->setMessage($texts->getBody());
1841                         $sent = $mail->send();
1842
1843                         if ($sent == GaletteMail::MAIL_SENT) {
1844                             $msg = _T("Account modification email sent to admin.");
1845                             $this->history->add($msg);
1846                             $success_detected[] = $msg;
1847                         } else {
1848                             $str = _T("A problem happened while sending account email to admin");
1849                             $this->history->add($str);
1850                             $warning_detected[] = $str;
1851                         }
1852                     }
1853
1854                     //store requested groups
1855                     $add_groups = null;
1856                     $groups_adh = null;
1857                     $managed_groups_adh = null;
1858
1859                     //add/remove user from groups
1860                     if (isset($post['groups_adh'])) {
1861                         $groups_adh = $post['groups_adh'];
1862                     }
1863                     $add_groups = Groups::addMemberToGroups(
1864                         $member,
1865                         $groups_adh
1866                     );
1867
1868                     if ($add_groups === false) {
1869                         $error_detected[] = _T("An error occurred adding member to its groups.");
1870                     }
1871
1872                     //add/remove manager from groups
1873                     if (isset($post['groups_managed_adh'])) {
1874                         $managed_groups_adh = $post['groups_managed_adh'];
1875                     }
1876                     $add_groups = Groups::addMemberToGroups(
1877                         $member,
1878                         $managed_groups_adh,
1879                         true
1880                     );
1881                     $member->loadGroups();
1882
1883                     if ($add_groups === false) {
1884                         $error_detected[] = _T("An error occurred adding member to its groups as manager.");
1885                     }
1886                 } else {
1887                     //something went wrong :'(
1888                     $error_detected[] = _T("An error occurred while storing the member.");
1889                 }
1890             }
1891
1892             if (count($error_detected) == 0) {
1893                 $files_res = $member->handleFiles($_FILES);
1894                 if (is_array($files_res)) {
1895                     $error_detected = array_merge($error_detected, $files_res);
1896                 }
1897
1898                 if (isset($post['del_photo'])) {
1899                     if (!$member->picture->delete($member->id)) {
1900                         $error_detected[] = _T("Delete failed");
1901                         $str_adh = $member->id . ' (' . $member->sname . ' ' . ')';
1902                         Analog::log(
1903                             'Unable to delete picture for member ' . $str_adh,
1904                             Analog::ERROR
1905                         );
1906                     }
1907                 }
1908             }
1909
1910             if (count($error_detected) > 0) {
1911                 foreach ($error_detected as $error) {
1912                     if (strpos($error, '%member_url_') !== false) {
1913                         preg_match('/%member_url_(\d+)/', $error, $matches);
1914                         $url = $this->router->pathFor('member', ['id' => $matches[1]]);
1915                         $error = str_replace(
1916                             '%member_url_' . $matches[1],
1917                             $url,
1918                             $error
1919                         );
1920                     }
1921                     $this->flash->addMessage(
1922                         'error_detected',
1923                         $error
1924                     );
1925                 }
1926             }
1927
1928             if (count($warning_detected) > 0) {
1929                 foreach ($warning_detected as $warning) {
1930                     $this->flash->addMessage(
1931                         'warning_detected',
1932                         $warning
1933                     );
1934                 }
1935             }
1936             if (count($success_detected) > 0) {
1937                 foreach ($success_detected as $success) {
1938                     $this->flash->addMessage(
1939                         'success_detected',
1940                         $success
1941                     );
1942                 }
1943             }
1944
1945             if (count($error_detected) == 0) {
1946                 if (isset($args['self'])) {
1947                     $redirect_url = $this->router->pathFor('login');
1948                 } elseif (
1949                     isset($post['redirect_on_create'])
1950                     && $post['redirect_on_create'] > Adherent::AFTER_ADD_DEFAULT
1951                 ) {
1952                     switch ($post['redirect_on_create']) {
1953                         case Adherent::AFTER_ADD_TRANS:
1954                             $redirect_url = $this->router->pathFor('transaction', ['action' => 'add']);
1955                             break;
1956                         case Adherent::AFTER_ADD_NEW:
1957                             $redirect_url = $this->router->pathFor('editmember', ['action' => 'add']);
1958                             break;
1959                         case Adherent::AFTER_ADD_SHOW:
1960                             $redirect_url = $this->router->pathFor('member', ['id' => $member->id]);
1961                             break;
1962                         case Adherent::AFTER_ADD_LIST:
1963                             $redirect_url = $this->router->pathFor('members');
1964                             break;
1965                         case Adherent::AFTER_ADD_HOME:
1966                             $redirect_url = $this->router->pathFor('slash');
1967                             break;
1968                     }
1969                 } elseif (!isset($post['id_adh']) && !$member->isDueFree()) {
1970                     $redirect_url = $this->router->pathFor(
1971                         'addContribution',
1972                         ['type' => 'fee']
1973                     ) . '?id_adh=' . $member->id;
1974                 } else {
1975                     $redirect_url = $this->router->pathFor('member', ['id' => $member->id]);
1976                 }
1977             } else {
1978                 //store entity in session
1979                 $this->session->member = $member;
1980
1981                 if (isset($args['self'])) {
1982                     $redirect_url = $this->router->pathFor('subscribe');
1983                 } else {
1984                     if ($member->id) {
1985                         $rparams = [
1986                             'id'    => $member->id,
1987                             'action'    => 'edit'
1988                         ];
1989                     } else {
1990                         $rparams = ['action' => 'add'];
1991                     }
1992                     $redirect_url = $this->router->pathFor(
1993                         'editmember',
1994                         $rparams
1995                     );
1996                 }
1997             }
1998         }
1999
2000         return $response
2001             ->withStatus(301)
2002             ->withHeader('Location', $redirect_url);
2003     }
2004
2005
2006     // /CRUD - Update
2007     // CRUD - Delete
2008
2009     /**
2010      * Get redirection URI
2011      *
2012      * @param array $args Route arguments
2013      *
2014      * @return string
2015      */
2016     public function redirectUri(array $args = [])
2017     {
2018         return $this->router->pathFor('members');
2019     }
2020
2021     /**
2022      * Get form URI
2023      *
2024      * @param array $args Route arguments
2025      *
2026      * @return string
2027      */
2028     public function formUri(array $args = [])
2029     {
2030         return $this->router->pathFor(
2031             'doRemoveMember',
2032             $args
2033         );
2034     }
2035
2036
2037     /**
2038      * Get ID to remove
2039      *
2040      * In simple cases, we get the ID in the route arguments; but for
2041      * batchs, it should be found elsewhere.
2042      * In post values, we look for id key, as well as all {sthing}_sel keys (like members_sel or contrib_sel)
2043      *
2044      * @param array $args Request arguments
2045      * @param array $post POST values
2046      *
2047      * @return null|integer|integer[]
2048      */
2049     protected function getIdsToRemove(&$args, $post)
2050     {
2051         if (isset($args['id'])) {
2052             return $args['id'];
2053         } else {
2054             $filters = $this->session->filter_members;
2055             return $filters->selected;
2056         }
2057     }
2058
2059     /**
2060      * Get confirmation removal page title
2061      *
2062      * @param array $args Route arguments
2063      *
2064      * @return string
2065      */
2066     public function confirmRemoveTitle(array $args = [])
2067     {
2068         if (isset($args['id_adh'])) {
2069             //one member removal
2070             $adh = new Adherent($this->zdb, (int)$args['id_adh']);
2071             return sprintf(
2072                 _T('Remove member %1$s'),
2073                 $adh->sfullname
2074             );
2075         } else {
2076             //batch members removal
2077             $filters = $this->session->filter_members;
2078             return str_replace(
2079                 '%count',
2080                 count($filters->selected),
2081                 _T('You are about to remove %count members.')
2082             );
2083         }
2084     }
2085
2086     /**
2087      * Remove object
2088      *
2089      * @param array $args Route arguments
2090      * @param array $post POST values
2091      *
2092      * @return boolean
2093      */
2094     protected function doDelete(array $args, array $post)
2095     {
2096         if (isset($this->session->filter_members)) {
2097             $filters = $this->session->filter_members;
2098         } else {
2099             $filters = new MembersList();
2100         }
2101         $members = new Members($filters);
2102
2103         if (!is_array($post['id'])) {
2104             $ids = (array)$post['id'];
2105         } else {
2106             $ids = $post['id'];
2107         }
2108
2109         return $members->removeMembers($ids);
2110     }
2111
2112     // CRUD - Delete
2113 }