lifetype-1.2/class/template/templatesets/templatesetstorage.class.php

Go to the documentation of this file.

<?php


    lt_include( PLOG_CLASS_PATH."class/config/config.class.php" );
    lt_include( PLOG_CLASS_PATH."class/misc/glob.class.php" );
    lt_include( PLOG_CLASS_PATH."class/file/file.class.php" );
    lt_include( PLOG_CLASS_PATH."class/template/templatesets/templatesets.class.php" );

    define( "BLOG_BASE_TEMPLATE_FOLDER", "blog_" );

        class TemplateSetStorage
        {

                function TemplateSetStorage()
                {

                }

        function getTemplateFolder( $templateName, $blogId = 0 )
        {
            $config =& Config::getConfig();
            $baseFolder = $config->getValue( "template_folder" );
            if( $baseFolder[strlen($baseFolder)-1] != "/" )
                $baseFolder = $baseFolder."/";

                if( $blogId == 0 ) {
                $templateFolder = $baseFolder.$templateName."/";
            }
            else {
                $templateFolder = $baseFolder.BLOG_BASE_TEMPLATE_FOLDER."$blogId/".$templateName."/";
            }

            return $templateFolder;
        }

        function getBaseTemplateFolder()
        {
                $config =& Config::getConfig();

            $basePath = $config->getValue( "template_folder" );

            return $basePath;
        }

        function getBlogBaseTemplateFolder( $blogId )
        {
            $config =& Config::getConfig();
            $baseFolder = $config->getValue( "template_folder" );
            if( $baseFolder[strlen($baseFolder)-1] != "/" )
                $baseFolder = $baseFolder."/";

            $templateFolder = $baseFolder.BLOG_BASE_TEMPLATE_FOLDER."$blogId/";

            return $templateFolder;
        }

        function _removeFolder( $folderName )
        {
                // if the folder does not even exist, let's not even bother trying... It
                // could be that it was manually removed by the user or something!
                if( File::exists( $folderName ))
                        $result = File::deleteDir( $folderName, true );
                else
                        $result = true;

                return( $result );
        }

        function _removeTemplateFromArray( $array, $key )
        {
            $resultArray = Array();
            foreach( $array as $elem ) {
                if( $elem != $key )
                        array_push( $resultArray, $elem );
            }

            return $resultArray;
        }

        function removeGlobalTemplate( $templateName )
        {
                $config =& Config::getConfig();

                        // check if the template really exists
            $availableTemplates = $config->getValue( "templates" );
                        if( !in_array( $templateName, $availableTemplates ))
                                return false;

            // remove the folder from disk
            $templateFolder = $this->getTemplateFolder( $templateName );
            $result = $this->_removeFolder( $templateFolder );
                        if( !$result )
                                return false;

            // remove the entry for that template from the configuration
            $newTemplateList = $this->_removeTemplateFromArray( $availableTemplates, $templateName );

            // update the list of templates
            $config->saveValue( "templates", $newTemplateList );

            return true;
        }

        function removeBlogTemplate( $templateName, $blogId )
        {
                $config =& Config::getConfig();

            // get the settings of this blog
                $blogs = new Blogs();
            $blog = $blogs->getBlogInfo( $blogId );
            $blogSettings = $blog->getSettings();

            // looks like the blog doesn't exist, so let's not bother...
            if( empty($blogSettings) )
                return false;

                        // check if the template really exists
            $blogTemplates = $blogSettings->getValue( "blog_templates" );
                        if( !in_array($templateName, $blogTemplates ))
                                return false;

            // remove the folder where the template is
            $templateFolder = $this->getTemplateFolder( $templateName, $blogId );
            $result = $this->_removeFolder( $templateFolder );
            if( !$result )
                return false;

            // remove the entry for that template from the configuration
            $newTemplateList = $this->_removeTemplateFromArray( $blogTemplates, $templateName );

            // finally, save the settings
            $blogSettings->setValue( "blog_templates", $newTemplateList );
            $blog->setSettings( $blogSettings );
            $blogs->updateBlog( $blog );

            return true;
        }

        function removeTemplate( $templateName, $blogId = 0 )
        {
                if( $blogId == 0 ) {
                $result = $this->removeGlobalTemplate( $templateName );
            }
            else {
                $result = $this->removeBlogTemplate( $templateName, $blogId );
            }

            return $result;
        }

        function addTemplate( $templateName, $blogId = 0 )
        {
                if( $blogId == 0 ) {
                // the template is global
                $result = $this->addGlobalTemplate( $templateName );
            }
            else {
                // the template is local
                $result = $this->addLocalTemplate( $templateName, $blogId );
            }

            return $result;
        }

        function addGlobalTemplate( $templateName )
        {
                $config =& Config::getConfig();

            // check if the value is there and if so, do nothing
            $templateSets = new TemplateSets();
            if( $templateSets->isTemplate( $templateName ))
                return true;

                        // let's make sure that we actually got an array... if not, then
                        // let's recreate the array to avoid further problems down the road!
                        $templates = $templateSets->getGlobalTemplates();
            if( !is_array($templates)) {
                print("recreating the array!");
                $templates = Array();
            }

            // if not there, we can add it
            array_push( $templates, $templateName );

            // and store the values
            $config->saveValue( "templates", $templates );

            return true;
        }

        function addLocalTemplate( $templateName, $blogId )
        {
                $blogs = new Blogs();
            $blog = $blogs->getBlogInfo( $blogId );
            $blogSettings = $blog->getSettings();
            if( empty($blogSettings) )
                return false;

            // get the array with the templates
            $blogTemplates = $blogSettings->getValue( "blog_templates" );

            // add a new one unless it's already there
            if( $blogTemplates == "" || $blogTemplates == null )
                $blogTemplates = Array();

            if( in_array( $templateName, $blogTemplates ))
                return true;

            array_push( $blogTemplates, $templateName );
            $blogSettings->setValue( "blog_templates", $blogTemplates );
            $blog->setSettings( $blogSettings );
            $blogs->updateBlog( $blog );

            return true;
        }

        function createBlogTemplateFolder( $blogId )
        {
            // make sure that the blog-specific folder exists
            $templateFolder = $this->getBaseTemplateFolder();
            $blogTemplateFolder = "$templateFolder/blog_".$blogId;
            if( !File::isDir( $blogTemplateFolder )) {
                File::createDir( $blogTemplateFolder, 0755 );
            }

            return $blogTemplateFolder;
        }

        function templateExists( $fileName, $templateSet )
        {
            $filePath = $this->getBaseTemplateFolder()."/".$templateSet."/".$fileName.".template";

            // first check if it exists at all
            if( !File::exists( $filePath, $templateSet ))
                return false;

            // and if it does, check if it can be read
            if( !File::isReadable( $filePath, $templateSet ))
                return false;

            return true;
        }

                function getAdminTemplateFolder()
                {
                        $templatePath = TemplateSetStorage::getBaseTemplateFolder()."/admin";

                        return $templatePath;
                }

                function getPluginTemplateFolder( $pluginId )
                {
                        $templateFolder = "./plugins/".$pluginId."/templates/";

                        return $templateFolder;
                }

                function isScreenshotAvailable( $templateName, $blogId = 0 )
                {
                        // build up the path to the screenshot file
                        $templatePath = $this->getTemplateFolder( $templateName, $blogId );
                        // and return whether it is available or not
                        $screenshotPath = $templatePath."/screenshot.jpg";
                        return( File::isReadable( $screenshotPath ));
                }

                function getScreenshotUrl( $templateName, $blogId = 0)
                {
                        // check if available at all...
                        if( !$this->isScreenshotAvailable( $templateName, $blogId ))
                                return $this->getNoScreenshotUrl();

                        $config =& Config::getConfig();
                        $templateFolder = $this->getBaseTemplateFolder();
                        $baseUrl = $config->getValue( "base_url" );
                        if( $blogId == 0 )
                                $screenshotPath = "$baseUrl/$templateFolder/$templateName/screenshot.jpg";
                        else
                                $screenshotPath = "$baseUrl/$templateFolder/blog_{$blogId}/$templateName/screenshot.jpg";

                        return $screenshotPath;
                }

                function getNoScreenshotUrl()
                {
                        $config =& Config::getConfig();
                        $baseUrl = $config->getValue( "base_url" );
                        $url = $baseUrl."/imgs/no-template-screenshot.jpg";

                        return $url;
                }

                function getMiscTemplateFolder()
                {
                        $templatePath = TemplateSetStorage::getBaseTemplateFolder()."/misc";
                        return $templatePath;
                }
        }
?>

© 2008 LifeType. All rights reserved.	International | Germany | Taiwan | Russia | Ukraine	Sitemap | Contact | Hosting by Lime Daley