class.ilPreview.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2013 ILIAS open source, Extended GPL, see docs/LICENSE */
 
require_once("./Services/Preview/classes/class.ilPreviewSettings.php");
require_once("./Services/Preview/classes/class.ilFSStoragePreview.php");
 
class ilPreview
{
    // status values
    const RENDER_STATUS_NONE = "none";
    const RENDER_STATUS_PENDING = "pending";
    const RENDER_STATUS_CREATED = "created";
    const RENDER_STATUS_FAILED = "failed";
    
    const FILENAME_FORMAT = "preview_%02d.jpg";
    
    private $obj_id = null;
    
    private $obj_type = null;
    
    private $storage = null;
    
    private $exists = false;
    
    private $render_date = false;
    
    private $render_status = self::RENDER_STATUS_NONE;
    
    public function __construct($a_obj_id, $a_type = "")
    {
        $this->obj_id = $a_obj_id;
        $this->obj_type = $a_type;
        
        $this->init();
    }
    
    public static function createPreview($a_obj, $a_force = false)
    {
        $preview = new ilPreview($a_obj->getId(), $a_obj->getType());
        return $preview->create($a_obj, $a_force);
    }
    
    public static function deletePreview($a_obj_id)
    {
        $preview = new ilPreview($a_obj_id);
        $preview->delete();
    }
    
    public static function copyPreviews($a_src_id, $a_dest_id)
    {
        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
            ilUtil::rCopy($src->getStoragePath(), $dest->getStoragePath());
            
            // save copy
            $dest->doCreate();
        } else {
            // all other status need no action
            // self::RENDER_STATUS_FAILED
            // self::RENDER_STATUS_NONE
            // self::RENDER_STATUS_PENDING
        }
    }
    
    public static function hasPreview($a_obj_id, $a_type = "")
    {
        if (!ilPreviewSettings::isPreviewEnabled()) {
            return false;
        }
        
        $preview = new ilPreview($a_obj_id, $a_type);
        if ($preview->exists()) {
            return true;
        }
        
        // does not exist, enable on demand rendering if there's any renderer that supports our object
        require_once("./Services/Preview/classes/class.ilRendererFactory.php");
        $renderer = ilRendererFactory::getRenderer($preview);
        return $renderer != null;
    }
    
    public static function lookupRenderStatus($a_obj_id)
    {
        $preview = new ilPreview($a_obj_id);
        return $preview->getRenderStatus();
    }
    
    public function exists()
    {
        return $this->exists;
    }
    
    public function create($a_obj, $a_force = false)
    {
        if (!ilPreviewSettings::isPreviewEnabled()) {
            return false;
        }
        
        // get renderer for preview
        require_once("./Services/Preview/classes/class.ilRendererFactory.php");
        $renderer = ilRendererFactory::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 ($this->getRenderStatus() == self::RENDER_STATUS_CREATED && !$a_force) {
            // 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()
    {
        // does exist?
        if ($this->exists()) {
            // delete files and database entry
            $this->getStorage()->delete();
            $this->doDelete();
            
            // reset values
            $this->exists = false;
            $this->render_date = false;
            $this->render_status = self::RENDER_STATUS_NONE;
        }
    }
    
    public function getImages()
    {
        $images = array();
        
        // status must be created
        $path = $this->getStoragePath();
        if ($this->getRenderStatus() == self::RENDER_STATUS_CREATED) {
            // load files
            if ($handle = @opendir($path)) {
                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()
    {
        if ($this->exists) {
            $this->doUpdate();
        } else {
            $this->doCreate();
        }
    }
    
    protected function doCreate()
    {
        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()
    {
        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()
    {
        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()
    {
        global $DIC;
        $ilDB = $DIC['ilDB'];
        
        $ilDB->manipulateF(
            "DELETE FROM preview_data WHERE obj_id=%s",
            array("integer"),
            array($this->getObjId())
        );
    }
    
    public function getObjId()
    {
        return $this->obj_id;
    }
    
    public function getObjType()
    {
        // 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()
    {
        return $this->getStorage()->getPath();
    }
    
    public function getAbsoluteStoragePath()
    {
        return ILIAS_ABSOLUTE_PATH . substr($this->getStorage()->getPath(), 1);
    }
    
    public function getFilePathFormat()
    {
        $path = ilUtil::removeTrailingPathSeparators($this->getAbsoluteStoragePath());
        return $path . "/" . self::FILENAME_FORMAT;
    }
    
    public function getRenderDate()
    {
        return $this->render_date;
    }
    
    public function setRenderDate($a_date)
    {
        $this->render_date = $a_date;
    }
    
    public function getRenderStatus()
    {
        return $this->render_status;
    }
    
    public function setRenderStatus($a_status)
    {
        $this->render_status = $a_status;
    }
    
    public function getStorage()
    {
        if ($this->storage == null) {
            $this->storage = new ilFSStoragePreview($this->obj_id);
        }
        
        return $this->storage;
    }
    
    private function init()
    {
        // read entry
        $this->doRead();
    }
}