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