class.ilObjFile.php

Go to the documentation of this file.

<?php
use ILIAS\DI\Container;
use ILIAS\File\Sanitation\FilePathSanitizer;
use ILIAS\Filesystem\Stream\FileStream;
use ILIAS\FileUpload\DTO\UploadResult;
use ILIAS\ResourceStorage\Revision\Revision;
use ILIAS\ResourceStorage\Identification\ResourceIdentification;
use ILIAS\ResourceStorage\Policy\FileNamePolicyException;

class ilObjFile extends ilObject2 implements ilObjFileImplementationInterface
{
    use ilObjFileMetadata;
    use ilObjFileUsages;
    use ilObjFilePreviewHandler;
    use ilObjFileNews;
    use ilObjFileSecureString;

    public const MODE_FILELIST = "filelist";
    public const MODE_OBJECT = "object";

    protected $implementation;

    protected $page_count = 0;
    protected $rating = false;
    protected $log;

    // ABSTRACT
    protected $filename = '';
    protected $filetype = '';
    protected $filesize;
    protected $version = 1;
    protected $max_version = 1;
    protected $action;
    // ABSTRACT

    protected $resource_id;

    public $mode = self::MODE_OBJECT;
    protected $manager;
    protected $upload;
    protected $stakeholder;

    public function __construct(int $a_id = 0, bool $a_call_by_reference = true)
    {
        global $DIC;
        $this->manager = $DIC->resourceStorage()->manage();
        $this->stakeholder = new ilObjFileStakeholder($DIC->user()->getId());
        $this->upload = $DIC->upload();
        $this->version = 0;
        $this->max_version = 0;
        $this->log = ilLoggerFactory::getLogger('file');

        parent::__construct($a_id, $a_call_by_reference);
    }

    protected function initImplementation() : void
    {
        if ($this->resource_id && ($id = $this->manager->find($this->resource_id)) !== null) {
            $resource = $this->manager->getResource($id);
            $this->implementation = new ilObjFileImplementationStorage(
                $resource,
                (int) $this->getId()
            );
            $this->setMaxVersion($resource->getMaxRevision());
            $this->setVersion($resource->getMaxRevision());
        } else {
            $this->implementation = new ilObjFileImplementationLegacy(
                (int) $this->getId(),
                (int) $this->getVersion(),
                (string) $this->getFileName()
            );
            $s = new FilePathSanitizer($this);
            $s->sanitizeIfNeeded();
        }
    }

    private function updateObjectFromRevision(Revision $r, bool $create_previews = true) : void
    {
        $this->setTitle($r->getTitle());
        $this->setFileName($r->getInformation()->getTitle());
        $this->setVersion($r->getVersionNumber());
        $this->setMaxVersion($r->getVersionNumber());
        $this->setFileSize($r->getInformation()->getSize());
        $this->setFileType($r->getInformation()->getMimeType());
        $this->update();
        if ($create_previews) {
            $this->createPreview(true);
        }
    }

    private function appendSuffixToTitle(string $title, string $filename) : string
    {
        // bugfix mantis 0026160 && 0030391 and 0032340
        $title_info = new SplFileInfo($title);
        $filename_info = new SplFileInfo($filename);

        $filename = str_replace('.' . $title_info->getExtension(), '', $title_info->getPathname());
        $extension = $filename_info->getExtension();

        return $this->secure($filename . '.' . $extension);
    }

    public function appendStream(FileStream $stream, string $title) : int
    {
        if ($this->getResourceId() && $i = $this->manager->find($this->getResourceId())) {
            $revision = $this->manager->appendNewRevisionFromStream($i, $stream, $this->stakeholder, $title);
        } else {
            $i = $this->manager->stream($stream, $this->stakeholder, $title);
            $revision = $this->manager->getCurrentRevision($i);
            $this->setResourceId($i->serialize());
            $this->initImplementation();
        }
        $this->updateObjectFromRevision($revision);

        return $revision->getVersionNumber();
    }

