Pagination.php

Go to the documentation of this file.

<?php

declare(strict_types=1);

namespace ILIAS\UI\Implementation\Component\Input\ViewControl;

use ILIAS\UI\Component\Input\ViewControl as VCInterface;
use ILIAS\UI\Implementation\Component\SignalGeneratorInterface;
use ILIAS\UI\Component\Signal;
use ILIAS\Data\Factory as DataFactory;
use ILIAS\Refinery\Factory as Refinery;
use ILIAS\Refinery\Transformation;
use ILIAS\Data\Range;
use ILIAS\UI\Implementation\Component\Input\Field\Factory as FieldFactory;
use ILIAS\UI\Implementation\Component\ComponentHelper;
use ILIAS\UI\Implementation\Component\Input\NameSource;

class Pagination extends ViewControlInput implements VCInterface\Pagination, HasInputGroup
{
    use ComponentHelper;
    use GroupDecorator;

    public const DEFAULT_LIMITS = [5, 10, 25, 50, 100, 250, 500, \PHP_INT_MAX];
    public const FNAME_OFFSET = 'offset';
    public const FNAME_LIMIT = 'limit';
    protected const NUMBER_OF_VISIBLE_SECTIONS = 7;

    protected Signal $internal_selection_signal;
    protected array $options;
    protected ?int $total_count = null;
    protected int $number_of_entries;
    protected string $label_limit = '';

    public function __construct(
        FieldFactory $field_factory,
        DataFactory $data_factory,
        Refinery $refinery,
        SignalGeneratorInterface $signal_generator
    ) {
        parent::__construct($data_factory, $refinery);

        $this->setInputGroup(
            $field_factory->group([
                self::FNAME_OFFSET => $field_factory->hidden(),
                self::FNAME_LIMIT => $field_factory->hidden(),
            ])
            ->withAdditionalTransformation($this->getRangeTransform())
            ->withAdditionalTransformation($this->getCorrectOffsetForPageSize())
        );

        $this->internal_selection_signal = $signal_generator->create();
        $this->number_of_entries = self::NUMBER_OF_VISIBLE_SECTIONS;
    }

    protected function getRangeTransform(): Transformation
    {
        return $this->refinery->custom()->transformation(
            function ($v): Range {
                if (is_null($v)) {
                    $limit = current($this->getLimitOptions());
                } else {
                    list(self::FNAME_OFFSET => $offset, self::FNAME_LIMIT => $limit) = array_map('intval', $v);
                };
                return $this->data_factory->range($offset, $limit);
            }
        );
    }

    protected function getCorrectOffsetForPageSize(): Transformation
    {
        return $this->refinery->custom()->transformation(
            function ($v): Range {
                list($offset, $limit) = $v->unpack();
                if($limit === 0) {
                    $limit = current($this->getLimitOptions());
                }
                $current_page = floor($offset / $limit);
                $offset = $current_page * $limit;
                return $this->data_factory->range((int)$offset, $limit);
            }
        );
    }

    public function getInternalSignal(): Signal
    {
        return $this->internal_selection_signal;
    }

    public function withLimitOptions(array $options): self
    {
        $this->checkArgListElements('options', $options, 'int');
        $clone = clone $this;
        $clone->options = $options;
        return $clone;
    }

    public function getLimitOptions(): array
    {
        return $this->options ?? self::DEFAULT_LIMITS;
    }

    public function getLabelLimit(): string
    {
        return $this->label_limit;
    }

    public function withAriaLabelLimit(string $label_limit): self
    {
        $clone = clone $this;
        $clone->label_limit = $label_limit;
        return $clone;
    }

    public function withLabelOffset(string $label): self
    {
        $clone = clone $this;
        $clone->label = $label;
        return $clone;
    }

    public function withNumberOfVisibleEntries(int $number_of_entries): self
    {
        $clone = clone $this;
        $clone->number_of_entries = $number_of_entries;
        return $clone;
    }

    public function getNumberOfVisibleEntries(): int
    {
        return $this->number_of_entries;
    }

    public function getTotalCount(): ?int
    {
        return $this->total_count;
    }

    public function withTotalCount(?int $total_count): self
    {
        $clone = clone $this;
        $clone->total_count = $total_count;
        return $clone;
    }
}