class.ilPreview.php

Go to the documentation of this file.

<?php
class ilPreview
{
    // status values
    public const RENDER_STATUS_NONE = "none";
    public const RENDER_STATUS_PENDING = "pending";
    public const RENDER_STATUS_CREATED = "created";
    public const RENDER_STATUS_FAILED = "failed";
 
    private const FILENAME_FORMAT = "preview_%02d.jpg";
 
    private ?int $obj_id = null;
 
    private ?string $obj_type = null;
 
    private ?\ilFSStoragePreview $storage = null;
 
    private bool $exists = false;
 
    private ?string $render_date = null;
 
    private string $render_status = self::RENDER_STATUS_NONE;
    protected ilRendererFactory $factory;
 
    public function __construct(int $a_obj_id, string $a_type = "")
    {
        $this->obj_id = $a_obj_id;
        $this->obj_type = $a_type;
        $this->factory = new ilRendererFactory();
        $this->init();
    }
 
    public static function createPreview(\ilObject $a_obj, bool $a_force = false): bool
    {
        $preview = new ilPreview($a_obj->getId(), $a_obj->getType());
        return $preview->create($a_obj, $a_force);
    }
 
    public static function deletePreview(int $a_obj_id): void
    {
        $preview = new ilPreview($a_obj_id);
        $preview->delete();
    }
 
    public static function copyPreviews(int $a_src_id, int $a_dest_id): void
    {
        if (!ilPreviewSettings::isPreviewEnabled()) {
            return;
        }
 
        // get source preview
        $src = new ilPreview($a_src_id);
        $status = $src->getRenderStatus();
 
        // created? copy the previews
        if ($status === self::RENDER_STATUS_CREATED) {
            // create destination preview and set it's properties
            $dest = new ilPreview($a_dest_id);
            $dest->setRenderDate($src->getRenderDate());
            $dest->setRenderStatus($src->getRenderStatus());
 
            // create path
            $dest->getStorage()->create();
 
            // copy previews
            ilFileUtils::rCopy($src->getStoragePath(), $dest->getStoragePath());
 
            // save copy
            $dest->doCreate();
        }
    }
 
    public static function hasPreview(int $a_obj_id, string $a_type = ""): bool
    {
        if (!ilPreviewSettings::isPreviewEnabled()) {
            return false;
        }
 
        $preview = new ilPreview($a_obj_id, $a_type);
        if ($preview->exists()) {
            return true;
        }
        $factory = new ilRendererFactory();
        $renderer = $factory->getRenderer($preview);
        return $renderer !== null;
    }
 
    public static function lookupRenderStatus(int $a_obj_id): string
    {
        $preview = new ilPreview($a_obj_id);
        return $preview->getRenderStatus();
    }
 
    public function exists(): bool
    {
        return $this->exists;
    }
 
    public function create(\ilObject $a_obj, bool $a_force = false): bool
    {
        if (!ilPreviewSettings::isPreviewEnabled()) {
            return false;
        }
        $factory = new ilRendererFactory();
        $renderer = $factory->getRenderer($this);
 
        // no renderer available?
        if ($renderer === null) {
            // bugfix mantis 23293
            $this->delete();
            return false;
        }
 
        // exists, but still pending?
        if ($this->getRenderStatus() === self::RENDER_STATUS_PENDING) {
            return false;
        }
 
        // not forced? check if update really needed
        if (!$a_force && $this->getRenderStatus() === self::RENDER_STATUS_CREATED) {
            // check last modified against last render date
            if ($a_obj->getLastUpdateDate() <= $this->getRenderDate()) {
                return false;
            }
        }
 
        // re-create the directory to store the previews
        $this->getStorage()->delete();
        $this->getStorage()->create();
 
        // let the renderer create the preview
        $renderer->render($this, $a_obj, true);
 
        // save to database
        $this->save();
 
        return true;
    }
 
