files/classes/conversion.php

   1 <?php
   2 // This file is part of Moodle - http://moodle.org/
   3 //
   4 // Moodle is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // Moodle is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 /**
  18  * Classes for converting files between different file formats.
  19  *
  20  * @package    core_files
  21  * @copyright  2017 Andrew Nicols <andrew@nicols.co.uk>
  22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23  */
  24 namespace core_files;
  25
  26 defined('MOODLE_INTERNAL') || die();
  27
  28 use stored_file;
  29
  30 /**
  31  * Class representing a conversion currently in progress.
  32  *
  33  * @package    core_files
  34  * @copyright  2017 Andrew Nicols <andrew@nicols.co.uk>
  35  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  36  */
  37 class conversion extends \core\persistent {
  38
  39     /**
  40      * Status value representing a conversion waiting to start.
  41      */
  42     const STATUS_PENDING = 0;
  43
  44     /**
  45      * Status value representing a conversion in progress.
  46      */
  47     const STATUS_IN_PROGRESS = 1;
  48
  49     /**
  50      * Status value representing a successful conversion.
  51      */
  52     const STATUS_COMPLETE = 2;
  53
  54     /**
  55      * Status value representing a failed conversion.
  56      */
  57     const STATUS_FAILED = -1;
  58
  59     /**
  60      * Table name for this persistent.
  61      */
  62     const TABLE = 'file_conversion';
  63
  64     /**
  65      * Define properties.
  66      *
  67      * @return array
  68      */
  69     protected static function define_properties() {
  70         return array(
  71             'sourcefileid' => [
  72                 'type' => PARAM_INT,
  73             ],
  74             'targetformat' => [
  75                 'type' => PARAM_ALPHANUMEXT,
  76             ],
  77             'status' => [
  78                 'type' => PARAM_INT,
  79                 'choices' => [
  80                     self::STATUS_PENDING,
  81                     self::STATUS_IN_PROGRESS,
  82                     self::STATUS_COMPLETE,
  83                     self::STATUS_FAILED,
  84                 ],
  85                 'default' => self::STATUS_PENDING,
  86             ],
  87             'statusmessage' => [
  88                 'type' => PARAM_RAW,
  89                 'null' => NULL_ALLOWED,
  90                 'default' => null,
  91             ],
  92             'converter' => [
  93                 'type' => PARAM_RAW,
  94                 'null' => NULL_ALLOWED,
  95                 'default' => null,
  96             ],
  97             'destfileid' => [
  98                 'type' => PARAM_INT,
  99                 'null' => NULL_ALLOWED,
 100                 'default' => null,
 101             ],
 102             'data' => [
 103                 'type' => PARAM_RAW,
 104                 'null' => NULL_ALLOWED,
 105                 'default' => null,
 106             ],
 107         );
 108     }
 109
 110     /**
 111      * Fetch all conversions relating to the specified file.
 112      *
 113      * Only conversions which have a valid file are returned.
 114      *
 115      * @param   stored_file $file The source file being converted
 116      * @param   string $format The targetforamt to filter to
 117      * @return  conversion[]
 118      */
 119     public static function get_conversions_for_file(stored_file $file, $format) {
 120         global $DB;
 121         $instances = [];
 122
 123         // Conversion records are intended for tracking a conversion in progress or recently completed.
 124         // The record is removed periodically, but the destination file is not.
 125         // We need to fetch all conversion records which match the source file and target, and also all source and
 126         // destination files which do not have a conversion record.
 127         $sqlfields = self::get_sql_fields('c', 'conversion');
 128
 129         // Fetch actual conversions which relate to the specified source file, and have a matching conversion record,
 130         // and either have a valid destination file which still exists, or do not have a destination file at all.
 131         $sql = "SELECT {$sqlfields}
 132                 FROM {" . self::TABLE . "} c
 133                 INNER JOIN {files} conversionsourcefile ON conversionsourcefile.id = c.sourcefileid
 134                 LEFT JOIN {files} conversiondestfile ON conversiondestfile.id = c.destfileid
 135                 WHERE
 136                     conversionsourcefile.contenthash = :ccontenthash
 137                 AND c.targetformat = :cformat
 138                 AND (
 139                     c.destfileid IS NULL OR conversiondestfile.id IS NOT NULL
 140                 )";
 141
 142         // Fetch a empty conversion record for each source/destination combination that we find to match where the
 143         // destination file is in the correct filearea/filepath/filename combination to meet the requirements.
 144         // This ensures that existing conversions are used where possible, even if there is no 'conversion' record for
 145         // them.
 146         $sql .= "
 147             UNION ALL
 148                 SELECT
 149                     NULL AS conversionid,
 150                     orphanedsourcefile.id AS conversionsourcefileid,
 151                     :oformat AS conversiontargetformat,
 152                     2 AS conversionstatus,
 153                     NULL AS conversionstatusmessage,
 154                     NULL AS conversionconverter,
 155                     orphaneddestfile.id AS conversiondestfileid,
 156                     NULL AS conversiondata,
 157                     0 AS conversiontimecreated,
 158                     0 AS conversiontimemodified,
 159                     0 AS conversionusermodified
 160                 FROM {files} orphanedsourcefile
 161                 INNER JOIN {files} orphaneddestfile ON (
 162                         orphaneddestfile.filename = orphanedsourcefile.contenthash
 163                     AND orphaneddestfile.component = 'core'
 164                     AND orphaneddestfile.filearea = 'documentconversion'
 165                     AND orphaneddestfile.filepath = :ofilepath
 166                 )
 167                 LEFT JOIN {" . self::TABLE . "} orphanedconversion ON orphanedconversion.destfileid = orphaneddestfile.id
 168                 WHERE
 169                     orphanedconversion.id IS NULL
 170                 AND
 171                     orphanedsourcefile.id = :osourcefileid
 172                 ";
 173         $records = $DB->get_records_sql($sql, [
 174             'ccontenthash' => $file->get_contenthash(),
 175             'osourcefileid' => $file->get_id(),
 176             'cfilepath' => "/{$format}/",
 177             'ofilepath' => "/{$format}/",
 178             'cformat' => $format,
 179             'oformat' => $format,
 180         ]);
 181
 182         foreach ($records as $record) {
 183             $data = self::extract_record($record, 'conversion');
 184             $newrecord = new static(0, $data);
 185             $instances[] = $newrecord;
 186         }
 187
 188         return $instances;
 189     }
 190
 191     /**
 192      * Remove all old conversion records.
 193      */
 194     public static function remove_old_conversion_records() {
 195         global $DB;
 196
 197         $DB->delete_records_select(self::TABLE, 'timemodified <= :weekagosecs', [
 198             'weekagosecs' => time() - WEEKSECS,
 199         ]);
 200     }
 201
 202     /**
 203      * Remove orphan records.
 204      *
 205      * Records are considered orphans when their source file not longer exists.
 206      * In this scenario we do not want to keep the converted file any longer,
 207      * in particular to be compliant with privacy laws.
 208      */
 209     public static function remove_orphan_records() {
 210         global $DB;
 211
 212         $sql = "
 213             SELECT c.id
 214               FROM {" . self::TABLE . "} c
 215          LEFT JOIN {files} f
 216                 ON f.id = c.sourcefileid
 217              WHERE f.id IS NULL";
 218         $ids = $DB->get_fieldset_sql($sql, []);
 219
 220         if (empty($ids)) {
 221             return;
 222         }
 223
 224         list($insql, $inparams) = $DB->get_in_or_equal($ids, SQL_PARAMS_NAMED);
 225         $DB->delete_records_select(self::TABLE, "id $insql", $inparams);
 226     }
 227
 228     /**
 229      * Set the source file id for the conversion.
 230      *
 231      * @param   stored_file $file The file to convert
 232      * @return  $this
 233      */
 234     public function set_sourcefile(stored_file $file) {
 235         $this->raw_set('sourcefileid', $file->get_id());
 236
 237         return $this;
 238     }
 239
 240     /**
 241      * Fetch the source file.
 242      *
 243      * @return  stored_file|false The source file
 244      */
 245     public function get_sourcefile() {
 246         $fs = get_file_storage();
 247
 248         return $fs->get_file_by_id($this->get('sourcefileid'));
 249     }
 250
 251     /**
 252      * Set the destination file for this conversion.
 253      *
 254      * @param   string $filepath The path to the converted file
 255      * @return  $this
 256      */
 257     public function store_destfile_from_path($filepath) {
 258         if ($record = $this->get_file_record()) {
 259             $fs = get_file_storage();
 260             $existing = $fs->get_file(
 261                 $record['contextid'],
 262                 $record['component'],
 263                 $record['filearea'],
 264                 $record['itemid'],
 265                 $record['filepath'],
 266                 $record['filename']
 267             );
 268             if ($existing) {
 269                 $existing->delete();
 270             }
 271             $file = $fs->create_file_from_pathname($record, $filepath);
 272
 273             $this->raw_set('destfileid', $file->get_id());
 274         }
 275
 276         return $this;
 277     }
 278
 279     /**
 280      * Set the destination file for this conversion.
 281      *
 282      * @param   string $content The content of the converted file
 283      * @return  $this
 284      */
 285     public function store_destfile_from_string($content) {
 286         if ($record = $this->get_file_record()) {
 287             $fs = get_file_storage();
 288             $existing = $fs->get_file(
 289                 $record['contextid'],
 290                 $record['component'],
 291                 $record['filearea'],
 292                 $record['itemid'],
 293                 $record['filepath'],
 294                 $record['filename']
 295             );
 296             if ($existing) {
 297                 $existing->delete();
 298             }
 299             $file = $fs->create_file_from_string($record, $content);
 300
 301             $this->raw_set('destfileid', $file->get_id());
 302         }
 303
 304         return $this;
 305     }
 306
 307     /**
 308      * Get the destination file.
 309      *
 310      * @return  stored_file|bool Destination file
 311      */
 312     public function get_destfile() {
 313         $fs = get_file_storage();
 314
 315         return $fs->get_file_by_id($this->get('destfileid'));
 316     }
 317
 318     /**
 319      * Helper to ensure that the returned status is always an int.
 320      *
 321      * @return  int status
 322      */
 323     protected function get_status() {
 324         return (int) $this->raw_get('status');
 325     }
 326
 327     /**
 328      * Get an instance of the current converter.
 329      *
 330      * @return  converter_interface|false current converter instance
 331      */
 332     public function get_converter_instance() {
 333         $currentconverter = $this->get('converter');
 334
 335         if ($currentconverter && class_exists($currentconverter)) {
 336             return new $currentconverter();
 337         } else {
 338             return false;
 339         }
 340     }
 341
 342     /**
 343      * Transform data into a storable format.
 344      *
 345      * @param   \stdClass $data The data to be stored
 346      * @return  $this
 347      */
 348     protected function set_data($data) {
 349         $this->raw_set('data', json_encode($data));
 350
 351         return $this;
 352     }
 353
 354     /**
 355      * Transform data into a storable format.
 356      *
 357      * @return  \stdClass The stored data
 358      */
 359     protected function get_data() {
 360         $data = $this->raw_get('data');
 361
 362         if (!empty($data)) {
 363             return json_decode($data);
 364         }
 365
 366         return (object) [];
 367     }
 368
 369     /**
 370      * Return the file record base for use in the files table.
 371      *
 372      * @return  array|bool
 373      */
 374     protected function get_file_record() {
 375         $file = $this->get_sourcefile();
 376
 377         if (!$file) {
 378             // If the source file was removed before we completed, we must return early.
 379             return false;
 380         }
 381
 382         return [
 383             'contextid' => \context_system::instance()->id,
 384             'component' => 'core',
 385             'filearea'  => 'documentconversion',
 386             'itemid'    => 0,
 387             'filepath'  => "/" . $this->get('targetformat') . "/",
 388             'filename'  => $file->get_contenthash(),
 389         ];
 390     }
 391 }