ExternalFiles.php

Go to the documentation of this file.

<?php

namespace Elgg\Assets;

use Elgg\Cache\SimpleCache;
use Elgg\Cache\SystemCache;
use Elgg\Config;
use Elgg\Http\Urls;
use Elgg\ViewsService;

class ExternalFiles {

    protected $files = [];

    protected $sri;
    
    protected $config;
    
    protected $urls;
    
    protected $views;
    
    protected $simpleCache;
    
    protected $serverCache;
    
    public function __construct(Config $config, Urls $urls, ViewsService $views, SimpleCache $simpleCache, SystemCache $serverCache) {
        $this->config = $config;
        $this->urls = $urls;
        $this->views = $views;
        $this->simpleCache = $simpleCache;
        $this->serverCache = $serverCache;
    }

    public function register(string $type, string $name, string $url, string $location): bool {
        $name = trim(strtolower($name));
        if (empty($name) || empty($url)) {
            return false;
        }
    
        $url = $this->urls->normalizeUrl($url);

        $this->setupType($type);
    
        $item = elgg_extract($name, $this->files[$type]);
    
        if ($item) {
            // updating a registered item
            // don't update loaded because it could already be set
            $item->url = $url;
            $item->location = $location;
        } else {
            $item = (object) [
                'loaded' => false,
                'url' => $url,
                'location' => $location,
            ];
        }

        $this->files[$type][$name] = $item;
    
        return true;
    }
    
    public function unregister(string $type, string $name): bool {
        $this->setupType($type);
        
        $name = trim(strtolower($name));
    
        if (!isset($this->files[$type][$name])) {
            return false;
        }
        
        unset($this->files[$type][$name]);
        return true;
    }

    public function load(string $type, string $name): void {
        $this->setupType($type);
    
        $name = trim(strtolower($name));
    
        $item = elgg_extract($name, $this->files[$type]);
    
        if ($item) {
            // update a registered item
            $item->loaded = true;
        } else {
            $item = (object) [
                'loaded' => true,
                'url' => '',
                'location' => '',
            ];
            if ($this->views->viewExists($name)) {
                $item->url = $this->simpleCache->getUrl($name);
                $item->location = ($type === 'js') ? 'footer' : 'head';
            }
        }
        
        $this->files[$type][$name] = $item;
    }
    
    public function getLoadedResources(string $type, string $location): array {
        if (!isset($this->files[$type])) {
            return [];
        }

        $items = $this->files[$type];

        // only return loaded files for this location
        $items = array_filter($items, function($v) use ($location) {
            return $v->loaded == true && $v->location == $location;
        });
        
        $cache_ts = $this->config->lastcache;
        $cache_url = $this->config->wwwroot . "cache/{$cache_ts}/default/";
        
        // check if SRI data is available
        array_walk($items, function(&$v, $k) use ($type, $cache_url) {
            $view = str_replace($cache_url, '', $v->url);
            $v->integrity = $this->getSubResourceIntegrity($type, $view);
        });
        
        return $items;
    }

    public function reset(): void {
        $this->files = [];
    }
    
    protected function setupType(string $type): void {
        if (!isset($this->files[$type])) {
            $this->files[$type] = [];
        }
    }
    
    protected function getSubResourceIntegrity(string $type, string $resource): ?string {
        if (!$this->config->subresource_integrity_enabled) {
            return null;
        }
        
        if (!isset($this->sri)) {
            $this->sri = $this->serverCache->load('sri') ?? [];
        }
        
        return $this->sri[$type][$resource] ?? null;
    }
}