WidgetsService.php

Go to the documentation of this file.

<?php
 
namespace Elgg;
 
use Elgg\Exceptions\Database\UserFetchFailureException;
 
class WidgetsService {
 
    private $widgets = [];
 
    private $widgetCache = [];
 
    public function getWidgets(int $owner_guid, string $context): array {
        $widget_cache_key = "{$context}-{$owner_guid}";
 
        if (isset($this->widgetCache[$widget_cache_key])) {
            return $this->widgetCache[$widget_cache_key];
        }
 
        $widgets = elgg_get_entities([
            'type' => 'object',
            'subtype' => 'widget',
            'owner_guid' => $owner_guid,
            'metadata_name' => 'context',
            'metadata_value' => $context,
            'limit' => false,
        ]);
        
        if (!$widgets) {
            $this->widgetCache[$widget_cache_key] = [];
            return [];
        }
 
        $sorted_widgets = [];
        foreach ($widgets as $widget) {
            $widget_column = (int) $widget->column;
            
            if (!isset($sorted_widgets[$widget_column])) {
                $sorted_widgets[$widget_column] = [];
            }
            
            if (!isset($sorted_widgets[$widget_column][$widget->order])) {
                $sorted_widgets[$widget_column][$widget->order] = [];
            }
            
            $sorted_widgets[$widget_column][$widget->order][] = $widget;
        }
 
        foreach ($sorted_widgets as $col => $orders) {
            ksort($orders);
            $sorted_col = [];
            
            foreach ($orders as $widgets) {
                foreach ($widgets as $widget) {
                    $sorted_col[] = $widget;
                }
            }
            
            $sorted_widgets[$col] = $sorted_col;
        }
 
        $this->widgetCache[$widget_cache_key] = $sorted_widgets;
 
        return $sorted_widgets;
    }
 
    public function createWidget(int $owner_guid, string $handler, string $context, ?int $access_id = null) {
        if (empty($owner_guid) || empty($handler)) {
            return false;
        }
 
        $owner = get_entity($owner_guid);
        if (!$owner) {
            return false;
        }
        
        if (!$this->validateType($handler, $context, $owner)) {
            return false;
        }
 
        $widget = new \ElggWidget();
        $widget->owner_guid = $owner_guid;
        $widget->container_guid = $owner_guid;
        $widget->access_id = $access_id ?? elgg_get_default_access();
        
        if (!$widget->save()) {
            return false;
        }
 
        $widget->handler = $handler;
        $widget->context = $context;
 
        return $widget->guid;
    }
 
    public function canEditLayout(string $context, int $user_guid = 0): bool {
        try {
            $user = _elgg_services()->entityTable->getUserForPermissionsCheck($user_guid);
        } catch (UserFetchFailureException $e) {
            return false;
        }
 
        $page_owner = elgg_get_page_owner_entity();
        $default = false;
        
        if ($page_owner) {
            $default = $page_owner->canEdit($user_guid);
        } elseif ($user) {
            $default = $user->isAdmin();
        }
        
        $params = [
            'user' => $user,
            'context' => $context,
            'page_owner' => $page_owner,
        ];
        return _elgg_services()->events->triggerResults('permissions_check', 'widget_layout', $params, $default);
    }
 
    public function registerType(WidgetDefinition $definition): void {
        $this->widgets[$definition->id] = $definition;
    }
 
    public function unregisterType(string $id): void {
        unset($this->widgets[$id]);
    }
 
    public function validateType(string $id, ?string $context = null, ?\ElggEntity $container = null): bool {
        $types = $this->getTypes([
            'context' => $context,
            'container' => $container,
        ]);
        $found = array_key_exists($id, $types);
        
        if (!$found && ($context === null)) {
            // Pre Elgg 2.2 this function returned true if a widget was registered regardless of context
            $found = array_key_exists($id, $this->widgets);
        }
        
        return $found;
    }
 
    public function getAllTypes(): array {
        return $this->widgets;
    }
    
    public function getNameById(string $id, string $context = '', ?\ElggEntity $container = null): ?string {
        $types = $this->getTypes([
            'context' => $context,
            'container' => $container,
        ]);
        if (isset($types[$id])) {
            return $types[$id]->name;
        }
        
        return null;
    }
 
    public function getTypes(array $params = []): array {
        $context = elgg_extract('context', $params, '');
        if (!$context) {
            $context = elgg_get_context();
            $params['context'] = $context;
        }
        
        $available_widgets = _elgg_services()->events->triggerResults('handlers', 'widgets', $params, $this->widgets);
        if (!is_array($available_widgets)) {
            return [];
        }
        
        $widgets = [];
        /* @var $widget_definition \Elgg\WidgetDefinition */
        foreach ($available_widgets as $widget_definition) {
            if (!$widget_definition instanceof WidgetDefinition) {
                continue;
            }
 
            if (!in_array($context, $widget_definition->context)) {
                continue;
            }
            
            if (!$widget_definition->isValid()) {
                continue;
            }
            
            $widgets[$widget_definition->id] = $widget_definition;
        }
 
        return $widgets;
    }
}