    public function appendUpload(UploadResult $result, string $title) : int
    {
        $title = $this->appendSuffixToTitle($title, $result->getName());
        if ($this->getResourceId() && $i = $this->manager->find($this->getResourceId())) {
            $revision = $this->manager->appendNewRevision($i, $result, $this->stakeholder, $title);
        } else {
            $i = $this->manager->upload($result, $this->stakeholder, $title);
            $revision = $this->manager->getCurrentRevision($i);
            $this->setResourceId($i->serialize());
            $this->initImplementation();
        }
        if ($result->getMetaData()->has(ilCountPDFPagesPreProcessors::PAGE_COUNT)) {
            $this->setPageCount($result->getMetaData()->get(ilCountPDFPagesPreProcessors::PAGE_COUNT));
        }
        $this->updateObjectFromRevision($revision);

        return $revision->getVersionNumber();
    }

    public function replaceWithStream(FileStream $stream, string $title) : int
    {
        if ($this->getResourceId() && $i = $this->manager->find($this->getResourceId())) {
            $revision = $this->manager->replaceWithStream($i, $stream, $this->stakeholder, $title);
        } else {
            throw new LogicException('only files with existing resource and revision can be replaced');
        }
        $this->updateObjectFromRevision($revision);

        return $revision->getVersionNumber();
    }

    public function replaceWithUpload(UploadResult $result, string $title) : int
    {
        $title = $this->appendSuffixToTitle($title, $result->getName());
        if ($this->getResourceId() && $i = $this->manager->find($this->getResourceId())) {
            $revision = $this->manager->replaceWithUpload($i, $result, $this->stakeholder, $title);
        } else {
            throw new LogicException('only files with existing resource and revision can be replaced');
        }
        if ($result->getMetaData()->has(ilCountPDFPagesPreProcessors::PAGE_COUNT)) {
            $this->setPageCount($result->getMetaData()->get(ilCountPDFPagesPreProcessors::PAGE_COUNT));
        }
        $this->updateObjectFromRevision($revision);

        return $revision->getVersionNumber();
    }

    public function getFile($a_hist_entry_id = null)
    {
        return $this->implementation->getFile($a_hist_entry_id);
    }

    public function getDirectory($a_version = 0)
    {
        return $this->implementation->getDirectory($a_version);
    }

    public function getVersion()
    {
        return $this->version;
    }

    public function setVersion($a_version)
    {
        $this->version = $a_version;
    }

    public function getFileName()
    {
        return $this->filename;
    }

    public function setFileName($a_name)
    {
        $this->filename = $a_name;
    }

    public function setRating($a_value)
    {
        $this->rating = (bool) $a_value;
    }

    public function setResourceId(?string $resource_id) : ilObjFile
    {
        $this->resource_id = $resource_id;
        return $this;
    }

    public function getResourceId() : ?string
    {
        return $this->resource_id ?? '-';
    }

    public function getStorageID() : ?string
    {
        return $this->implementation->getStorageID();
    }

    public function getMode()
    {
        return $this->mode;
    }

    public function setMode($a_mode)
    {
        $this->mode = $a_mode;
    }

    public function getFileSize()
    {
        return $this->filesize;
    }

    public function setFileSize($a_size)
    {
        $this->filesize = $a_size;
    }

    public function getFileType()
    {
        return $this->filetype;
    }

    public function setFileType($a_type)
    {
        $this->filetype = $a_type;
    }

    public function hasRating()
    {
        return $this->rating;
    }

    public function getMaxVersion()
    {
        return $this->max_version;
    }

    public function setMaxVersion($a_max_version)
    {
        $this->max_version = $a_max_version;
    }

    public function getPageCount()
    {
        return $this->page_count;
    }

    public function setPageCount($page_count)
    {
        $this->page_count = $page_count;
    }

    public function getAction()
    {
        return $this->action;
    }

    public function setAction($a_action)
    {
        $this->action = $a_action;
    }

    public function handleChangedObjectTitle(string $new_title)
    {
        $this->setTitle($new_title);
        $this->implementation->handleChangedObjectTitle($new_title);
    }


    // CRUD

    protected function doCreate($a_upload = false)
    {
        $this->createProperties($a_upload);
        $this->notifyCreation($this->getId(), $this->getDescription());
    }

