unreal4u\TelegramAPI\TgLog

Complexity

Total Complexity

7

Size/Duplication

Total Lines	141
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

61.53%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	14	2
A	performApiRequest()	0	10	1
A	downloadFile()	0	19	1
A	sendRequestToTelegram()	0	5	1
A	resetObjectValues()	0	5	1
A	composeApiMethodUrl()	0	8	1

<?php

declare(strict_types=1);

namespace unreal4u\TelegramAPI;

use Psr\Log\LoggerInterface;
use React\Promise\Deferred;
use React\Promise\PromiseInterface;
use unreal4u\TelegramAPI\Abstracts\TelegramMethods;
use unreal4u\TelegramAPI\InternalFunctionality\DummyLogger;
use unreal4u\TelegramAPI\InternalFunctionality\PostOptionsConstructor;
use unreal4u\TelegramAPI\InternalFunctionality\TelegramDocument;
use unreal4u\TelegramAPI\InternalFunctionality\TelegramResponse;
use unreal4u\TelegramAPI\Telegram\Types\File;

/**
 * The main API which does it all
 */
class TgLog
{
    /**
     * @var RequestHandlerInterface
     */
    protected $requestHandler;

    /**
     * @var PostOptionsConstructor
     */
    protected $formConstructor;

    /**
     * Stores the token
     * @var string
     */
    private $botToken;

    /**
     * Contains an instance to a PSR-3 compatible logger
     * @var LoggerInterface
     */
    protected $logger;

    /**
     * Stores the API URL from Telegram
     * @var string
     */
    private $apiUrl = '';

    /**
     * @var string
     */
    protected $methodName = '';

    /**
     * TelegramLog constructor.
     *
     * @param string $botToken
     * @param RequestHandlerInterface $handler
     * @param LoggerInterface $logger
     */
    public function __construct(string $botToken, RequestHandlerInterface $handler, LoggerInterface $logger = null)
    {
        $this->botToken = $botToken;

        // Initialize new dummy logger (PSR-3 compatible) if not injected
        if ($logger === null) {
            $logger = new DummyLogger();
        }
        $this->logger = $logger;

        $this->requestHandler = $handler;
        $this->formConstructor = new PostOptionsConstructor();
        $this->apiUrl = 'https://api.telegram.org/bot' . $this->botToken . '/';
    }

    /**
     * @param TelegramMethods $method
     *
     * @return PromiseInterface
     */
    public function performApiRequest(TelegramMethods $method)
    {
        $this->logger->debug('Request for async API call, resetting internal values', [get_class($method)]);
        $this->resetObjectValues();
        $option = $this->formConstructor->constructOptions($method);
        return $this->sendRequestToTelegram($method, $option)
            ->then(function (TelegramResponse $response) use ($method) {
                return $method::bindToObject($response, $this->logger);
            });
    }

    /**
     * @param File $file
     *
     * @return PromiseInterface
     */
    public function downloadFile(File $file): PromiseInterface
    {
        $this->logger->debug('Downloading file async from Telegram, creating URL');
        $url = 'https://api.telegram.org/file/bot' . $this->botToken . '/' . $file->file_path;
        $this->logger->debug('About to perform request to begin downloading file');

        $deferred = new Deferred();

        $this->requestHandler->get($url)->then(
            function (TelegramResponse $rawData) use ($deferred) {
                $deferred->resolve(new TelegramDocument($rawData));
            },
            function (\Exception $exception) use ($deferred) {
                $deferred->reject($exception);
            }
        );
        
        return $deferred->promise();
    }

    /**
     * @param TelegramMethods $method
     * @param array $formData
     *
     * @return PromiseInterface
     */
    protected function sendRequestToTelegram(TelegramMethods $method, array $formData): PromiseInterface
    {
        $this->logger->debug('About to perform async HTTP call to Telegram\'s API');
        return $this->requestHandler->post($this->composeApiMethodUrl($method), $formData);
    }

    /**
     * Resets everything to the default values
     *
     * @return TgLog
     */
    private function resetObjectValues(): TgLog
    {
        $this->formConstructor->formType = 'application/x-www-form-urlencoded';
        return $this;
    }

    /**
     * Builds up the URL with which we can work with
     *
     * All methods in the Bot API are case-insensitive.
     * All queries must be made using UTF-8.
     *
     * @see https://core.telegram.org/bots/api#making-requests
     *
     * @param TelegramMethods $call
     * @return string
     */
    protected function composeApiMethodUrl(TelegramMethods $call): string
    {
        $completeClassName = get_class($call);
        $this->methodName = substr($completeClassName, strrpos($completeClassName, '\\') + 1);
        $this->logger->info('About to perform API request', ['method' => $this->methodName]);

        return $this->apiUrl . $this->methodName;
    }
}