FileRef.php

<?php
/**
 * FileRef.php
 * model class for table file_refs
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * @author      André Noack <noack@data-quest.de>
 * @copyright   2016 Stud.IP Core-Group
 * @license     http://www.gnu.org/licenses/gpl-2.0.html GPL version 2
 * @category    Stud.IP
 *
 *
 * @property string id database column
 * @property string file_id database column
 * @property string folder_id database column
 * @property string user_id database column
 * @property string name database column
 * @property string downloads database column
 * @property string description database column
 * @property string license database column
 * @property string content_terms_of_use_id database column
 * @property string mkdate database column
 * @property string chdate database column
 * @property SimpleORMap file belongs_to File
 * @property SimpleORMap folder belongs_to Folder
 * @property SimpleORMap owner belongs_to User
 * @property SimpleORMap terms_of_use belongs_to ContentTermsOfUse
 */
class FileRef extends SimpleORMap implements PrivacyObject, FeedbackRange
{
    protected static function configure($config = [])
    {
        $config['db_table'] = 'file_refs';

        $config['belongs_to']['file'] = [
            'class_name'  => File::class,
            'foreign_key' => 'file_id',
        ];
        $config['belongs_to']['folder'] = [
            'class_name'  => Folder::class,
            'foreign_key' => 'folder_id',
        ];
        $config['belongs_to']['owner'] = [
            'class_name'  => User::class,
            'foreign_key' => 'user_id',
        ];

        $config['belongs_to']['terms_of_use'] = [
            'class_name' => ContentTermsOfUse::class,
            'foreign_key' => 'content_terms_of_use_id',
            'assoc_func' => 'findOrBuild'
        ];

        $config['additional_fields']['size'] = ['file', 'size'];
        $config['additional_fields']['mime_type'] = ['file', 'mime_type'];
        $config['additional_fields']['download_url']['set'] = 'setDownloadURL';
        $config['additional_fields']['download_url']['get'] = 'getDownloadURL';
        $config['additional_fields']['author_name']['get'] = 'getAuthorName';
        $config['additional_fields']['is_accessible']['get'] = 'getAccessibility';
        $config['additional_fields']['is_link']['get'] = 'isLink';
        $config['additional_fields']['foldertype']['set'] = 'setFolderType';
        $config['additional_fields']['foldertype']['get'] = 'getFolderType';

        $config['registered_callbacks']['after_delete'][] = 'cbRemoveFileIfOrphaned';
        $config['registered_callbacks']['after_delete'][] = 'cbRemoveFeedbackElements';
        $config['registered_callbacks']['before_store'][] = 'cbMakeUniqueFilename';

        parent::configure($config);
    }

    protected $folder_type;
    protected $download_url;
    public $path_to_blob;

    /**
     * This callback is called after deleting a FileRef.
     * It removes the File object that is associated with the FileRef,
     * if the File is not referenced by any other FileRef object.
     */
    public function cbRemoveFileIfOrphaned()
    {
        if (!self::countBySql('file_id = ?', [$this->file_id])) {
            File::deleteBySQL("id = ?", [$this->file_id]);
        }
    }

    /**
     * This callback is called after deleting a FileRef.
     * It removes feedback elements that are associated with the FileRef.
     */
    public function cbRemoveFeedbackElements()
    {
        FeedbackElement::deleteBySQL("range_id = ? AND range_type = 'FileRef'", [$this->id]);
    }

    /**
     * This callback is called before storing a FileRef object.
     * In case the name field is changed this callback assures that the
     * name of the FileRef is unique inside the folder where
     * the FileRef is placed.
     */
    public function cbMakeUniqueFilename()
    {
        if (isset($this->folder) && $this->isFieldDirty('name')) {
            $this->name = $this->folder->getUniqueName($this->name);
        }
        if ($this->isFieldDirty('folder_id')) {
            //We have moved the file ref. $this->folder may not work directly
            //so we have to load the folder manually:
            $folder = Folder::find($this->folder_id);
            if ($folder) {
                $this->name = $folder->getUniqueName($this->name);
            }
        }
    }

    /**
     * Overrides the usual download url that this file_ref would get by the system (sendfile.php...)
     * Use this method by cloud plugins.
     * If you set download URL to null, the normal sendfile.php will be set as default download URL.
     * @param $url : string as URL or null to set URL to sendfile.php-URL
     */
    public function setDownloadURL($field, $url) {
        $this->download_url = $url;
    }

