TelegramBot\InlineKeyboardPagination\InlineKeyboardPagination

Complexity

Total Complexity

45

Size/Duplication

Total Lines	385
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	getOffset()	0	3	1
A	generateCallbackData()	0	6	1
A	setItemsPerPage()	0	9	2
A	setCommand()	0	5	1
A	setItems()	0	9	2
A	getNumberOfPages()	0	3	1
A	getCallbackDataFormat()	0	3	1
A	__construct()	0	10	1
A	getLabels()	0	3	1
A	getParametersFromCallbackData()	0	5	1
A	setMaxButtons()	0	10	3
A	setSelectedPage()	0	10	3
A	getPagination()	0	9	2
A	generateButtons()	0	17	3
A	setLabels()	0	5	1
B	applyButtonLabels()	0	33	9
A	generateKeyboard()	0	6	1
B	generateRange()	0	31	7
A	generateButton()	0	5	1
A	getItemsPerPage()	0	3	1
A	getPreparedItems()	0	3	1
A	setCallbackDataFormat()	0	5	1

<?php

namespace TelegramBot\InlineKeyboardPagination;

use TelegramBot\InlineKeyboardPagination\Exceptions\InlineKeyboardPaginationException;

/**
 * Class InlineKeyboardPagination
 *
 * @package TelegramBot\InlineKeyboardPagination
 */
class InlineKeyboardPagination implements InlineKeyboardPaginator
{
    protected array $items;
    protected int $itemsPerPage;
    protected int $selectedPage;
    protected int $maxButtons = 5;
    protected bool $forceButtonCount = false;
    protected string $command;
    protected string $callbackDataFormat = 'command={COMMAND}&oldPage={OLD_PAGE}&newPage={NEW_PAGE}';
    protected array $labels = [
        'default'  => '%d',
        'first'    => '« %d',
        'previous' => '‹ %d',
        'current'  => '· %d ·',
        'next'     => '%d ›',
        'last'     => '%d »',
    ];

    /**
     * @param int  $maxButtons
     * @param bool $forceButtonCount
     *
     * @return self
     * @throws InlineKeyboardPaginationException
     */
    public function setMaxButtons(int $maxButtons = 5, bool $forceButtonCount = false): self
    {
        if ($maxButtons < 5 || $maxButtons > 8) {
            throw InlineKeyboardPaginationException::invalidMaxButtons();
        }

        $this->maxButtons       = $maxButtons;
        $this->forceButtonCount = $forceButtonCount;

        return $this;
    }

    /**
     * Get the current callback format.
     *
     * @return string
     */
    public function getCallbackDataFormat(): string
    {
        return $this->callbackDataFormat;
    }

    /**
     * Set the callback_data format.
     *
     * @param string $callbackDataFormat
     *
     * @return self
     */
    public function setCallbackDataFormat(string $callbackDataFormat): self
    {
        $this->callbackDataFormat = $callbackDataFormat;

        return $this;
    }

    /**
     * Return list of keyboard button labels.
     *
     * @return array
     */
    public function getLabels(): array
    {
        return $this->labels;
    }

    /**
     * Set the keyboard button labels.
     *
     * @param array $labels
     *
     * @return self
     */
    public function setLabels(array $labels): self
    {
        $this->labels = $labels;

        return $this;
    }

    /**
     * @inheritdoc
     */
    public function setCommand(string $command = 'pagination'): self
    {
        $this->command = $command;

        return $this;
    }

    /**
     * @inheritdoc
     * @throws InlineKeyboardPaginationException
     */
    public function setSelectedPage(int $selectedPage): self
    {
        $numberOfPages = $this->getNumberOfPages();
        if ($selectedPage < 1 || $selectedPage > $numberOfPages) {
            throw InlineKeyboardPaginationException::pageMustBeBetween(1, $numberOfPages);
        }

        $this->selectedPage = $selectedPage;

        return $this;
    }

    /**
     * Get the number of items shown per page.
     *
     * @return int
     */
    public function getItemsPerPage(): int
    {
        return $this->itemsPerPage;
    }

    /**
     * Set how many items should be shown per page.
     *
     * @param int $itemsPerPage
     *
     * @return self
     * @throws InlineKeyboardPaginationException
     */
    public function setItemsPerPage(int $itemsPerPage): self
    {
        if ($itemsPerPage <= 0) {
            throw InlineKeyboardPaginationException::invalidItemsPerPage();
        }

        $this->itemsPerPage = $itemsPerPage;

        return $this;
    }

    /**
     * Set the items for the pagination.
     *
     * @param array $items
     *
     * @return self
     * @throws InlineKeyboardPaginationException
     */
    public function setItems(array $items): self
    {
        if (empty($items)) {
            throw InlineKeyboardPaginationException::noItems();
        }

        $this->items = $items;

        return $this;
    }

    /**
     * Calculate and return the number of pages.
     *
     * @return int
     */
    public function getNumberOfPages(): int
    {
        return (int) ceil(count($this->items) / $this->itemsPerPage);
    }

    /**
     * TelegramBotPagination constructor.
     *
     * @inheritdoc
     * @throws InlineKeyboardPaginationException
     */
    public function __construct(
        array $items,
        string $command = 'pagination',
        int $selectedPage = 1,
        int $itemsPerPage = 5
    ) {
        $this->setCommand($command);
        $this->setItemsPerPage($itemsPerPage);
        $this->setItems($items);
        $this->setSelectedPage($selectedPage);
    }

