CollectionBuilder.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\ResourceStorage\Collection;
 
use ILIAS\ResourceStorage\Identification\CollectionIdentificationGenerator;
use ILIAS\ResourceStorage\Identification\ResourceCollectionIdentification;
use ILIAS\ResourceStorage\Identification\ResourceIdentification;
use ILIAS\ResourceStorage\Identification\UniqueIDCollectionIdentificationGenerator;
use ILIAS\ResourceStorage\Preloader\SecureString;
 
class CollectionBuilder
{
    use SecureString;
 
    private Repository\CollectionRepository $collection_repository;
    private ?CollectionIdentificationGenerator $id_generator = null;
    private ?\ILIAS\ResourceStorage\Lock\LockHandler $lock_handler = null;
 
 
    public function __construct(
        Repository\CollectionRepository $collection_repository,
        ?CollectionIdentificationGenerator $id_generator = null,
        ?\ILIAS\ResourceStorage\Lock\LockHandler $lock_handler = null
    ) {
        $this->collection_repository = $collection_repository;
        $this->lock_handler = $lock_handler;
        $this->id_generator = $id_generator ?? new UniqueIDCollectionIdentificationGenerator();
    }
 
    public function has(ResourceCollectionIdentification $identification): bool
    {
        return $this->collection_repository->has($identification);
    }
 
    public function getResourceIdStrings(ResourceCollectionIdentification $identification): \Generator
    {
        yield from $this->collection_repository->getResourceIdStrings($identification);
    }
 
    public function getResourceIds(ResourceCollectionIdentification $identification): \Generator
    {
        foreach ($this->getResourceIdStrings($identification) as $string) {
            yield new ResourceIdentification($string);
        }
    }
 
    private function validate(ResourceCollectionIdentification $identification): void
    {
        if (!$this->id_generator->validateScheme($identification->serialize())) {
            throw new \InvalidArgumentException('Invalid identification scheme');
        }
    }
 
    public function new(?int $owner = null): ResourceCollection
    {
        return $this->collection_repository->blank(
            $this->id_generator->getUniqueResourceCollectionIdentification(),
            $owner ?? ResourceCollection::NO_SPECIFIC_OWNER
        );
    }
 
    public function get(ResourceCollectionIdentification $identification, ?int $owner = null): ResourceCollection
    {
        $this->validate($identification);
        $existing = $this->collection_repository->existing($identification);
        if ($existing->hasSpecificOwner()
            && $existing->getOwner() !== $owner
        ) {
            throw new \InvalidArgumentException('Invalid owner of collection');
        }
        return $existing;
    }
 
    public function store(ResourceCollection $collection): bool
    {
        if ($this->lock_handler !== null) {
            $result = $this->lock_handler->lockTables(
                $this->collection_repository->getNamesForLocking(),
                function () use ($collection): void {
                    $this->collection_repository->update($collection);
                }
            );
            $result->runAndUnlock();
        } else {
            $this->collection_repository->update($collection);
        }
 
        return true;
    }
 
    public function delete(ResourceCollectionIdentification $identification): bool
    {
        $this->collection_repository->delete($identification);
        return true;
    }
 
    public function notififyResourceDeletion(ResourceIdentification $identification): void
    {
        $this->collection_repository->removeResourceFromAllCollections($identification);
    }
}