    /**
     * Returns the download-URL for the FileRef.
     *
     * @param string $dltype The download type: 'normal', 'zip', 'force' or 'force_download'.
     *
     * @return string The URL for the FileRef.
     */
    public function getDownloadURL($dltype = 'normal')
    {
        if ($this->download_url) {
            return $this->download_url;
        }
        $mode = Config::get()->SENDFILE_LINK_MODE ?: 'normal';
        $link = [];
        $params = [];
        $type = '0';
        $file_name = $this->file->name ?: $this->name;
        $file_id = $this->id;

        switch($mode) {
            case 'rewrite':
                $link[] = 'download/';
                switch ($dltype) {
                    case 'zip':
                        $link[] = 'zip/';
                        break;
                    case 'force':
                    case 'force_download':
                        $link[] = 'force_download/';
                        break;
                    default:
                        $link[] = 'normal/';
                }
                $link[] = $type . '/' . $file_id . '/' . urlencode($file_name);
                break;
            default:
                $link[] = 'sendfile.php';
                if ($dltype == 'zip') {
                    $params['zip'] = 1;
                } elseif (in_array($dltype,  ['force_download', 'force'])) {
                    $params['force_download'] = 1;
                }
                $params['type'] = $type;
                $params['file_id'] = $file_id;
                $params['file_name'] = $file_name;
        }
        return URLHelper::getScriptURL(implode('', $link), $params);
    }

    /**
     * Returns the name of the FileRef's author.
     *
     * @return string The name of the FileRef's author.
     */
    public function getAuthorName()
    {
        if (isset($this->owner)) {
            return $this->owner->getFullName('no_title_rev');
        }
        return $this->file->author_name;
    }

    /**
     * Returns true if the file is accessible
     */
    public function getAccessibility() : bool
    {
        return (bool) $this->file->is_accessible;
    }

    /**
     * This method increments the download counter of the FileRef.
     *
     * @return int The number of rows of the file_refs table that have been altered.
     */
    public function incrementDownloadCounter()
    {
        $this->downloads += 1;
        if (!$this->isNew()) {
            $where_query = join(' AND ' , $this->getWhereQuery());
            $query = "UPDATE `{$this->db_table()}`
                      SET `downloads` = `downloads` + 1
                      WHERE {$where_query}";
            return DBManager::get()->exec($query);
        }

        return 0;
    }

    /**
     * Returns the license object for this file.
     *
     * @return Object (to be specified!)
     */
    public function getLicenseObject()
    {
        if (class_exists($this->license)) {
            return new $this->license();
        }
        throw new UnexpectedValueException("class: {$this->license} not found");
    }

    /**
     * Determines whether this FileRef is a link or not.
     * @deprecated
     * @return bool True, if the FileRef references a link, false otherwise.
     */
    public function isLink()
    {
        return false;
    }

    public function setFolderType($field, FolderType $folder_type)
    {
        $this->folder_type = $folder_type;
    }

    public function getFolderType()
    {
        if ($this->folder_type) {
            return $this->folder_type;
        } elseif($this->folder) {
            return $this->folder->getTypedFolder();
        }
    }

    /**
     * Determines if the FileRef references an image file.
     *
     * @return bool True, if the referenced file is an image file, false otherwise.
     */
    public function isImage()
    {
        return mb_strpos($this->mime_type, 'image/') === 0;
    }

    /**
     * Determines if the FileRef references an audio file.
     *
     * @return bool True, if the referenced file is an audio file, false otherwise.
     */
    public function isAudio()
    {
        return mb_strpos($this->mime_type, 'audio/') === 0;
    }


    /**
     * Determines if the FileRef references a video file.
     *
     * @return bool True, if the referenced file is a video file, false otherwise.
     */
    public function isVideo()
    {
        return mb_strpos($this->mime_type, 'video/') === 0;
    }

