ElggFile.php

Go to the documentation of this file.

<?php
 
use Elgg\Exceptions\Filesystem\IOException;
use Elgg\Exceptions\DomainException as ElggDomainException;
use Elgg\Exceptions\InvalidArgumentException as ElggInvalidArgumentException;
use Elgg\Project\Paths;
use Symfony\Component\HttpFoundation\File\Exception\FileException;
use Symfony\Component\HttpFoundation\File\UploadedFile;
 
class ElggFile extends ElggObject {
 
    private $handle;
 
    protected function initializeAttributes() {
        parent::initializeAttributes();
 
        $this->attributes['subtype'] = 'file';
    }
    
    public function __set($name, $value) {
        switch ($name) {
            case 'filename':
                // ensure sanitization
                $this->setFilename($value);
                return;
        }
        
        parent::__set($name, $value);
    }
    
    public function __get($name) {
        switch ($name) {
            case 'filename':
                // ensure sanitization
                return $this->getFilename();
        }
        
        return parent::__get($name);
    }
 
    public function setFilename(string $filename): void {
        $filename = ltrim(Paths::sanitize($filename, false), '/');
        
        parent::__set('filename', $filename);
    }
 
    public function getFilename(): string {
        $filename = parent::__get('filename');
        if (empty($filename)) {
            return '';
        }
        
        return ltrim(Paths::sanitize($filename, false), '/');
    }
 
    public function getFilenameOnFilestore(): string {
        return $this->getFilestore()->getFilenameOnFilestore($this);
    }
 
    public function getMimeType(): string|false {
        if ($this->mimetype) {
            return $this->mimetype;
        }
        
        try {
            return _elgg_services()->mimetype->getMimeType($this->getFilenameOnFilestore());
        } catch (ElggInvalidArgumentException $e) {
            // the file has no file on the filesystem
            // can happen in tests etc.
        }
        
        return false;
    }
 
    public function setMimeType(string $mimetype): void {
        $this->mimetype = $mimetype;
    }
 
    public function getSimpleType(): string {
        if (isset($this->simpletype)) {
            return $this->simpletype;
        }
        
        return _elgg_services()->mimetype->getSimpleType($this->getMimeType() ?: '');
    }
 
    public function open(string $mode) {
        if (!$this->getFilename()) {
            throw new IOException('You must specify a name before opening a file.');
        }
 
        if (!in_array($mode, ['read', 'write', 'append'])) {
            throw new ElggDomainException("Unrecognized file mode '{$mode}'");
        }
 
        // Open the file handle
        $this->handle = $this->getFilestore()->open($this, $mode);
 
        return $this->handle;
    }
 
    public function write(string $data): int|false {
        return $this->getFilestore()->write($this->handle, $data);
    }
 
    public function read(int $length, int $offset = 0) {
        return $this->getFilestore()->read($this->handle, $length, $offset);
    }
 
    public function grabFile(): string|false {
        return $this->getFilestore()->grabFile($this);
    }
 
    public function close(): bool {
        if (is_resource($this->handle) && $this->getFilestore()->close($this->handle)) {
            $this->handle = null;
 
            return true;
        }
 
        return false;
    }
 
    public function delete(bool $recursive = true, bool $persistent = null): bool {
        if (!$this->guid) {
            return $this->persistentDelete($recursive);
        }
        
        return parent::delete($recursive, $persistent);
    }
    
    protected function persistentDelete(bool $recursive = true): bool {
        if ($this->guid) {
            $result = parent::persistentDelete($recursive);
            if ($result) {
                $this->getFilestore()->delete($this);
            }
            
            return $result;
        }
        
        return $this->getFilestore()->delete($this);
    }
 
    public function seek(int $position): void {
        $this->getFilestore()->seek($this->handle, $position);
    }
 
    public function tell(): int {
        return $this->getFilestore()->tell($this->handle);
    }
 
    public function setModifiedTime(): bool {
        $filestorename = $this->getFilenameOnFilestore();
        
        $modified = touch($filestorename);
        if ($modified) {
            clearstatcache(true, $filestorename);
        } else {
            elgg_log("Unable to update modified time for {$filestorename}", \Psr\Log\LogLevel::ERROR);
        }
        
        return $modified;
    }
 
    public function getModifiedTime(): int {
        return filemtime($this->getFilenameOnFilestore());
    }
 
    public function getSize(): int {
        return $this->getFilestore()->getFileSize($this);
    }
 
    public function eof(): bool {
        return $this->getFilestore()->eof($this->handle);
    }
 
    public function exists(): bool {
        return $this->getFilestore()->exists($this);
    }
 
    protected function getFilestore(): \Elgg\Filesystem\Filestore\DiskFilestore {
        return _elgg_services()->filestore;
    }
 
    public function transfer(int $owner_guid, ?string $filename = null): bool {
        if ($owner_guid < 1) {
            return false;
        }
 
        if (!$this->exists()) {
            return false;
        }
 
        if (empty($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): bool {
        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;
 
        $params = [
            'file' => $this,
            'upload' => $upload,
        ];
 
        $uploaded = _elgg_services()->events->triggerResults('upload', 'file', $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);
            }
            
            try {
                // try to detect mimetype
                $mime_type = _elgg_services()->mimetype->getMimeType($this->getFilenameOnFilestore());
                $this->setMimeType($mime_type);
                $this->simpletype = _elgg_services()->mimetype->getSimpleType($mime_type);
            } catch (ElggInvalidArgumentException $e) {
                // this can fail if the upload events returns true, but the file is not present on the filestore
                // this happens in a unittest
            }
            
            _elgg_services()->events->triggerAfter('upload', 'file', $this);
            return true;
        }
 
        return false;
    }
 
    public function __sleep() {
        return array_diff(array_keys(get_object_vars($this)), [
            // a resource
            'handle',
        ]);
    }
 
    public function canDownload(int $user_guid = 0, bool $default = true): bool {
        return _elgg_services()->userCapabilities->canDownload($this, $user_guid, $default);
    }
 
    public function getDownloadURL(bool $use_cookie = true, string $expires = '+2 hours'): ?string {
        $file_svc = new \Elgg\FileService\File();
        $file_svc->setFile($this);
        if (!empty($expires)) {
            $file_svc->setExpires($expires);
        }
        
        $file_svc->setDisposition('attachment');
        $file_svc->bindSession($use_cookie);
 
        $params = [
            'entity' => $this,
            'use_cookie' => $use_cookie,
            'expires' => $expires,
        ];
        return _elgg_services()->events->triggerResults('download:url', 'file', $params, $file_svc->getURL());
    }
 
    public function getInlineURL(bool $use_cookie = false, string $expires = ''): ?string {
        $file_svc = new \Elgg\FileService\File();
        $file_svc->setFile($this);
        if (!empty($expires)) {
            $file_svc->setExpires($expires);
        }
        
        $file_svc->setDisposition('inline');
        $file_svc->bindSession($use_cookie);
 
        $params = [
            'entity' => $this,
            'use_cookie' => $use_cookie,
            'expires' => $expires,
        ];
        return _elgg_services()->events->triggerResults('inline:url', 'file', $params, $file_svc->getURL());
    }
}