ViewsService.php

Go to the documentation of this file.

<?php

namespace Elgg;

use Elgg\Application\CacheHandler;
use Elgg\Cache\SystemCache;
use Elgg\Filesystem\Directory;
use Elgg\Http\Request as HttpRequest;
use Psr\Log\LoggerInterface;

class ViewsService {

    use Loggable;

    const VIEW_HOOK = 'view';
    const VIEW_VARS_HOOK = 'view_vars';
    const OUTPUT_KEY = '__view_output';
    const BASE_VIEW_PRIORITY = 500;

    protected $file_exists_cache = [];

    private $locations = [];

    private $overrides = [];

    private $simplecache_views = [];

    private $extensions = [];

    private $fallbacks = [];

    private $hooks;

    private $cache;

    private $request;

    private $viewtype;

    public function __construct(PluginHooksService $hooks, LoggerInterface $logger, HttpRequest $request = null) {
        $this->hooks = $hooks;
        $this->logger = $logger;
        $this->request = $request;
    }

    public function setViewtype($viewtype = '') {
        if (!$viewtype) {
            $this->viewtype = null;

            return true;
        }
        if ($this->isValidViewtype($viewtype)) {
            $this->viewtype = $viewtype;

            return true;
        }

        return false;
    }

    public function getViewtype() {
        if ($this->viewtype === null) {
            $this->viewtype = $this->resolveViewtype();
        }

        return $this->viewtype;
    }

    public function clampViewtypeToPopulatedViews() {
        $viewtype = $this->getViewtype();
        if (empty($this->locations[$viewtype])) {
            $this->viewtype = 'default';
        }
    }

    private function resolveViewtype() {
        if ($this->request) {
            $view = $this->request->getParam('view', '', false);
            if ($this->isValidViewtype($view)) {
                return $view;
            }
        }

        $view = elgg_get_config('view');
        if ($this->isValidViewtype($view)) {
            return $view;
        }

        return 'default';
    }

    public function isValidViewtype($viewtype) {
        if (!is_string($viewtype) || $viewtype === '') {
            return false;
        }

        if (preg_match('/\W/', $viewtype)) {
            return false;
        }

        return true;
    }

    public static function canonicalizeViewName($alias) {
        if (!is_string($alias)) {
            return false;
        }

        $canonical = $alias;

        $extension = pathinfo($canonical, PATHINFO_EXTENSION);
        $hasValidFileExtension = isset(CacheHandler::$extensions[$extension]);

        if (strpos($canonical, "js/") === 0) {
            $canonical = substr($canonical, 3);
            if (!$hasValidFileExtension) {
                $canonical .= ".js";
            }
        } else if (strpos($canonical, "css/") === 0) {
            $canonical = substr($canonical, 4);
            if (!$hasValidFileExtension) {
                $canonical .= ".css";
            }
        }

        return $canonical;
    }

    public function autoregisterViews($view_base, $folder, $viewtype) {
        $folder = rtrim($folder, '/\\');
        $view_base = rtrim($view_base, '/\\');

        $handle = opendir($folder);
        if (!$handle) {
            return false;
        }

        while ($entry = readdir($handle)) {
            if ($entry[0] === '.') {
                continue;
            }

            $path = "$folder/$entry";

            if (!empty($view_base)) {
                $view_base_new = $view_base . "/";
            } else {
                $view_base_new = "";
            }

            if (is_dir($path)) {
                $this->autoregisterViews($view_base_new . $entry, $path, $viewtype);
            } else {
                $view = $view_base_new . basename($entry, '.php');
                $this->setViewLocation($view, $viewtype, $path);
            }
        }

        return true;
    }

    public function findViewFile($view, $viewtype) {
        if (!isset($this->locations[$viewtype][$view])) {
            return "";
        }

        $path = $this->locations[$viewtype][$view];
        if ($this->fileExists($path)) {
            return $path;
        }

        return "";
    }

    public function setViewDir($view, $location, $viewtype = '') {
        $view = self::canonicalizeViewName($view);

        if (empty($viewtype)) {
            $viewtype = 'default';
        }

        $location = rtrim($location, '/\\');

        if ($this->fileExists("$location/$viewtype/$view.php")) {
            $this->setViewLocation($view, $viewtype, "$location/$viewtype/$view.php");
        } else if ($this->fileExists("$location/$viewtype/$view")) {
            $this->setViewLocation($view, $viewtype, "$location/$viewtype/$view");
        }
    }

    public function registerViewtypeFallback($viewtype) {
        $this->fallbacks[] = $viewtype;
    }

    public function doesViewtypeFallback($viewtype) {
        return in_array($viewtype, $this->fallbacks);
    }

    public function renderDeprecatedView($view, array $vars, $suggestion, $version) {
        $view = self::canonicalizeViewName($view);

        $rendered = $this->renderView($view, $vars, '', false);
        if ($rendered) {
            elgg_deprecated_notice("The $view view has been deprecated. $suggestion", $version, 3);
        }

        return $rendered;
    }

