engine/classes/ElggFile.php

Go to the documentation of this file.

<?php

class ElggFile extends ElggObject {
    private $filestore;

    private $handle;

    protected function initializeAttributes() {
        parent::initializeAttributes();

        $this->attributes['subtype'] = "file";
    }

    public function __construct($guid = null) {
        parent::__construct($guid);

        // Set default filestore
        $this->filestore = $this->getFilestore();
    }

    public function setFilename($name) {
        $this->filename = $name;
    }

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

    public function getFilenameOnFilestore() {
        return $this->filestore->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;
        }

        // @todo Guess mimetype if not here
    }

    public function setMimeType($mimetype) {
        return $this->mimetype = $mimetype;
    }

    public function detectMimeType($file = null, $default = null) {
        if (!$file) {
            if (isset($this) && $this->filename) {
                $file = $this->filename;
            } else {
                return false;
            }
        }

        $mime = false;

        // for PHP5 folks.
        if (function_exists('finfo_file') && defined('FILEINFO_MIME_TYPE')) {
            $resource = finfo_open(FILEINFO_MIME_TYPE);
            if ($resource) {
                $mime = finfo_file($resource, $file);
            }
        }

        // for everyone else.
        if (!$mime && function_exists('mime_content_type')) {
            $mime = mime_content_type($file);
        }

        // default
        if (!$mime) {
            return $default;
        }

        return $mime;
    }

    public function setDescription($description) {
        $this->description = $description;
    }

    public function open($mode) {
        if (!$this->getFilename()) {
            throw new IOException(elgg_echo('IOException:MissingFileName'));
        }

        // See if file has already been saved
        // seek on datastore, parameters and name?

        // Sanity check
        if (
            ($mode != "read") &&
            ($mode != "write") &&
            ($mode != "append")
        ) {
            $msg = elgg_echo('InvalidParameterException:UnrecognisedFileMode', array($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() {
        $fs = $this->getFilestore();
        if ($fs->delete($this)) {
            return parent::delete();
        }
    }

    public function seek($position) {
        $fs = $this->getFilestore();

        // @todo add seek() to ElggFilestore
        return $fs->seek($this->handle, $position);
    }

    public function tell() {
        $fs = $this->getFilestore();

        return $fs->tell($this->handle);
    }

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

    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) {
        $this->filestore = $filestore;
    }

    protected function getFilestore() {
        // Short circuit if already set.
        if ($this->filestore) {
            return $this->filestore;
        }

        // ask for entity specific filestore
        // saved as filestore::className in metadata.
        // need to get all filestore::* metadata because the rest are "parameters" that
        // get passed to filestore::setParameters()
        if ($this->guid) {
            $options = array(
                'guid' => $this->guid,
                'where' => array("n.string LIKE 'filestore::%'"),
            );

            $mds = elgg_get_metadata($options);

            $parameters = array();
            foreach ($mds as $md) {
                list($foo, $name) = explode("::", $md->name);
                if ($name == 'filestore') {
                    $filestore = $md->value;
                }
                $parameters[$name] = $md->value;
            }
        }

        // need to check if filestore is set because this entity is loaded in save()
        // before the filestore metadata is saved.
        if (isset($filestore)) {
            if (!class_exists($filestore)) {
                $msg = elgg_echo('ClassNotFoundException:NotFoundNotSavedWithFile',
                    array($filestore, $this->guid));
                throw new ClassNotFoundException($msg);
            }

            $this->filestore = new $filestore();
            $this->filestore->setParameters($parameters);
            // @todo explain why $parameters will always be set here (PhpStorm complains)
        }

        // this means the entity hasn't been saved so fallback to default
        if (!$this->filestore) {
            $this->filestore = get_default_filestore();
        }

        return $this->filestore;
    }

    public function save() {
        if (!parent::save()) {
            return false;
        }

        // Save datastore metadata
        $params = $this->filestore->getParameters();
        foreach ($params as $k => $v) {
            $this->setMetaData("filestore::$k", $v);
        }

        // Now make a note of the filestore class
        $this->setMetaData("filestore::filestore", get_class($this->filestore));

        return true;
    }
}

---