    /**
     * Export available data of a given user into a storage object
     * (an instance of the StoredUserData class) for that user.
     *
     * @param StoredUserData $storage object to store data into
     */
    public static function exportUserData(StoredUserData $storage)
    {
        $sorm = self::findBySQL("user_id = ?", [$storage->user_id]);
        if ($sorm) {
            $field_data = [];
            foreach ($sorm as $row) {
                $field_data[] = $row->toRawArray();
            }
            if ($field_data) {
                $storage->addTabularData(_('Dateien'), 'file_refs', $field_data);
            }
        }
    }

    /**
     * @returns FileType
     */
    public function getFileType()
    {
        $filetype = $this->file->filetype;
        if (class_exists($filetype) && is_subclass_of($filetype, 'FileType')) {
            return new $filetype($this);
        } else {
            return new UnknownFileType($this);
        }
    }

    public function getRangeName()
    {
        return $this->name;
    }

    public function getRangeIcon($role)
    {
        return FileManager::getIconForFileRef($this, $role);
    }

    public function getRangeUrl()
    {
        return 'course/files/index/' . $this->foldertype->getId();
    }

    public function getRangeCourseId()
    {
        return $this->foldertype->range_id;
    }

    public function isRangeAccessible(string $user_id = null): bool
    {
        $user_id = $user_id ?? $GLOBALS['user']->id;

        return $this->foldertype->isFileDownloadable($this->id, $user_id);
    }


    /**
     * This is a helper method to generate the SQL query for the
     * findAll and countAll methods. Relevant FileRef objects for these methods
     * can be limited by a time range and a specific course. The amount
     * and the offset of the FileRef objects to be retrieved can also be set.
     *
     * @param string $user_id The ID of the user that is used to count or
     *     retrieve FileRef objects.
     *
     * @param DateTime|null $begin The begin of the time range.
     *
     * @param DateTime|null $end The end of the time range.
     *
     * @param string $course_id The ID of the course from which FileRef objects
     *     shall be retrieved.
     *
     * @param int $file_limit The maximum amount of FileRef objects to be
     *     retrieved.
     *
     * @param int $file_offset The offset in the FileRef data from which to
     *     start retrieving objects.
     *
     * @returns mixed[] An array with two indexes:
     *     - sql: The SQL query string.
     *     - params: An array with SQL query parameters.
     */
    protected static function getAllSql($user_id, $begin = null, $end = null, $course_id = '', $file_limit = 0, $file_offset = 0)
    {
        $sql = '';
        $sql_params = [];
        if ($course_id) {
            //Limit the result for a specific course.
            $sql = 'INNER JOIN `folders`
                ON `file_refs`.`folder_id` = `folders`.`id`
                WHERE `folders`.`range_id` =  :course_id ';
            $sql_params['course_id'] = $course_id;
            if (($begin instanceof DateTime) && ($end instanceof DateTime)) {
                $sql .= 'AND `file_refs`.`chdate` BETWEEN :begin AND :end ';
                $sql_params['begin'] = $begin->getTimestamp();
                $sql_params['end'] = $end->getTimestamp();
            }
        } else {
            if ($GLOBALS['perm']->have_perm('root', $user_id)) {
                //This is easy: Get all recent files ordered by chdate.
                if (($begin instanceof DateTime) && ($end instanceof DateTime)) {
                    $sql = 'chdate BETWEEN :begin AND :end ';
                    $sql_params['begin'] = $begin->getTimestamp();
                    $sql_params['end'] = $end->getTimestamp();
                } else {
                    $sql = 'TRUE ';
                }
            } else {
                //Get the folders (all folders) of the user first and then
                //check for new files. This means getting all folders of courses
                //and institutes where the user has access to.

                $range_ids = FileManager::getRangeIdsForFolders($user_id, true);

                //Now get all file refs:
                $sql = 'INNER JOIN `folders`
                    ON `file_refs`.`folder_id` = `folders`.`id`
                    WHERE `folders`.`range_id` IN ( :range_ids ) ';
                $sql_params['range_ids'] = $range_ids;

                if (($begin instanceof DateTime) && ($end instanceof DateTime)) {
                    $sql .= 'AND `file_refs`.`chdate` BETWEEN :begin AND :end ';
                    $sql_params['begin'] = $begin->getTimestamp();
                    $sql_params['end'] = $end->getTimestamp();
                }
            }
        }
        $sql .= ' ORDER BY `file_refs`.`chdate` DESC, `file_refs`.`mkdate` DESC, `file_refs`.`name` ASC';
        if ($file_limit > 0) {
            $sql .= ' LIMIT :limit';
            $sql_params['limit'] = $file_limit;
            if ($file_offset > 0) {
                $sql .= ' OFFSET :offset';
                $sql_params['offset'] = $file_offset;
            }
        }
        return ['sql' => $sql, 'params' => $sql_params];
    }


