ElggFile.php

Go to the documentation of this file.

<?php
 
use Elgg\Filesystem\MimeTypeDetector;
use Symfony\Component\HttpFoundation\File\Exception\FileException;
use Symfony\Component\HttpFoundation\File\UploadedFile;
 
class ElggFile extends ElggObject {
 
    private $filestore;
 
    private $handle;
 
    protected function initializeAttributes() {
        parent::initializeAttributes();
 
        $this->attributes['subtype'] = "file";
    }
 
    public function getMetadata($name) {
        if (0 === strpos($name, 'filestore::')) {
            elgg_deprecated_notice("Do not access the ElggFile filestore metadata directly. Use setFilestore().", '2.0');
        }
        return parent::getMetadata($name);
    }
 
    public function setMetadata($name, $value, $value_type = '', $multiple = false, $owner_guid = 0, $access_id = null) {
        if (0 === strpos($name, 'filestore::')) {
            elgg_deprecated_notice("Do not access the ElggFile filestore metadata directly. Use setFilestore().", '2.0');
        }
        return parent::setMetadata($name, $value, $value_type, $multiple, $owner_guid, $access_id);
    }
 
    public function setFilename($name) {
        $this->filename = $name;
    }
 
    public function getFilename() {
        return $this->filename;
    }
 
    public function getFilenameOnFilestore() {
        return $this->getFilestore()->getFilenameOnFilestore($this);
    }
 
    public function getFilestoreSize($prefix = '', $container_guid = 0) {
        if (!$container_guid) {
            $container_guid = $this->container_guid;
        }
        $fs = $this->getFilestore();
        // @todo add getSize() to \ElggFilestore
        return $fs->getSize($prefix, $container_guid);
    }
 
    public function getMimeType() {
        if ($this->mimetype) {
            return $this->mimetype;
        }
        return $this->detectMimeType();
    }
 
    public function setMimeType($mimetype) {
        return $this->mimetype = $mimetype;
    }
 
    public function detectMimeType($file = null, $default = null) {
        $class = __CLASS__;
        if (!$file && isset($this) && $this instanceof $class) {
            $file = $this->getFilenameOnFilestore();
        }
 
        if (!is_readable($file)) {
            return false;
        }
 
        $mime = $default;
 
        $detected = (new MimeTypeDetector())->tryStrategies($file);
        if ($detected) {
            $mime = $detected;
        }
 
        $original_filename = isset($this) && $this instanceof $class ? $this->originalfilename : basename($file);
        $params = array(
            'filename' => $file,
            'original_filename' => $original_filename, // @see file upload action
            'default' => $default,
        );
        return _elgg_services()->hooks->trigger('mime_type', 'file', $params, $mime);
    }
 
    public function getSimpleType() {
        if (isset($this->simpletype)) {
            return $this->simpletype;
        }
        $mime_type = $this->getMimeType();
        return elgg_get_file_simple_type($mime_type);
    }
 
    public function setDescription($description) {
        $this->description = $description;
    }
 
    public function open($mode) {
        if (!$this->getFilename()) {
            throw new IOException("You must specify a name before opening a file.");
        }
 
        // See if file has already been saved
        // seek on datastore, parameters and name?
        // Sanity check
        if (
                ($mode != "read") &&
                ($mode != "write") &&
                ($mode != "append")
        ) {
            $msg = "Unrecognized file mode '" . $mode . "'";
            throw new InvalidParameterException($msg);
        }
 
        // Get the filestore
        $fs = $this->getFilestore();
 
        // Ensure that we save the file details to object store
        //$this->save();
        // Open the file handle
        $this->handle = $fs->open($this, $mode);
 
        return $this->handle;
    }
 
    public function write($data) {
        $fs = $this->getFilestore();
 
        return $fs->write($this->handle, $data);
    }
 
    public function read($length, $offset = 0) {
        $fs = $this->getFilestore();
 
        return $fs->read($this->handle, $length, $offset);
    }
 
    public function grabFile() {
        $fs = $this->getFilestore();
        return $fs->grabFile($this);
    }
 
    public function close() {
        $fs = $this->getFilestore();
 
        if ($fs->close($this->handle)) {
            $this->handle = null;
 
            return true;
        }
 
        return false;
    }
 
    public function delete($follow_symlinks = true) {
        $fs = $this->getFilestore();
 
        $result = $fs->delete($this, $follow_symlinks);
 
        if ($this->getGUID() && $result) {
            $result = parent::delete();
        }
 
        return $result;
    }
 
    public function seek($position) {
        $fs = $this->getFilestore();
 
        return $fs->seek($this->handle, $position);
    }
 
    public function tell() {
        $fs = $this->getFilestore();
 
        return $fs->tell($this->handle);
    }
 
    public function setModifiedTime() {
        $filestorename = $this->getFilenameOnFilestore();
        $modified = touch($filestorename);
        if ($modified) {
            clearstatcache(true, $filestorename);
        } else {
            elgg_log("Unable to update modified time for $filestorename", 'ERROR');
        }
        return $modified;
    }
 
    public function getModifiedTime() {
        return filemtime($this->getFilenameOnFilestore());
    }
 
    public function getSize() {
        return $this->getFilestore()->getFileSize($this);
    }
 
