ViewsService.php

Go to the documentation of this file.

<?php

namespace Elgg;

use Elgg\Cache\SystemCache;
use Elgg\Http\Request as HttpRequest;
use Elgg\Project\Paths;
use Elgg\Traits\Loggable;

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 array $file_exists_cache = [];

    protected array $locations = [];

    protected array $overrides = [];

    protected array $extensions = [];

    protected array $fallbacks = [];

    protected ?string $viewtype;
    
    protected bool $locations_loaded_from_cache = false;

    public function __construct(
        protected EventsService $events,
        protected HttpRequest $request,
        protected Config $config,
        protected SystemCache $server_cache
    ) {
    }

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

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

            return true;
        }

        return false;
    }

    public function getViewtype(): string {
        if (!isset($this->viewtype)) {
            $this->viewtype = $this->resolveViewtype();
        }

        return $this->viewtype;
    }

    protected function resolveViewtype(): string {
        if ($this->request) {
            $view = $this->request->getParam('view', '', false);
            if ($this->isValidViewtype($view) && !empty($this->locations[$view])) {
                return $view;
            }
        }

        $view = (string) $this->config->view;
        if ($this->isValidViewtype($view) && !empty($this->locations[$view])) {
            return $view;
        }

        return 'default';
    }

    public function isValidViewtype(string $viewtype): bool {
        if ($viewtype === '') {
            return false;
        }

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

        return true;
    }

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

        if (!is_dir($folder) || !is_readable($folder)) {
            $this->getLogger()->notice("Unable to register views from the directory: {$folder}");
            return false;
        }

        try {
            $dir = new \DirectoryIterator($folder);
        } catch (\Exception $e) {
            $this->getLogger()->error($e->getMessage());
            return false;
        }

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

        /* @var $fileinfo \SplFileInfo */
        foreach ($dir as $fileinfo) {
            if ($fileinfo->isDot()) {
                continue;
            }

            $path = $fileinfo->getPathname();

            if ($fileinfo->isDir()) {
                // Found a directory so go deeper
                $this->autoregisterViews($view_base_new . $fileinfo->getFilename(), $path, $viewtype);
                continue;
            }

            // found a file add it to the views
            $view = $view_base_new . $fileinfo->getBasename('.php');
            $this->setViewLocation($view, $viewtype, $path);
        }

        return true;
    }

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

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

        return '';
    }

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

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

    public function renderDeprecatedView(string $view, array $vars, string $suggestion, string $version): string {
        $rendered = $this->renderView($view, $vars, '', false);
        if ($rendered) {
            $this->logDeprecatedMessage("The '{$view}' view has been deprecated. {$suggestion}", $version);
        }

        return $rendered;
    }

    public function getViewList(string $view): array {
        return $this->extensions[$view] ?? [self::BASE_VIEW_PRIORITY => $view];
    }

    public function renderView(string $view, array $vars = [], string $viewtype = '', bool $issue_missing_notice = null, array $extensions_tree = []): string {
        // basic checking for bad paths
        if (str_contains($view, '..')) {
            return '';
        }

        // check for extension deadloops
        if (in_array($view, $extensions_tree)) {
            $this->getLogger()->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();
        }
        
        if (!isset($issue_missing_notice)) {
            $issue_missing_notice = $viewtype === 'default';
        }

        // allow altering $vars
        $vars_event_params = [
            'view' => $view,
            'vars' => $vars,
            'viewtype' => $viewtype,
        ];
        $vars = $this->events->triggerResults(self::VIEW_VARS_HOOK, $view, $vars_event_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;
                }
            }
        }

        $params = [
            'view' => $view,
            'vars' => $vars,
            'viewtype' => $viewtype,
        ];
        
        return (string) $this->events->triggerResults(self::VIEW_HOOK, $view, $params, $content);
    }

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

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

    protected function renderViewFile(string $view, array $vars, string $viewtype, bool $issue_missing_notice): string|false {
        $file = $this->findViewFile($view, $viewtype);
        if (!$file) {
            if ($issue_missing_notice) {
                $this->getLogger()->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(string $view, string $viewtype = '', bool $recurse = true): bool {
        if (empty($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(string $view, string $view_extension, int $priority = 501): void {
        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 unextendView(string $view, string $view_extension): bool {
        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 registerViewsFromPath(string $path): bool {
        $path = Paths::sanitize($path);
        $view_dir = "{$path}views/";

        // do not fail on non existing views folder
        if (!is_dir($view_dir)) {
            return true;
        }

        // but if folder exists it has to be readable
        $handle = opendir($view_dir);
        if ($handle === false) {
            $this->getLogger()->notice("Unable to register views from the directory: {$view_dir}");

            return false;
        }

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

            if (!str_starts_with($view_type, '.') && is_dir($view_type_dir)) {
                if (!$this->autoregisterViews('', $view_type_dir, $view_type)) {
                    return false;
                }
            }
        }

        return true;
    }

    public function mergeViewsSpec(array $spec): void {
        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)) {
                        // relative path
                        $path = Paths::project() . $path;
                    }

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

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

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

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

        if ($this->server_cache) {
            $data = $this->server_cache->load('view_overrides');
            if (is_array($data)) {
                $overrides = $data;
            }
        }
        
        return [
            'locations' => $this->locations,
            'overrides' => $overrides,
            'extensions' => $this->extensions,
            'simplecache' => _elgg_services()->simpleCache->getCacheableViews(),
        ];
    }

    public function configureFromCache(): void {
        if (!$this->server_cache->isEnabled()) {
            return;
        }
        
        $data = $this->server_cache->load('view_locations');
        if (!is_array($data)) {
            return;
        }
        
        $this->locations = $data['locations'];
        $this->locations_loaded_from_cache = true;
    }

    public function cacheConfiguration(): void {
        if (!$this->server_cache->isEnabled()) {
            return;
        }
        
        // only cache if not already loaded
        if ($this->isViewLocationsLoadedFromCache()) {
            return;
        }
        
        if (empty($this->locations)) {
            $this->server_cache->delete('view_locations');
            return;
        }
        
        $this->server_cache->save('view_locations', ['locations' => $this->locations]);

        // this is saved just for the inspector and is not loaded in loadAll()
        $this->server_cache->save('view_overrides', $this->overrides);
    }
    
    public function isViewLocationsLoadedFromCache(): bool {
        return $this->locations_loaded_from_cache;
    }
    
    public function getESModules(): array {
        $modules = $this->server_cache->load('esmodules');
        if (is_array($modules)) {
            return $modules;
        }
        
        $modules = [];
        foreach ($this->locations['default'] as $name => $path) {
            if (!str_ends_with($name, '.mjs')) {
                continue;
            }
            
            $modules[] = $name;
        }
        
        $this->server_cache->save('esmodules', $modules);
        
        return $modules;
    }

    protected function setViewLocation(string $view, string $viewtype, string $path): void {
        $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
        _elgg_services()->simpleCache->isCacheableView($view);
    }
}