    /**
     * @inheritdoc
     * @throws InlineKeyboardPaginationException
     */
    public function getPagination(int $selectedPage = null): array
    {
        if ($selectedPage !== null) {
            $this->setSelectedPage($selectedPage);
        }

        return [
            'items'    => $this->getPreparedItems(),
            'keyboard' => $this->generateKeyboard(),
        ];
    }

    /**
     * Generate the keyboard with the correctly labelled buttons.
     *
     * @return array
     */
    protected function generateKeyboard(): array
    {
        $buttons = $this->generateButtons();
        $buttons = $this->applyButtonLabels($buttons);

        return array_values(array_filter($buttons));
    }

    /**
     * Generate all buttons for this inline keyboard.
     *
     * @return array
     */
    protected function generateButtons(): array
    {
        $numberOfPages = $this->getNumberOfPages();

        $range = ['from' => 2, 'to' => $numberOfPages - 1];

        if ($numberOfPages > $this->maxButtons) {
            $range = $this->generateRange();
        }

        $buttons[1] = $this->generateButton(1);

$buttons was never initialized. Although not strictly required by PHP, it is generally a good practice to add $buttons = array(); before regardless.

        for ($i = $range['from']; $i <= $range['to']; $i++) {
            $buttons[$i] = $this->generateButton($i);
        }
        $buttons[$numberOfPages] = $this->generateButton($numberOfPages);

        return $buttons;
    }

    /**
     * Apply correct text labels to the keyboard buttons.
     *
     * @param array $buttons
     *
     * @return array
     */
    protected function applyButtonLabels(array $buttons): array
    {
        $numberOfPages = $this->getNumberOfPages();

        foreach ($buttons as $page => &$button) {
            $inFirstBlock = max($this->selectedPage, $page) <= 3;
            $inLastBlock  = min($this->selectedPage, $page) >= $numberOfPages - 2;

            $labelKey = 'next';
            if ($page === $this->selectedPage) {
                $labelKey = 'current';
            } elseif ($inFirstBlock || $inLastBlock) {
                $labelKey = 'default';
            } elseif ($page === 1) {
                $labelKey = 'first';
            } elseif ($page === $numberOfPages) {
                $labelKey = 'last';
            } elseif ($page < $this->selectedPage) {
                $labelKey = 'previous';
            }

            $label = $this->labels[$labelKey] ?? '';

            // Remove button for undefined labels.
            if ($label === '') {
                $button = null;
                continue;
            }

            $button['text'] = sprintf($label, $page);
        }

        return $buttons;
    }

    /**
     * Get the range of intermediate buttons for the keyboard.
     *
     * @return array
     */
    protected function generateRange(): array
    {
        $numberOfIntermediateButtons = $this->maxButtons - 2; // Minus first and last buttons.
        $numberOfPages               = $this->getNumberOfPages();

        $from = $this->selectedPage - 1;
        $to   = $this->selectedPage + 1;

        if ($this->selectedPage === 1) {
            $from = 2;
            $to   = $this->maxButtons - 1;
        } elseif ($this->selectedPage === $numberOfPages) {
            $from = $numberOfPages - $numberOfIntermediateButtons;
            $to   = $numberOfPages - 1;
        } elseif ($this->selectedPage === 3) {
            // Special case because this button is in the center of a flexible pagination.
            $to += $numberOfIntermediateButtons - 3;
        } elseif ($this->selectedPage < 3) {
            // First half.
            $from = $this->selectedPage;
            $to   = $this->selectedPage + $numberOfIntermediateButtons - 1;
        } elseif (($numberOfPages - $this->selectedPage) < 3) {
            // Last half.
            $from = $numberOfPages - $numberOfIntermediateButtons;
            $to   = $numberOfPages - 1;
        } elseif ($this->forceButtonCount) {
            $from = (int) max(2, $this->selectedPage - floor($numberOfIntermediateButtons / 2));
            $to   = $from + $numberOfIntermediateButtons - 1;
        }

        return compact('from', 'to');
    }

    /**
     * Generate the button for the passed page.
     *
     * @param int $page
     *
     * @return array
     */
    protected function generateButton(int $page): array
    {
        return [
            'text'          => $page,
            'callback_data' => $this->generateCallbackData($page),
        ];
    }

    /**
     * Generate the callback data for the passed page.
     *
     * @param int $page
     *
     * @return string
     */
    protected function generateCallbackData(int $page): string
    {
        return str_replace(
            ['{COMMAND}', '{OLD_PAGE}', '{NEW_PAGE}'],
            [$this->command, $this->selectedPage, $page],
            $this->callbackDataFormat
        );
    }

    /**
     * Get the prepared items for the selected page.
     *
     * @return array
     */
    protected function getPreparedItems(): array
    {
        return array_slice($this->items, $this->getOffset(), $this->itemsPerPage);
    }

    /**
     * Get the items offset for the selected page.
     *
     * @return int
     */
    protected function getOffset(): int
    {
        return $this->itemsPerPage * ($this->selectedPage - 1);
    }

    /**
     * Get the parameters from the callback query.
     *
     * @todo Possibly make it work for custom formats too?
     *
     * @param string $data
     *
     * @return array
     */
    public static function getParametersFromCallbackData(string $data): array
    {
        parse_str($data, $params);

        return $params;
    }
}