    public function getViewList($view) {
        if (isset($this->extensions[$view])) {
            return $this->extensions[$view];
        } else {
            return [self::BASE_VIEW_PRIORITY => $view];
        }
    }

    public function renderView($view, array $vars = [], $viewtype = '', $issue_missing_notice = true, array $extensions_tree = []) {
        $view = self::canonicalizeViewName($view);

        if (!is_string($view) || !is_string($viewtype)) {
            $this->logger->notice("View and Viewtype in views must be a strings: $view");

            return '';
        }
        // basic checking for bad paths
        if (strpos($view, '..') !== false) {
            return '';
        }

        // check for extension deadloops
        if (in_array($view, $extensions_tree)) {
            $this->logger->error("View $view is detected as an extension of itself. This is not allowed");

            return '';
        }
        $extensions_tree[] = $view;

        // Get the current viewtype
        if ($viewtype === '' || !$this->isValidViewtype($viewtype)) {
            $viewtype = $this->getViewtype();
        }

        // allow altering $vars
        $vars_hook_params = [
            'view' => $view,
            'vars' => $vars,
            'viewtype' => $viewtype,
        ];
        $vars = $this->hooks->trigger(self::VIEW_VARS_HOOK, $view, $vars_hook_params, $vars);

        // allow $vars to hijack output
        if (isset($vars[self::OUTPUT_KEY])) {
            return (string) $vars[self::OUTPUT_KEY];
        }

        $viewlist = $this->getViewList($view);

        $content = '';
        foreach ($viewlist as $priority => $view_name) {
            if ($priority !== self::BASE_VIEW_PRIORITY) {
                // the others are extensions
                $content .= $this->renderView($view_name, $vars, $viewtype, $issue_missing_notice, $extensions_tree);
                continue;
            }

            // actual rendering of a single view
            $rendering = $this->renderViewFile($view_name, $vars, $viewtype, $issue_missing_notice);
            if ($rendering !== false) {
                $content .= $rendering;
                continue;
            }

            // attempt to load default view
            if ($viewtype !== 'default' && $this->doesViewtypeFallback($viewtype)) {
                $rendering = $this->renderViewFile($view_name, $vars, 'default', $issue_missing_notice);
                if ($rendering !== false) {
                    $content .= $rendering;
                }
            }
        }

        // Plugin hook
        $params = [
            'view' => $view,
            'vars' => $vars,
            'viewtype' => $viewtype,
        ];
        $content = $this->hooks->trigger(self::VIEW_HOOK, $view, $params, $content);

        return $content;
    }

    protected function fileExists($path) {
        if (!isset($this->file_exists_cache[$path])) {
            $this->file_exists_cache[$path] = file_exists($path);
        }

        return $this->file_exists_cache[$path];
    }

    private function renderViewFile($view, array $vars, $viewtype, $issue_missing_notice) {
        $file = $this->findViewFile($view, $viewtype);
        if (!$file) {
            if ($issue_missing_notice) {
                $this->logger->notice("$viewtype/$view view does not exist.");
            }

            return false;
        }

        if (pathinfo($file, PATHINFO_EXTENSION) === 'php') {
            ob_start();

            try {
                // don't isolate, scripts use the local $vars
                include $file;

                return ob_get_clean();
            } catch (\Exception $e) {
                ob_get_clean();
                throw $e;
            }
        }

        return file_get_contents($file);
    }

    public function viewExists($view, $viewtype = '', $recurse = true) {
        $view = self::canonicalizeViewName($view);

        if (empty($view) || !is_string($view)) {
            return false;
        }

        // Detect view type
        if ($viewtype === '' || !$this->isValidViewtype($viewtype)) {
            $viewtype = $this->getViewtype();
        }


        $file = $this->findViewFile($view, $viewtype);
        if ($file) {
            return true;
        }

        // If we got here then check whether this exists as an extension
        // We optionally recursively check whether the extended view exists also for the viewtype
        if ($recurse && isset($this->extensions[$view])) {
            foreach ($this->extensions[$view] as $view_extension) {
                // do not recursively check to stay away from infinite loops
                if ($this->viewExists($view_extension, $viewtype, false)) {
                    return true;
                }
            }
        }

        // Now check if the default view exists if the view is registered as a fallback
        if ($viewtype != 'default' && $this->doesViewtypeFallback($viewtype)) {
            return $this->viewExists($view, 'default');
        }

        return false;

    }

    public function extendView($view, $view_extension, $priority = 501) {
        $view = self::canonicalizeViewName($view);
        $view_extension = self::canonicalizeViewName($view_extension);

        if ($view === $view_extension) {
            // do not allow direct extension on self with self
            return;
        }

        if (!isset($this->extensions[$view])) {
            $this->extensions[$view][self::BASE_VIEW_PRIORITY] = (string) $view;
        }

        // raise priority until it doesn't match one already registered
        while (isset($this->extensions[$view][$priority])) {
            $priority++;
        }

        $this->extensions[$view][$priority] = (string) $view_extension;
        ksort($this->extensions[$view]);
    }

