ViewsService.php

Go to the documentation of this file.

<?php
 
namespace Elgg;
 
use Elgg\Cache\ServerCache;
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 ServerCache $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 registerCoreViews(): void {
        if ($this->isViewLocationsLoadedFromCache()) {
            return;
        }
        
        // Core view files in /views
        $this->registerViewsFromPath(Paths::elgg());
        
        // Core view definitions in /engine/views.php
        $file = Paths::elgg() . 'engine/views.php';
        if (!is_file($file)) {
            return;
        }
        
        $spec = Includer::includeFile($file);
        if (is_array($spec)) {
            // check for uploaded fontawesome font
            if ($this->config->font_awesome_zip) {
                $spec['default']['font-awesome/css/'] = elgg_get_data_path() . 'fontawesome/webfont/css/';
                $spec['default']['font-awesome/otfs/'] = elgg_get_data_path() . 'fontawesome/webfont/otfs/';
                $spec['default']['font-awesome/webfonts/'] = elgg_get_data_path() . 'fontawesome/webfont/webfonts/';
            }
            
            $this->mergeViewsSpec($spec);
        }
    }
    
    public function autoregisterViews(string $view_base, string $folder, string $viewtype): bool {
        $folder = Paths::sanitize($folder);
        $view_base = Paths::sanitize($view_base, false);
        $view_base = $view_base ? $view_base . '/' : $view_base;
        
        try {
            $dir = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($folder, \RecursiveDirectoryIterator::SKIP_DOTS));
        } catch (\Throwable $t) {
            $this->getLogger()->error($t->getMessage());
            return false;
        }
 
        /* @var $file \SplFileInfo */
        foreach ($dir as $file) {
            $path = $file->getPath() .  '/' . $file->getBasename('.php');
            $path = Paths::sanitize($path, false);
 
            // found a file add it to the views
            $view = $view_base . substr($path, strlen($folder));
            $this->setViewLocation($view, $viewtype, $file->getPathname());
        }
 
        return true;
    }
 
    public function findViewFile(string $view, string $viewtype): string {
        if (!isset($this->locations[$viewtype][$view])) {
            return '';
        }
 
        $path = $this->locations[$viewtype][$view];
        
        return $this->fileExists($path) ? $path : '';
    }
 
    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] = $view;
        }
 
        // raise priority until it doesn't match one already registered
        while (isset($this->extensions[$view][$priority])) {
            $priority++;
        }
 
        $this->extensions[$view][$priority] = $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) . 'views/';
 
        // do not fail on non existing views folder
        if (!is_dir($path)) {
            return true;
        }
        
        try {
            $dir = new \DirectoryIterator($path);
        } catch (\Throwable $t) {
            $this->getLogger()->error($t->getMessage());
            return false;
        }
        
        foreach ($dir as $folder) {
            $folder_name = $folder->getBasename();
            if (!$folder->isDir() || str_starts_with($folder_name, '.')) {
                continue;
            }
            
            if (!$this->autoregisterViews('', $folder->getPathname(), $folder_name)) {
                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 {
        return array_keys($this->locations[$viewtype] ?? []);
    }
 
    public function getInspectorData(): array {
        $cached_overrides = $this->server_cache->load('view_overrides');
        
        return [
            'locations' => $this->locations,
            'overrides' => is_array($cached_overrides) ? $cached_overrides : $this->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);
    }
}