    protected function doRead()
    {
        global $DIC;
        $q = "SELECT * FROM file_data WHERE file_id = %s";
        $r = $DIC->database()->queryF($q, ['integer'], [$this->getId()]);
        $row = $r->fetchObject();

        $this->setFileName($this->secure($row->file_name ?? ''));
        $this->setFileType($row->file_type);
        $this->setFileSize($row->file_size);
        $this->setVersion($row->version ? $row->version : 1);
        $this->setMaxVersion($row->max_version ? $row->max_version : 1);
        $this->setMode($row->f_mode);
        $this->setRating($row->rating);
        $this->setPageCount($row->page_count);
        $this->setPageCount($row->page_count);
        $this->setResourceId($row->rid);

        $this->initImplementation();
    }

    protected function doCloneObject($new_object, $a_target_id, $a_copy_id = 0)
    {
        $this->cloneMetaData($new_object);

        // object created now copy other settings
        $this->db->manipulateF(
            "INSERT INTO file_data (file_id, file_name, file_type, file_size, version, rating, f_mode) VALUES (%s, %s, %s, %s, %s, %s, %s)",
            [
                'integer', // file_id
                'text', // file_name
                'text', // file_type
                'integer', // file_size
                'integer', // version
                'integer', // rating
                'integer' // f_mode
            ],
            [
                (int) $new_object->getId(),
                $this->getFileName(),
                $this->getFileType(),
                (int) $this->getFileSize(),
                (int) $this->getVersion(),
                (int) $this->hasRating(),
                (int) $this->getMode()
            ]
        );

        // Copy Resource
        if ($this->resource_id
            && ($identification = $this->manager->find($this->resource_id)) instanceof ResourceIdentification) {
            $new_resource_identification = $this->manager->clone($identification);
            $new_current_revision = $this->manager->getCurrentRevision($new_resource_identification);
            $new_object->setResourceId($new_resource_identification->serialize());
            $new_object->initImplementation();
            $new_object->updateObjectFromRevision($new_current_revision, false); // Previews are already copied in 453
            $new_object->setTitle($this->getTitle()); // see https://mantis.ilias.de/view.php?id=31375
            $new_object->update();
        } else {
            // migrate
            global $DIC;
            $migration = new ilFileObjectToStorageMigrationRunner(
                $DIC->fileSystem()->storage(),
                $DIC->database(),
                rtrim(CLIENT_DATA_DIR, "/") . '/ilFile/migration_log.csv'
            );
            $migration->setMigrateToNewObjectId((int) $new_object->getId());
            $migration->migrate(new ilFileObjectToStorageDirectory($this->getId(), $this->getDirectory()));
        }

        // copy all previews
        ilPreview::copyPreviews($this->getId(), $new_object->getId());

        // Copy learning progress settings
        $obj_settings = new ilLPObjSettings($this->getId());
        $obj_settings->cloneSettings($new_object->getId());
        unset($obj_settings);

        return $new_object;
    }

    protected function doUpdate()
    {
        global $DIC;

        $a_columns = $this->getArrayForDatabase();
        $DIC->database()->update('file_data', $a_columns, [
            'file_id' => [
                'integer',
                $this->getId(),
            ],
        ]);

        // update metadata with the current file version
        $meta_version_column = ['meta_version' => ['integer', (int) $this->getVersion()]];
        $DIC->database()->update('il_meta_lifecycle', $meta_version_column, [
            'rbac_id' => [
                'integer',
                $this->getId(),
            ],
        ]);

        $this->notifyUpdate($this->getId(), $this->getDescription());

        return true;
    }

    protected function beforeUpdate()
    {
        // no meta data handling for file list files
        if ($this->getMode() != self::MODE_FILELIST) {
            $this->updateMetaData();
        }

        return true;
    }

    protected function beforeDelete()
    {
        // check, if file is used somewhere
        $usages = $this->getUsages();
        if (count($usages) == 0) {
            return true;
        }

        return false;
    }

    protected function doDelete()
    {
        global $DIC;

        // delete file data entry
        $DIC->database()->manipulateF("DELETE FROM file_data WHERE file_id = %s", ['integer'], [$this->getId()]);

        // delete history entries
        ilHistory::_removeEntriesForObject($this->getId());

        // delete meta data
        if ($this->getMode() != self::MODE_FILELIST) {
            $this->deleteMetaData();
        }

        // delete preview
        $this->deletePreview();

        // delete resource
        $identification = $this->getResourceId();
        if ($identification && $identification != '-') {
            $resource = $this->manager->find($identification);
            if ($resource !== null) {
                $this->manager->remove($resource, $this->stakeholder);
            }
        }
    }