    public function viewIsExtended($view) {
        return count($this->getViewList($view)) > 1;
    }

    public function viewHasHookHandlers($view) {
        return $this->hooks->hasHandler('view', $view) || $this->hooks->hasHandler('view_vars', $view);
    }

    public function unextendView($view, $view_extension) {
        $view = self::canonicalizeViewName($view);
        $view_extension = self::canonicalizeViewName($view_extension);

        if (!isset($this->extensions[$view])) {
            return false;
        }

        $extensions = $this->extensions[$view];
        unset($extensions[self::BASE_VIEW_PRIORITY]); // we do not want the base view to be removed from the list

        $priority = array_search($view_extension, $extensions);
        if ($priority === false) {
            return false;
        }

        unset($this->extensions[$view][$priority]);

        return true;
    }

    public function registerCacheableView($view) {
        $view = self::canonicalizeViewName($view);

        $this->simplecache_views[$view] = true;
    }

    public function isCacheableView($view) {
        $view = self::canonicalizeViewName($view);
        if (isset($this->simplecache_views[$view])) {
            return true;
        }

        // build list of viewtypes to check
        $current_viewtype = $this->getViewtype();
        $viewtypes = [$current_viewtype];

        if ($this->doesViewtypeFallback($current_viewtype) && $current_viewtype != 'default') {
            $viewtypes[] = 'default';
        }

        // If a static view file is found in any viewtype, it's considered cacheable
        foreach ($viewtypes as $viewtype) {
            $file = $this->findViewFile($view, $viewtype);

            if ($file && pathinfo($file, PATHINFO_EXTENSION) !== 'php') {
                $this->simplecache_views[$view] = true;

                return true;
            }
        }

        // Assume not-cacheable by default
        return false;
    }

    public function registerPluginViews($path, &$failed_dir = '') {
        $path = rtrim($path, "\\/");
        $view_dir = "$path/views/";

        // plugins don't have to have views.
        if (!is_dir($view_dir)) {
            return true;
        }

        // but if they do, they have to be readable
        $handle = opendir($view_dir);
        if (!$handle) {
            $failed_dir = $view_dir;

            return false;
        }

        while (false !== ($view_type = readdir($handle))) {
            $view_type_dir = $view_dir . $view_type;

            if ('.' !== substr($view_type, 0, 1) && is_dir($view_type_dir)) {
                if (!$this->autoregisterViews('', $view_type_dir, $view_type)) {
                    $failed_dir = $view_type_dir;

                    return false;
                }
            }
        }

        return true;
    }

    public function mergeViewsSpec(array $spec) {
        foreach ($spec as $viewtype => $list) {
            foreach ($list as $view => $paths) {
                if (!is_array($paths)) {
                    $paths = [$paths];
                }

                foreach ($paths as $path) {
                    if (preg_match('~^([/\\\\]|[a-zA-Z]\:)~', $path)) {
                        // absolute path
                    } else {
                        // relative path
                        $path = Directory\Local::projectRoot()->getPath($path);
                    }

                    if (substr($view, -1) === '/') {
                        // prefix
                        $this->autoregisterViews($view, $path, $viewtype);
                    } else {
                        $this->setViewLocation($view, $viewtype, $path);
                    }
                }
            }
        }
    }

    public function listViews($viewtype = 'default') {
        if (empty($this->locations[$viewtype])) {
            return [];
        }

        return array_keys($this->locations[$viewtype]);
    }

    public function getInspectorData() {
        $overrides = $this->overrides;

        if ($this->cache) {
            $data = $this->cache->load('view_overrides');
            if (is_array($data)) {
                $overrides = $data;
            }
        }

        return [
            'locations' => $this->locations,
            'overrides' => $overrides,
            'extensions' => $this->extensions,
            'simplecache' => $this->simplecache_views,
        ];
    }

    public function configureFromCache(SystemCache $cache) {
        $data = $cache->load('view_locations');
        if (!is_array($data)) {
            return false;
        }
        // format changed, check version
        if (empty($data['version']) || $data['version'] !== '2.0') {
            return false;
        }
        
        $this->locations = $data['locations'];
        $this->cache = $cache;

        return true;
    }

    public function cacheConfiguration(SystemCache $cache) {
        $cache->save('view_locations', [
            'version' => '2.0',
            'locations' => $this->locations,
        ]);

        // this is saved just for the inspector and is not loaded in loadAll()
        $cache->save('view_overrides', $this->overrides);
    }

    private function setViewLocation($view, $viewtype, $path) {
        $view = self::canonicalizeViewName($view);
        $path = strtr($path, '\\', '/');

        if (isset($this->locations[$viewtype][$view]) && $path !== $this->locations[$viewtype][$view]) {
            $this->overrides[$viewtype][$view][] = $this->locations[$viewtype][$view];
        }
        $this->locations[$viewtype][$view] = $path;

        // Test if view is cacheable and push it to the cacheable views stack,
        // if it's not registered as cacheable explicitly
        $this->isCacheableView($view);
    }
}