NewsCollectionService.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\News\Domain;
 
use ILIAS\News\Aggregation\NewsAggregator;
use ILIAS\News\Data\LazyNewsCollection;
use ILIAS\News\Data\NewsCollection;
use ILIAS\News\Data\NewsContext;
use ILIAS\News\Data\NewsCriteria;
use ILIAS\News\Persistence\NewsCache;
use ILIAS\News\Persistence\NewsRepository;
 
class NewsCollectionService
{
    public function __construct(
        private readonly NewsRepository $repository,
        private readonly NewsCache $cache,
        private readonly UserContextResolver $user_context_resolver,
        private readonly \ilObjectDataCache $object_data,
        private readonly \ilAccessHandler $access,
    ) {
    }
 
    public function getNewsForUser(\ilObjUser $user, NewsCriteria $criteria, bool $lazy = false): NewsCollection
    {
        // 1. Try user cache first
        $cached_news = $this->cache->getNewsForUser($user->getId(), $criteria);
        if ($cached_news !== null) {
            // Transform the lazy collection to a normal collection if needed
            if (!$lazy) {
                $news_collection = new NewsCollection($this->repository->findByIds($cached_news->pluck('id')));
            } else {
                $news_collection = $cached_news->withFetchCallback(
                    fn(...$args) => $this->repository->loadLazyItems(...$args)
                );
            }
 
            // Apply request-specific filtering [DPL 5]
            return $this->applyFinalProcessing($news_collection, $criteria);
        }
 
        // 2. Add missing criteria and validate it
        if ($criteria->isIncludeReadStatus() && $criteria->getReadUserId() === null) {
            $criteria = $criteria->withReadUserId($user->getId());
        }
        $criteria->validate();
 
        // 3. Get user accessible contexts [DPL 1]
        $user_contexts = $this->user_context_resolver->getAccessibleContexts($user, $criteria);
        if (empty($user_contexts)) {
            return new NewsCollection();
        }
 
        // 4. Query news for resolved contexts [DPL 2-4]
        $news_collection = $this->getNewsForContexts($user_contexts, $criteria, $lazy);
 
        // 5. Store in cache
        $this->cache->storeNewsForUser($user->getId(), $criteria, $news_collection);
 
        // 6. Apply request-specific filtering [DPL 5]
        return $this->applyFinalProcessing($news_collection, $criteria);
    }
 
    public function getNewsForContext(NewsContext $context, NewsCriteria $criteria, bool $lazy = false): NewsCollection
    {
        return $this->applyFinalProcessing($this->getNewsForContexts([$context], $criteria, $lazy), $criteria);
    }
 
    public function invalidateCache(int $user_id): void
    {
        $this->cache->invalidateNewsForUser($user_id, new NewsCriteria());
    }
 
    private function getNewsForContexts(array $contexts, NewsCriteria $criteria, bool $lazy): NewsCollection
    {
        // 1. Try context cache first (L1)
        $cached = $this->cache->getAggregatedContexts($contexts);
        $hits = $cached['hit'];
 
        if (!empty($cached['missing'])) {
            // 2. Batch load missing context object information [DPL 2]
            $remaining = $this->fetchContextData($cached['missing']);
 
            // 3. Perform aggregation [DPL 3]
            if (!$criteria->isPreventNesting()) {
                $aggregated = (new NewsAggregator())->aggregate($remaining);
                $this->cache->storeAggregatedContexts($remaining, $aggregated);
                $hits = array_merge($hits, $aggregated);
            } else {
                $hits = array_merge($hits, $remaining);
            }
        }
 
        // 4. Perform access checks [DPL 3]
        $aggregated = $this->filterByAccess($hits, $criteria);
 
        // 5. Batch load news from the database [DPL 4]
        return $lazy
            ? $this->repository->findByContextsBatchLazy($aggregated, $criteria)
            : $this->repository->findByContextsBatch($aggregated, $criteria);
    }
 
    private function fetchContextData(array $contexts): array
    {
        // Batch loads object_data and object_references using preloading
        $obj_ids = array_filter(array_map(fn($context) => $context->getObjId(), $contexts));
        $this->object_data->preloadObjectCache($obj_ids);
 
        for ($i = 0; $i < count($contexts); $i++) {
            $context = $contexts[$i];
 
            if ($context->getObjId() === null) {
                $context->setObjId($this->object_data->lookupObjId($context->getRefId()));
            }
 
            if ($context->getObjType() === null) {
                $context->setObjType($this->object_data->lookupType($context->getObjId()));
            }
 
            $contexts[$i] = $context;
        }
 
        return $contexts;
    }
 
    private function filterByAccess(array $contexts, NewsCriteria $criteria): array
    {
        if ($criteria->isOnlyPublic()) {
            return $contexts;
        }
 
        // Preload activation cache which is used in access handler
        \ilObjectActivation::preloadData(array_map(fn($context) => $context->getRefId(), $contexts));
 
        $filtered = [];
        foreach ($contexts as $context) {
            if ($this->access->checkAccess('read', '', $context->getRefId())) {
                $filtered[] = $context;
            }
        }
        return $filtered;
    }
 
    private function applyFinalProcessing(NewsCollection $collection, NewsCriteria $criteria): NewsCollection
    {
        return $collection->exclude($criteria->getExcludedNewsIds())->limit($criteria->getLimit());
    }
}