galette/lib/Galette/Controllers/CsvController.php

   1 <?php
   2
   3 /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
   4
   5 /**
   6  * Galette CSV controller
   7  *
   8  * PHP version 5
   9  *
  10  * Copyright © 2019-2021 The Galette Team
  11  *
  12  * This file is part of Galette (http://galette.tuxfamily.org).
  13  *
  14  * Galette is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation, either version 3 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * Galette is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  *  GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with Galette. If not, see <http://www.gnu.org/licenses/>.
  26  *
  27  * @category  Controllers
  28  * @package   Galette
  29  *
  30  * @author    Johan Cwiklinski <johan@x-tnd.be>
  31  * @copyright 2019-2021 The Galette Team
  32  * @license   http://www.gnu.org/licenses/gpl-3.0.html GPL License 3.0 or (at your option) any later version
  33  * @link      http://galette.tuxfamily.org
  34  * @since     Available since 0.9.4dev - 2019-12-06
  35  */
  36
  37 namespace Galette\Controllers;
  38
  39 use Slim\Http\Request;
  40 use Slim\Http\Response;
  41 use Galette\Entity\ImportModel;
  42 use Galette\Filters\MembersList;
  43 use Galette\IO\Csv;
  44 use Galette\IO\CsvIn;
  45 use Galette\IO\CsvOut;
  46 use Galette\IO\MembersCsv;
  47 use Galette\Repository\DynamicFieldsSet;
  48 use Analog\Analog;
  49
  50 /**
  51  * Galette CSV controller
  52  *
  53  * @category  Controllers
  54  * @name      CsvController
  55  * @package   Galette
  56  * @author    Johan Cwiklinski <johan@x-tnd.be>
  57  * @copyright 2019-2021 The Galette Team
  58  * @license   http://www.gnu.org/licenses/gpl-3.0.html GPL License 3.0 or (at your option) any later version
  59  * @link      http://galette.tuxfamily.org
  60  * @since     Available since 0.9.4dev - 2019-12-06
  61  */
  62
  63 class CsvController extends AbstractController
  64 {
  65     /**
  66      * Send response
  67      *
  68      * @param Response $response PSR Response
  69      * @param string   $filepath File path on disk
  70      * @param string   $filename File name for output
  71      *
  72      * @return Response
  73      */
  74     protected function sendResponse(Response $response, $filepath, $filename): Response
  75     {
  76         if (file_exists($filepath)) {
  77             $response = $response->withHeader('Content-Description', 'File Transfer')
  78                 ->withHeader('Content-Type', 'text/csv')
  79                 ->withHeader('Content-Disposition', 'attachment;filename="' . $filename . '"')
  80                 ->withHeader('Pragma', 'no-cache')
  81                 ->withHeader('Content-Transfer-Encoding', 'binary')
  82                 ->withHeader('Expires', '0')
  83                 ->withHeader('Cache-Control', 'must-revalidate')
  84                 ->withHeader('Pragma', 'public');
  85
  86             $stream = fopen('php://memory', 'r+');
  87             fwrite($stream, file_get_contents($filepath));
  88             rewind($stream);
  89
  90             return $response->withBody(new \Slim\Http\Stream($stream));
  91         } else {
  92             Analog::log(
  93                 'A request has been made to get a CSV file named `' .
  94                 $filename . '` that does not exists (' . $filepath . ').',
  95                 Analog::WARNING
  96             );
  97             $notFound = $this->notFoundHandler;
  98             return $notFound($request, $response);
  99         }
 100     }
 101
 102     /**
 103      * Exports page
 104      *
 105      * @param Request  $request  PSR Request
 106      * @param Response $response PSR Response
 107      *
 108      * @return Response
 109      */
 110     public function export(Request $request, Response $response): Response
 111     {
 112         $csv = new CsvOut();
 113
 114         $tables_list = $this->zdb->getTables();
 115         $parameted = $csv->getParametedExports();
 116         $existing = $csv->getExisting();
 117
 118         // display page
 119         $this->view->render(
 120             $response,
 121             'export.tpl',
 122             array(
 123                 'page_title'        => _T("CVS database Export"),
 124                 'tables_list'       => $tables_list,
 125                 'written'           => $this->flash->getMessage('written_exports'),
 126                 'existing'          => $existing,
 127                 'parameted'         => $parameted
 128             )
 129         );
 130         return $response;
 131     }
 132
 133     /**
 134      * Proceed exports
 135      *
 136      * @param Request  $request  PSR Request
 137      * @param Response $response PSR Response
 138      *
 139      * @return Response
 140      */
 141     public function doExport(Request $request, Response $response): Response
 142     {
 143         $post = $request->getParsedBody();
 144         $csv = new CsvOut();
 145         $written = [];
 146
 147         if (isset($post['export_tables']) && $post['export_tables'] != '') {
 148             foreach ($post['export_tables'] as $table) {
 149                 $select = $this->zdb->sql->select($table);
 150                 $results = $this->zdb->execute($select);
 151
 152                 if ($results->count() > 0) {
 153                     $filename = $table . '_full.csv';
 154                     $filepath = CsvOut::DEFAULT_DIRECTORY . $filename;
 155                     $fp = fopen($filepath, 'w');
 156                     if ($fp) {
 157                         $res = $csv->export(
 158                             $results,
 159                             Csv::DEFAULT_SEPARATOR,
 160                             Csv::DEFAULT_QUOTE,
 161                             true,
 162                             $fp
 163                         );
 164                         fclose($fp);
 165                         $written[] = [
 166                             'name' => $table,
 167                             'file' => $filename
 168                         ];
 169                     }
 170                 } else {
 171                     $this->flash->addMessage(
 172                         'warning_detected',
 173                         str_replace(
 174                             '%table',
 175                             $table,
 176                             _T("Table %table is empty, and has not been exported.")
 177                         )
 178                     );
 179                 }
 180             }
 181         }
 182
 183         if (isset($post['export_parameted']) && $post['export_parameted'] != '') {
 184             foreach ($post['export_parameted'] as $p) {
 185                 $res = $csv->runParametedExport($p);
 186                 $pn = $csv->getParamedtedExportName($p);
 187                 switch ($res) {
 188                     case Csv::FILE_NOT_WRITABLE:
 189                         $this->flash->addMessage(
 190                             'error_detected',
 191                             str_replace(
 192                                 '%export',
 193                                 $pn,
 194                                 _T("Export file could not be write on disk for '%export'. Make sure web server can write in the exports directory.")
 195                             )
 196                         );
 197                         break;
 198                     case Csv::DB_ERROR:
 199                         $this->flash->addMessage(
 200                             'error_detected',
 201                             str_replace(
 202                                 '%export',
 203                                 $pn,
 204                                 _T("An error occurred running parameted export '%export'.")
 205                             )
 206                         );
 207                         break;
 208                     case false:
 209                         $this->flash->addMessage(
 210                             'error_detected',
 211                             str_replace(
 212                                 '%export',
 213                                 $pn,
 214                                 _T("An error occurred running parameted export '%export'. Please check the logs.")
 215                             )
 216                         );
 217                         break;
 218                     default:
 219                         //no error, file has been writted to disk
 220                         $written[] = [
 221                             'name' => $pn,
 222                             'file' => (string)$res
 223                         ];
 224                         break;
 225                 }
 226             }
 227         }
 228
 229         if (count($written)) {
 230             foreach ($written as $ex) {
 231                 $path = $this->router->pathFor('getCsv', ['type' => 'export', 'file' => $ex['file']]);
 232                 $this->flash->addMessage(
 233                     'written_exports',
 234                     '<a href="' . $path . '">' . $ex['name'] . ' (' . $ex['file'] . ')</a>'
 235                 );
 236             }
 237         }
 238
 239         return $response
 240             ->withStatus(301)
 241             ->withHeader('Location', $this->router->pathFor('export'));
 242     }
 243
 244     /**
 245      * Imports page
 246      *
 247      * @param Request  $request  PSR Request
 248      * @param Response $response PSR Response
 249      *
 250      * @return Response
 251      */
 252     public function import(Request $request, Response $response): Response
 253     {
 254         $csv = new CsvIn($this->zdb);
 255         $existing = $csv->getExisting();
 256         $dryrun = true;
 257
 258         // display page
 259         $this->view->render(
 260             $response,
 261             'import.tpl',
 262             array(
 263                 'page_title'        => _T("CSV members import"),
 264                 'existing'          => $existing,
 265                 'dryrun'            => $dryrun,
 266                 'import_file'       => $this->session->import_file
 267             )
 268         );
 269         return $response;
 270     }
 271
 272     /**
 273      * Proceed imports
 274      *
 275      * @param Request  $request  PSR Request
 276      * @param Response $response PSR Response
 277      *
 278      * @return Response
 279      */
 280     public function doImports(Request $request, Response $response): Response
 281     {
 282         $csv = new CsvIn($this->zdb);
 283         $post = $request->getParsedBody();
 284         $dryrun = isset($post['dryrun']);
 285
 286         //store selected file to dispaly again in UI
 287         $this->session->import_file = $post['import_file'];
 288
 289         $res = $csv->import(
 290             $this->zdb,
 291             $this->preferences,
 292             $this->history,
 293             $post['import_file'],
 294             $this->members_fields,
 295             $this->members_fields_cats,
 296             $dryrun
 297         );
 298         if ($res !== true) {
 299             if ($res < 0) {
 300                 $this->flash->addMessage(
 301                     'error_detected',
 302                     $csv->getErrorMessage($res)
 303                 );
 304                 if (count($csv->getErrors()) > 0) {
 305                     foreach ($csv->getErrors() as $error) {
 306                         $this->flash->addMessage(
 307                             'error_detected',
 308                             $error
 309                         );
 310                     }
 311                 }
 312             } else {
 313                 $this->flash->addMessage(
 314                     'error_detected',
 315                     _T("An error occurred importing the file :(")
 316                 );
 317             }
 318         } else {
 319             if ($this->session->import_file && !$dryrun) {
 320                 $this->session->import_file = null;
 321             }
 322             $this->flash->addMessage(
 323                 'success_detected',
 324                 str_replace(
 325                     '%filename%',
 326                     $post['import_file'],
 327                     _T("File '%filename%' has been successfully imported :)")
 328                 )
 329             );
 330         }
 331         return $response
 332             ->withStatus(301)
 333             ->withHeader('Location', $this->router->pathFor('import'));
 334     }
 335
 336     /**
 337      * Get CSV file (imports or exports)
 338      *
 339      * @param Request  $request  PSR Request
 340      * @param Response $response PSR Response
 341      *
 342      * @return Response
 343      */
 344     public function uploadImportFile(Request $request, Response $response): Response
 345     {
 346         $csv = new CsvIn($this->zdb);
 347         if (isset($_FILES['new_file'])) {
 348             if ($_FILES['new_file']['error'] === UPLOAD_ERR_OK) {
 349                 if ($_FILES['new_file']['tmp_name'] != '') {
 350                     if (is_uploaded_file($_FILES['new_file']['tmp_name'])) {
 351                         $res = $csv->store($_FILES['new_file']);
 352                         if ($res < 0) {
 353                             $this->flash->addMessage(
 354                                 'error_detected',
 355                                 $csv->getErrorMessage($res)
 356                             );
 357                         } else {
 358                             $this->flash->addMessage(
 359                                 'success_detected',
 360                                 _T("Your file has been successfully uploaded!")
 361                             );
 362                         }
 363                     }
 364                 }
 365             } elseif ($_FILES['new_file']['error'] !== UPLOAD_ERR_NO_FILE) {
 366                 Analog::log(
 367                     $csv->getPhpErrorMessage($_FILES['new_file']['error']),
 368                     Analog::WARNING
 369                 );
 370                 $this->flash->addMessage(
 371                     'error_detected',
 372                     $csv->getPhpErrorMessage(
 373                         $_FILES['new_file']['error']
 374                     )
 375                 );
 376             } elseif (isset($_POST['upload'])) {
 377                 $this->flash->addMessage(
 378                     'error_detected',
 379                     _T("No files has been seleted for upload!")
 380                 );
 381             }
 382         } else {
 383             $this->flash->addMessage(
 384                 'warning_detected',
 385                 _T("No files has been uploaded!")
 386             );
 387         }
 388
 389         return $response
 390             ->withStatus(301)
 391             ->withHeader('Location', $this->router->pathFor('import'));
 392     }
 393
 394     /**
 395      * Get CSV file (imports or exports)
 396      *
 397      * @param Request  $request  PSR Request
 398      * @param Response $response PSR Response
 399      * @param string   $file     File name
 400      * @param string   $type     File type
 401      *
 402      * @return Response
 403      */
 404     public function getFile(Request $request, Response $response, string $file, string $type): Response
 405     {
 406         $filename = $file;
 407
 408         //Exports main contain user confidential data, they're accessible only for
 409         //admins or staff members
 410         if ($this->login->isAdmin() || $this->login->isStaff()) {
 411             $filepath = $type === 'export' ?
 412                 CsvOut::DEFAULT_DIRECTORY : CsvIn::DEFAULT_DIRECTORY;
 413             $filepath .= $filename;
 414             return $this->sendResponse($response, $filepath, $filename);
 415         } else {
 416             Analog::log(
 417                 'A non authorized person asked to retrieve ' . $type . ' file named `' .
 418                 $filename . '`. Access has not been granted.',
 419                 Analog::WARNING
 420             );
 421             $error = $this->errorHandler;
 422             return $error(
 423                 $request,
 424                 $response->withStatus(403)
 425             );
 426         }
 427     }
 428
 429     /**
 430      * Remove CSV file confirmation (imports or exports)
 431      *
 432      * @param Request  $request  PSR Request
 433      * @param Response $response PSR Response
 434      * @param string   $file     File name
 435      * @param string   $type     File type
 436      *
 437      * @return Response
 438      */
 439     public function confirmRemoveFile(
 440         Request $request,
 441         Response $response,
 442         string $file,
 443         string $type
 444     ): Response {
 445         $data = [
 446             'type' => $type,
 447             'file' => $file,
 448             'redirect_uri'  => $this->router->pathFor($type)
 449         ];
 450
 451         // display page
 452         $this->view->render(
 453             $response,
 454             'confirm_removal.tpl',
 455             array(
 456                 'mode'          => $request->isXhr() ? 'ajax' : '',
 457                 'page_title'    => sprintf(
 458                     _T('Remove %1$s file %2$s'),
 459                     $type,
 460                     $file
 461                 ),
 462                 'form_url'      => $this->router->pathFor(
 463                     'doRemoveCsv',
 464                     [
 465                         'type' => $type,
 466                         'file' => $file
 467                     ]
 468                 ),
 469                 'cancel_uri'    => $data['redirect_uri'],
 470                 'data'          => $data
 471             )
 472         );
 473         return $response;
 474     }
 475
 476     /**
 477      * Remove CSV file (imports or exports)
 478      *
 479      * @param Request  $request  PSR Request
 480      * @param Response $response PSR Response
 481      * @param string   $file     File name
 482      * @param string   $type     File type
 483      *
 484      * @return Response
 485      */
 486     public function removeFile(Request $request, Response $response, string $file, string $type): Response
 487     {
 488         $post = $request->getParsedBody();
 489         $ajax = isset($post['ajax']) && $post['ajax'] === 'true';
 490         $success = false;
 491
 492         $uri = isset($post['redirect_uri']) ?
 493             $post['redirect_uri'] : $this->router->pathFor('slash');
 494
 495         if (!isset($post['confirm'])) {
 496             $this->flash->addMessage(
 497                 'error_detected',
 498                 _T("Removal has not been confirmed!")
 499             );
 500         } else {
 501             $csv = $type === 'export' ?
 502                 new CsvOut() : new CsvIn($this->zdb);
 503             $res = $csv->remove($file);
 504             if ($res === true) {
 505                 $success = true;
 506                 $this->flash->addMessage(
 507                     'success_detected',
 508                     str_replace(
 509                         '%export',
 510                         $file,
 511                         _T("'%export' file has been removed from disk.")
 512                     )
 513                 );
 514             } else {
 515                 $success = false;
 516                 $this->flash->addMessage(
 517                     'error_detected',
 518                     str_replace(
 519                         '%export',
 520                         $file,
 521                         _T("Cannot remove '%export' from disk :/")
 522                     )
 523                 );
 524             }
 525         }
 526
 527         if (!$ajax) {
 528             return $response
 529                 ->withStatus(301)
 530                 ->withHeader('Location', $uri);
 531         } else {
 532             return $response->withJson(
 533                 [
 534                     'success'   => $success
 535                 ]
 536             );
 537         }
 538     }
 539
 540     /**
 541      * Import model page
 542      *
 543      * @param Request  $request  PSR Request
 544      * @param Response $response PSR Response
 545      *
 546      * @return Response
 547      */
 548     public function importModel(Request $request, Response $response): Response
 549     {
 550         $model = new ImportModel();
 551         $model->load();
 552
 553         if (isset($request->getQueryParams()['remove'])) {
 554             $model->remove($this->zdb);
 555             $model->load();
 556         }
 557
 558         $csv = new CsvIn($this->zdb);
 559
 560         /** FIXME:
 561          * - set fields that should not be part of import
 562          */
 563         $fields = $model->getFields();
 564         $defaults = $csv->getDefaultFields();
 565         $defaults_loaded = false;
 566
 567         if ($fields === null) {
 568             $fields = $defaults;
 569             $defaults_loaded = true;
 570         }
 571
 572         $import_fields = $this->members_form_fields;
 573         //get dynamic fields
 574         $dynamic_import_fields = [];
 575         $fieldset = new DynamicFieldsSet($this->zdb, $this->login);
 576         $dfields = $fieldset->getList('adh');
 577         foreach ($dfields as $field) {
 578             if ($field->hasData() && !$field instanceof \Galette\DynamicFields\File) {
 579                 $dynamic_import_fields['dynfield_' . $field->getId()] = [
 580                     'label'     => __($field->getname())
 581                 ];
 582             }
 583         }
 584         //we do not want to import id_adh. Never.
 585         unset($import_fields['id_adh']);
 586         $import_fields += $dynamic_import_fields;
 587
 588         // display page
 589         $this->view->render(
 590             $response,
 591             'import_model.tpl',
 592             array(
 593                 'page_title'        => _T("CSV import model"),
 594                 'fields'            => $fields,
 595                 'model'             => $model,
 596                 'defaults'          => $defaults,
 597                 'members_fields'    => $import_fields,
 598                 'defaults_loaded'   => $defaults_loaded
 599             )
 600         );
 601         return $response;
 602     }
 603
 604     /**
 605      * Get CSV import model file
 606      *
 607      * @param Request  $request  PSR Request
 608      * @param Response $response PSR Response
 609      *
 610      * @return Response
 611      */
 612     public function getImportModel(Request $request, Response $response): Response
 613     {
 614         $model = new ImportModel();
 615         $model->load();
 616
 617         $csv = new CsvIn($this->zdb);
 618
 619         $fields = $model->getFields();
 620         $defaults = $csv->getDefaultFields();
 621         $defaults_loaded = false;
 622
 623         if ($fields === null) {
 624             $fields = $defaults;
 625             $defaults_loaded = true;
 626         }
 627
 628         $ocsv = new CsvOut();
 629         $res = $ocsv->export(
 630             $fields,
 631             Csv::DEFAULT_SEPARATOR,
 632             Csv::DEFAULT_QUOTE,
 633             $fields
 634         );
 635         $filename = _T("galette_import_model.csv");
 636
 637         $response = $response->withHeader('Content-Description', 'File Transfer')
 638             ->withHeader('Content-Type', 'text/csv')
 639             ->withHeader('Content-Disposition', 'attachment;filename="' . $filename . '"')
 640             ->withHeader('Pragma', 'no-cache')
 641             ->withHeader('Content-Transfer-Encoding', 'binary')
 642             ->withHeader('Expires', '0')
 643             ->withHeader('Cache-Control', 'must-revalidate')
 644             ->withHeader('Pragma', 'public');
 645
 646         $stream = fopen('php://memory', 'r+');
 647         fwrite($stream, $res);
 648         rewind($stream);
 649
 650         return $response->withBody(new \Slim\Http\Stream($stream));
 651     }
 652
 653     /**
 654      * Store CSV model
 655      *
 656      * @param Request  $request  PSR Request
 657      * @param Response $response PSR Response
 658      *
 659      * @return Response
 660      */
 661     public function storeModel(Request $request, Response $response): Response
 662     {
 663         $model = new ImportModel();
 664         $model->load();
 665
 666         $model->setFields($request->getParsedBody()['fields']);
 667         $res = $model->store($this->zdb);
 668         if ($res === true) {
 669             $this->flash->addMessage(
 670                 'success_detected',
 671                 _T("Import model has been successfully stored :)")
 672             );
 673         } else {
 674             $this->flash->addMessage(
 675                 'error_detected',
 676                 _T("Import model has not been stored :(")
 677             );
 678         }
 679
 680         return $response
 681             ->withStatus(301)
 682             ->withHeader('Location', $this->router->pathFor('importModel'));
 683     }
 684
 685     /**
 686      * Members CSV exports
 687      *
 688      * @param Request  $request  PSR Request
 689      * @param Response $response PSR Response
 690      *
 691      * @return Response
 692      */
 693     public function membersExport(Request $request, Response $response): Response
 694     {
 695         $post = $request->getParsedBody();
 696         $get = $request->getQueryParams();
 697
 698         $session_var = $post['session_var'] ?? $get['session_var'] ?? 'filter_members';
 699
 700         if (isset($this->session->$session_var)) {
 701             $filters = $this->session->$session_var;
 702         } else {
 703             $filters = new MembersList();
 704         }
 705
 706         $csv = new MembersCsv(
 707             $this->zdb,
 708             $this->login,
 709             $this->members_fields,
 710             $this->fields_config
 711         );
 712         $csv->exportMembers($filters);
 713
 714         $filepath = $csv->getPath();
 715         $filename = $csv->getFileName();
 716
 717         return $this->sendResponse($response, $filepath, $filename);
 718     }
 719 }