    /**
     * This method retrieves the FileRef objects a user has access to.
     *
     * @see FileRef::getAllSql for the parameter description.
     *
     * @returns FileRef[] A list of FileRef objects.
     */
    public static function findAll($user_id, $begin = null, $end = null, $course_id = null, $file_limit = 0, $file_offset = 0)
    {
        $sql_data = self::getAllSql($user_id, $begin, $end, $course_id, $file_limit, $file_offset);
        return FileRef::findBySql($sql_data['sql'], $sql_data['params']);
    }


    /**
     * This method counts all the FileRef objects a user has access to.
     *
     * @see FileRef::getAllSql for the parameter description.
     *
     * @returns int The amount of found FileRef rows.
     */
    public static function countAll($user_id, $begin = null, $end = null, $course_id = null)
    {
        $sql_data = self::getAllSql($user_id, $begin, $end, $course_id);
        return FileRef::countBySql($sql_data['sql'], $sql_data['params']);
    }


    /**
     * This is a helper method to generate the SQL query for the
     * findPublicFiles and countPublicFiles methods. Relevant FileRef objects
     * for these methods can be limited by a time range. The amount
     * and the offset of the FileRef objects to be retrieved can also be set.
     *
     * @param string $user_id The ID of the user that is used to count or
     *     retrieve FileRef objects in public folders.
     *
     * @param DateTime|null $begin The begin of the time range.
     *
     * @param DateTime|null $end The end of the time range.
     *
     * @param int $file_limit The maximum amount of FileRef objects to be
     *     retrieved from public folders.
     *
     * @param int $file_offset The offset in the FileRef data from which to
     *     start retrieving objects from public folders.
     *
     * @returns mixed[] An array with two indexes:
     *     - sql: The SQL query string.
     *     - params: An array with SQL query parameters.
     */
    protected static function getPublicFilesSql($user_id, $begin = null, $end = null, $file_limit = 0, $file_offset = 0)
    {
        $sql = "INNER JOIN `folders`
            ON `file_refs`.`folder_id` = `folders`.`id`
            WHERE `folders`.`folder_type` = 'PublicFolder'
            AND `folders`.`range_type` = 'user' ";
        $sql_params = [];
        if ($user_id) {
            $sql .= " AND `folders`.`range_id` = :user_id";
            $sql_params['user_id'] = $user_id;
        }
        if (($begin instanceof DateTime) && ($end instanceof DateTime)) {
            $sql .= ' AND `file_refs`.`chdate` BETWEEN :begin AND :end';
            $sql_params['begin'] = $begin->getTimestamp();
            $sql_params['end'] = $end->getTimestamp();
        }
        $sql .= " ORDER BY `file_refs`.`chdate` DESC";
        if ($file_limit > 0) {
            $sql .= " LIMIT :file_limit";
            $sql_params['file_limit'] = $file_limit;
        }
        if ($file_offset > 0) {
            $sql .= " OFFSET :file_offset";
            $sql_params['file_offset'] = $file_offset;
        }
        return ['sql' => $sql, 'params' => $sql_params];
    }


    /**
     * This method retrieves the FileRef objects in public folders which
     * can be accessed by a user.
     *
     * @see FileRef::getPublicFilesSql for the parameter description.
     *
     * @returns FileRef[] A list of FileRef objects.
     */
    public static function findPublicFiles($user_id, $begin = null, $end = null, $file_limit = 0, $file_offset = 0)
    {
        $sql_data = self::getPublicFilesSql($user_id, $begin, $end, $file_limit, $file_offset);
        return self::findBySql($sql_data['sql'], $sql_data['params']);
    }


    /**
     * This method counts the FileRef objects in public folders which
     * can be accessed by a user.
     *
     * @see FileRef::getPublicFilesSql for the parameter description.
     *
     * @returns int The amount of found FileRef rows.
     */
    public static function countPublicFiles($user_id, $begin = null, $end = null)
    {
        $sql_data = self::getPublicFilesSql($user_id, $begin, $end);
        return self::countBySql($sql_data['sql'], $sql_data['params']);
    }