    public function delete(): void
    {
        // does exist?
        if ($this->exists()) {
            // delete files and database entry
            $this->getStorage()->delete();
            $this->doDelete();
 
            // reset values
            $this->exists = false;
            $this->render_date = null;
            $this->render_status = self::RENDER_STATUS_NONE;
        }
    }
 
    public function getImages(): array
    {
        $images = array();
 
        // status must be created
        $path = $this->getAbsoluteStoragePath();
        if ($this->getRenderStatus() === self::RENDER_STATUS_CREATED && ($handle = @opendir($path))) {
            // load files
            while (false !== ($file = readdir($handle))) {
                $filepath = $path . "/" . $file;
                if (!is_file($filepath)) {
                    continue;
                }
 
                if ($file !== '.' && $file !== '..' && strpos($file, "preview_") === 0) {
                    $image = array();
                    $image["url"] = ilUtil::getHtmlPath($filepath);
 
                    // get image size
                    $size = @getimagesize($filepath);
                    if ($size !== false) {
                        $image["width"] = $size[0];
                        $image["height"] = $size[1];
                    }
 
                    $images[$file] = $image;
                }
            }
            closedir($handle);
 
            // sort by key
            ksort($images);
        }
 
        return $images;
    }
 
    public function save(): void
    {
        if ($this->exists) {
            $this->doUpdate();
        } else {
            $this->doCreate();
        }
    }
 
    protected function doCreate(): void
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
 
        $ilDB->insert(
            "preview_data",
            array(
                "obj_id" => array("integer", $this->getObjId()),
                "render_date" => array("timestamp", $this->getRenderDate()),
                "render_status" => array("text", $this->getRenderStatus())
            )
        );
        $this->exists = true;
    }
 
    protected function doRead(): void
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
 
        $set = $ilDB->queryF(
            "SELECT * FROM preview_data WHERE obj_id=%s",
            array("integer"),
            array($this->getObjId())
        );
 
        while ($rec = $ilDB->fetchAssoc($set)) {
            $this->setRenderDate($rec["render_date"]);
            $this->setRenderStatus($rec["render_status"]);
            $this->exists = true;
        }
    }
 
    protected function doUpdate(): void
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
 
        $ilDB->update(
            "preview_data",
            array(
                "render_date" => array("timestamp", $this->getRenderDate()),
                "render_status" => array("text", $this->getRenderStatus())
            ),
            array("obj_id" => array("integer", $this->getObjId()))
        );
    }
 
    protected function doDelete(): void
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
 
        $ilDB->manipulateF(
            "DELETE FROM preview_data WHERE obj_id=%s",
            array("integer"),
            array($this->getObjId())
        );
    }
 
    public function getObjId(): ?int
    {
        return $this->obj_id;
    }
 
    public function getObjType(): string
    {
        // not evaluated before or specified?
        if (empty($this->obj_type)) {
            $this->obj_type = ilObject::_lookupType($this->getObjId(), false);
        }
 
        return $this->obj_type;
    }
 
    public function getStoragePath(): string
    {
        return $this->getStorage()->getPath();
    }
 
    public function getAbsoluteStoragePath(): string
    {
        return ILIAS_WEB_DIR . "/" . CLIENT_ID . "/{$this->getStorage()->getPath()}";
    }
 
    public function getFilePathFormat(): string
    {
        $path = ilFileUtils::removeTrailingPathSeparators($this->getAbsoluteStoragePath());
        return $path . "/" . self::FILENAME_FORMAT;
    }
 
    public function getRenderDate(): ?string
    {
        return $this->render_date;
    }
 
    public function setRenderDate(string $a_date): void
    {
        $this->render_date = $a_date;
    }
 
    public function getRenderStatus(): string
    {
        return $this->render_status;
    }
 
    public function setRenderStatus(string $a_status): void
    {
        $this->render_status = $a_status;
    }
 
    public function getStorage(): \ilFSStoragePreview
    {
        if ($this->storage === null) {
            $this->storage = new ilFSStoragePreview($this->obj_id);
        }
 
        return $this->storage;
    }
 
    private function init(): void
    {
        // read entry
        $this->doRead();
    }
}