    public function size() {
        elgg_deprecated_notice("Use \ElggFile::getSize() instead of \ElggFile::size()", 1.9);
        return $this->getSize();
    }
 
    public function eof() {
        $fs = $this->getFilestore();
 
        return $fs->eof($this->handle);
    }
 
    public function exists() {
        $fs = $this->getFilestore();
 
        return $fs->exists($this);
    }
 
    public function setFilestore(ElggFilestore $filestore) {
        elgg_deprecated_notice(__METHOD__ . ' is deprecated.', '2.1');
        $this->filestore = $filestore;
    }
 
    protected function getFilestore() {
        if ($this->filestore) {
            // already set
            return $this->filestore;
        }
 
        // such a common case we just assume for now
        $this->filestore = $GLOBALS['DEFAULT_FILE_STORE'];
 
        if (!$this->guid) {
            return $this->filestore;
        }
 
        // Note we use parent::getMetadata() below to avoid showing the warnings added in #9193
 
        $class = parent::getMetadata('filestore::filestore');
        if (!$class) {
            return $this->filestore;
        }
 
        // common case
        if ($class === ElggDiskFilestore::class && parent::getMetadata('filestore::dir_root') === _elgg_services()->config->getDataPath()) {
            return $this->filestore;
        }
 
        if (!class_exists($class)) {
            $this->filestore = null;
            throw new ClassNotFoundException("Unable to load filestore class $class for file {$this->guid}");
        }
 
        // need to get all filestore::* metadata because the rest are "parameters" that
        // get passed to filestore::setParameters()
        $mds = elgg_get_metadata([
            'guid' => $this->guid,
            'where' => array("n.string LIKE 'filestore::%'"),
        ]);
        $parameters = [];
        foreach ($mds as $md) {
            list(, $name) = explode("::", $md->name);
            if ($name !== 'filestore') {
                $parameters[$name] = $md->value;
            }
        }
 
        $this->filestore = new $class();
        $this->filestore->setParameters($parameters);
        return $this->filestore;
    }
 
    public function save() {
        if (!parent::save()) {
            return false;
        }
 
        $filestore = $this->getFilestore();
 
        // Note we use parent::getMetadata() below to avoid showing the warnings added in #9193
        // Save datastore metadata
        $params = $filestore->getParameters();
        foreach ($params as $k => $v) {
            parent::setMetadata("filestore::$k", $v);
        }
 
        // Now make a note of the filestore class
        parent::setMetadata("filestore::filestore", get_class($filestore));
 
        return true;
    }
 
    public function transfer($owner_guid, $filename = null) {
        if (!$owner_guid) {
            return false;
        }
 
        if (!$this->exists()) {
            return false;
        }
 
        if (!$filename) {
            $filename = $this->getFilename();
        }
        $filestorename = $this->getFilenameOnFilestore();
 
        $this->owner_guid = $owner_guid;
        $this->setFilename($filename);
        $this->open('write');
        $this->close();
 
        return rename($filestorename, $this->getFilenameOnFilestore());
    }
 
    public function acceptUploadedFile(UploadedFile $upload) {
        if (!$upload->isValid()) {
            return false;
        }
 
        $old_filestorename = '';
        if ($this->exists()) {
            $old_filestorename = $this->getFilenameOnFilestore();
        }
 
        $originalfilename = $upload->getClientOriginalName();
        $this->originalfilename = $originalfilename;
        if (empty($this->title)) {
            $this->title = htmlspecialchars($this->originalfilename, ENT_QUOTES, 'UTF-8');
        }
 
        $this->upload_time = time();
        $prefix = $this->filestore_prefix ? : 'file';
        $prefix = trim($prefix, '/');
        $filename = elgg_strtolower("$prefix/{$this->upload_time}{$this->originalfilename}");
        $this->setFilename($filename);
        $this->filestore_prefix = $prefix;
 
        $hook_params = [
            'file' => $this,
            'upload' => $upload,
        ];
 
        $uploaded = _elgg_services()->hooks->trigger('upload', 'file', $hook_params);
        if ($uploaded !== true && $uploaded !== false) {
            $filestorename = $this->getFilenameOnFilestore();
            try {
                $uploaded = $upload->move(pathinfo($filestorename, PATHINFO_DIRNAME), pathinfo($filestorename, PATHINFO_BASENAME));
            } catch (FileException $ex) {
                _elgg_services()->logger->error($ex->getMessage());
                $uploaded = false;
            }
        }
 
        if ($uploaded) {
            if ($old_filestorename && $old_filestorename != $this->getFilenameOnFilestore()) {
                // remove old file
                unlink($old_filestorename);
            }
            $mime_type = $this->detectMimeType(null, $upload->getClientMimeType());
            $this->setMimeType($mime_type);
            $this->simpletype = elgg_get_file_simple_type($mime_type);
            _elgg_services()->events->triggerAfter('upload', 'file', $this);
            return true;
        }
        
        return false;
    }
 
    public function __sleep() {
        return array_diff(array_keys(get_object_vars($this)), array(
            // Don't persist filestore, which contains CONFIG
            // https://github.com/Elgg/Elgg/issues/9081#issuecomment-152859856
            'filestore',
            // a resource
            'handle',
        ));
    }
 
}