    private function getArrayForDatabase() : array
    {
        return [
            'file_id' => ['integer', $this->getId()],
            'file_name' => ['text', $this->getFileName()],
            'file_type' => ['text', $this->getFileType()],
            'file_size' => ['integer', (int) $this->getFileSize()],
            'version' => ['integer', (int) $this->getVersion()],
            'max_version' => ['integer', (int) $this->getMaxVersion()],
            'f_mode' => ['text', $this->getMode()],
            'page_count' => ['text', $this->getPageCount()],
            'rating' => ['integer', $this->hasRating()],
            'rid' => ['text', $this->resource_id ?? ''],
        ];
    }

    public function initType()
    {
        $this->type = "file";
    }

    public function createDirectory()
    {
        // we no longer create directories
    }

    public function raiseUploadError($raise = false)
    {
        // we no longer support that
    }

    // Upload Handling
    public function replaceFile($a_upload_file, $a_filename)
    {
        return null;
    }

    private function prepareUpload() : void
    {
        if (true !== $this->upload->hasBeenProcessed()) {
            if (defined('PATH_TO_GHOSTSCRIPT') && PATH_TO_GHOSTSCRIPT !== "") {
                $this->upload->register(new ilCountPDFPagesPreProcessors());
            }

            $this->upload->process();
        }
    }

    public function getUploadFile($a_upload_file, string $title, bool $a_prevent_preview = false) : bool
    {
        $this->prepareUpload();

        $results = $this->upload->getResults();
        $upload = $results[$a_upload_file];

        $this->appendUpload($upload, $title);

        return true;
    }

    public function isHidden()
    {
        return ilObjFileAccess::_isFileHidden($this->getTitle());
    }

    public function clearDataDirectory()
    {
        $this->implementation->clearDataDirectory();
    }

    public function deleteVersions($a_hist_entry_ids = null)
    {
        $this->implementation->deleteVersions($a_hist_entry_ids);
    }

    public function sendFile($a_hist_entry_id = null) : void
    {
        $this->implementation->sendFile($a_hist_entry_id);
    }

    public function isInline()
    {
        return ilObjFileAccess::_isFileInline($this->getTitle());
    }

    public function export(string $target_dir) : void
    {
        $this->implementation->export($target_dir);
    }

    public function storeUnzipedFile($a_upload_file, $a_filename)
    {
        $this->setVersion($this->getVersion() + 1);

        if (@!is_dir($this->getDirectory($this->getVersion()))) {
            ilUtil::makeDir($this->getDirectory($this->getVersion()));
        }

        $file = $this->getDirectory($this->getVersion()) . "/" . $a_filename;

        $file = ilFileUtils::getValidFilename($file);

        ilFileUtils::rename($a_upload_file, $file);

        // create preview
        $this->createPreview();
    }

    public function getVersions($version_ids = null) : array
    {
        return $this->implementation->getVersions($version_ids);
    }

    public function rollback(int $version_id) : void
    {
        if ($this->getResourceId() && $i = $this->manager->find($this->getResourceId())) {
            $this->manager->rollbackRevision($i, $version_id);
            $latest_revision = $this->manager->getCurrentRevision($i);
            $this->updateObjectFromRevision($latest_revision);
        } else {
            throw new LogicException('only files with existing resource and revision can be replaced');
        }
    }

    public function checkFileExtension($new_filename, $new_title)
    {
        $fileExtension = ilObjFileAccess::_getFileExtension($new_filename);
        $titleExtension = ilObjFileAccess::_getFileExtension($new_title);
        if ($titleExtension != $fileExtension && strlen($fileExtension) > 0) {
            // remove old extension
            $pi = pathinfo($this->getFileName());
            $suffix = $pi["extension"];
            if ($suffix != "") {
                if (substr($new_title, strlen($new_title) - strlen($suffix) - 1) == "." . $suffix) {
                    $new_title = substr($new_title, 0, strlen($new_title) - strlen($suffix) - 1);
                }
            }
            $new_title .= '.' . $fileExtension;
        }

        return $new_title;
    }

    public function getFileExtension()
    {
        return $this->implementation->getFileExtension();
    }
}