    /**
     * This is a helper method to generate the SQL query for the
     * findUploadedFiles and countUploadedFiles methods. Relevant FileRef
     * objects for these methods can be limited by a time range and a specified
     * course. Furthermore, it is possible to limit the search to FileRef
     * objects without a license set or with the "unknown" license set.
     * The amount and the offset of the FileRef objects to be retrieved can also
     * be set.
     *
     * @param string $user_id The ID of the user whose uploaded files shall be
     *     retrieved or counted.
     *
     * @param DateTime|null $begin The begin of the time range.
     *
     * @param DateTime|null $end The end of the time range.
     *
     * @param string $course_id The ID of the course from which FileRef objects
     *     shall be retrieved.
     *
     * @param bool $unknown_license_only Whether to only query for FileRef
     *     objects without a license or with the "unknown" license set
     *     (true) or to query all uploaded FileRef objects (false).
     *     Defaults to false.
     *
     * @param int $file_limit The maximum amount of FileRef objects to be
     *     retrieved from public folders.
     *
     * @param int $file_offset The offset in the FileRef data from which to
     *     start retrieving objects from public folders.
     *
     * @returns mixed[] An array with two indexes:
     *     - sql: The SQL query string.
     *     - params: An array with SQL query parameters.
     */
    protected static function getUploadedFilesSql($user_id, $begin = null, $end = null, $course_id = '', $unknown_license_only = false, $file_limit = 0, $file_offset = 0)
    {
        $sql = '';
        if ($course_id) {
            $sql = 'INNER JOIN `folders`
                ON `file_refs`.`folder_id` = `folders`.`id`
                WHERE ';
        }
        $sql .= "`file_refs`.`user_id` = :user_id";
        $sql_params = [
            'user_id' => $user_id
        ];
        if ($unknown_license_only) {
            $sql .= " AND (
                `file_refs`.`content_terms_of_use_id` IN ('', 'UNDEF_LICENSE')
                OR
                `file_refs`.`content_terms_of_use_id` IS NULL
            )";
        }

        if (($begin instanceof DateTime) && ($end instanceof DateTime)) {
            $active_sidebar_filters[] = 'course';
            $sql .= ' AND `file_refs`.`chdate` BETWEEN :begin AND :end ';
            $sql_params['begin'] = $begin->getTimestamp();
            $sql_params['end'] = $end->getTimestamp();
        }
        if ($course_id) {
            $sql .= ' AND `folders`.`range_id` = :course_id';
            $sql_params['course_id'] = $course_id;
        }
        $sql .= " ORDER BY `file_refs`.`chdate` DESC";
        if ($file_limit > 0) {
            $sql .= " LIMIT :file_limit";
            $sql_params['file_limit'] = $file_limit;
        }
        if ($file_offset > 0) {
            $sql .= " OFFSET :file_offset";
            $sql_params['file_offset'] = $file_offset;
        }
        return ['sql' => $sql, 'params' => $sql_params];
    }


    /**
     * Retrieves all uploaded files a user has uploaded.
     *
     * @see FileRef::getUploadedFilesSql for the parameter description.
     *
     * @returns FileRef[] A list of FileRef objects for files the user uploaded.
     */
    public static function findUploadedFiles($user_id, $begin = null, $end = null, $course_id = '', $unknown_license_only = false, $file_limit = 0, $file_offset = 0)
    {
        $sql_data = self::getUploadedFilesSql($user_id, $begin, $end, $course_id, $unknown_license_only, $file_limit, $file_offset);
        return self::findBySql($sql_data['sql'], $sql_data['params']);
    }


    /**
     * Counts all uploaded files a user has uploaded.
     *
     * @see FileRef::getUploadedFilesSql for the parameter description.
     *
     * @returns int The amount of files the user uploaded.
     */
    public static function countUploadedFiles($user_id, $begin = null, $end = null, $course_id = '', $unknown_license_only = false)
    {
        $sql_data = self::getUploadedFilesSql($user_id, $begin, $end, $course_id, $unknown_license_only);
        return self::countBySql($sql_data['sql'], $sql_data['params']);
    }
}