LazyNewsCollection.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\News\Data;
 
class LazyNewsCollection extends NewsCollection
{
    private bool $group_files = false;
    private int $group_forums = 0;
 
    public function __construct(
        array $news_ids = [],
        protected ?\Closure $fetch_callback = null
    ) {
        parent::__construct();
 
        foreach ($news_ids as $news_id) {
            $this->news_items[$news_id] = null;
        }
    }
 
    public function withFetchCallback(\Closure $callback): static
    {
        $clone = clone $this;
        $clone->fetch_callback = $callback;
        return $clone;
    }
 
    public function addNewsItems(array $news_items): static
    {
        foreach ($news_items as $id => $item) {
            if ($item !== null) {
                $this->addNewsItem($item);
            } else {
                $this->news_items[$id] = null;
            }
 
        }
        return $this;
    }
 
    public function load(array $news_ids = []): static
    {
        if ($this->fetch_callback === null) {
            throw new \RuntimeException('No fetch callback provided');
        }
 
        if (empty($news_ids)) {
            $news_ids = array_keys(array_filter($this->news_items, fn($item) => $item === null));
        } else {
            $news_ids = array_intersect($news_ids, array_keys($this->news_items));
        }
 
        if (empty($news_ids)) {
            return $this;
        }
 
        // Check if grouping was requested
        $context_types = [];
        if ($this->group_files === true) {
            $context_types[] = 'file';
        }
        if ($this->group_forums > 0) {
            $context_types[] = 'frm';
        }
 
        // Load items from a repository
        $items = call_user_func($this->fetch_callback, $news_ids, $context_types);
        $this->addNewsItems($items);
 
        // Perform re-grouping if necessary
        $this->regroup($items);
 
        return $this;
    }
 
    /*
        Grouping
     */
 
    public function groupFiles(): static
    {
        $this->group_files = true;
        return $this;
    }
 
    public function groupForums(bool $group_posting_sequence): static
    {
        $this->group_forums = $group_posting_sequence ? 2 : 1;
        return $this;
    }
 
    private function regroup(array $items): void
    {
        // Check if re-grouping is required
        $needs_file_grouping = false;
        $needs_forum_grouping = false;
        foreach ($items as $item) {
            if ($this->group_files === true && $item->getContextObjType() === 'file') {
                $needs_file_grouping = true;
            }
            if ($this->group_forums > 0 && $item->getContextObjType() === 'frm') {
                $needs_forum_grouping = true;
            }
        }
 
        // Perform re-grouping
        if ($needs_file_grouping) {
            parent::groupFiles();
        }
        if ($needs_forum_grouping) {
            parent::groupForums($this->group_forums === 2);
        }
    }
 
    /*
        Access & Lazy Loading
     */
 
    public function contains(int $news_id): bool
    {
        return array_key_exists($news_id, $this->news_items);
    }
 
    public function has(int $news_id): bool
    {
        return isset($this->news_items[$news_id]);
    }
 
    public function getById(int $news_id): ?NewsItem
    {
        if (!$this->has($news_id)) {
            $this->load([$news_id]);
        }
 
        return $this->news_items[$news_id] ?? null;
    }
 
    public function pick(int $offset): ?NewsItem
    {
        $index = max(0, $offset);
        $news_id = array_keys($this->news_items)[$index] ?? null;
 
        return $news_id !== null ? $this->getById($news_id) : null;
    }
 
    public function pluck(string $key, bool $wrap = false): array
    {
        if ($key === 'id') {
            return $wrap ? array_map(fn($item) => [$item], array_keys($this->news_items)) : array_keys($this->news_items);
        }
 
        $this->load();
        return parent::pluck($key, $wrap);
    }
 
    public function toArray(): array
    {
        $this->load();
        return parent::toArray();
    }
 
    public function getAggregatedNews(
        bool $aggregate_files = false,
        bool $aggregate_forums = false,
        bool $group_posting_sequence = false
    ): array {
        $this->load();
        return parent::getAggregatedNews($aggregate_files, $aggregate_forums, $group_posting_sequence);
    }
 
    public function merge(NewsCollection $other): static
    {
        return parent::merge($other)->withFetchCallback($this->fetch_callback);
    }
 
    public function exclude(array $news_ids): static
    {
        return parent::exclude($news_ids)->withFetchCallback($this->fetch_callback);
    }
 
    public function limit(?int $limit): static
    {
        return parent::limit($limit)->withFetchCallback($this->fetch_callback);
    }
}