TelegramBot\Bot

Complexity

Total Complexity

18

Size/Duplication

Total Lines	141
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

58.46%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	setClient()	0	3	1
A	poll()	0	5	1
A	_handlePollResponse()	0	4	1
A	_handlePollData()	0	18	3
A	_handlePollError()	0	4	1
A	setUpdateId()	0	3	1
A	getResponder()	0	5	1
A	getMassagesRequest()	0	6	1
A	sendResponse()	0	15	1
A	botCommand()	0	5	2
A	assembleUri()	0	8	1
A	getResponseHeaders()	0	6	1
A	postDataEncoder()	0	9	2

<?php

namespace TelegramBot;

use React\HttpClient\Client;
use React\HttpClient\Request;
use React\HttpClient\Response;

class Bot implements BotInterface {

  use \League\Event\EmitterTrait;

  /** @var string */
  private $botToken;
  /** @var int */
  private $offset;
  /** @var \React\HttpClient\Client */
  private $client;

  /**
   * @param string $botToken
   */
  public function __construct(string $botToken)
  {
      $this->botToken = $botToken;
  }

  /**
   * @param \React\HttpClient\Client
   */
  public function setClient(Client $client) {
    $this->client = $client;
  }

  public function poll() {
    $request = $this->getMassagesRequest();
    $request->on('response', [$this, '_handlePollResponse']);
    $request->end();
  }

  /**
   * @param \React\HttpClient\Response $response
   */
  public function _handlePollResponse(Response $response) {
    $response->on('data', [$this, '_handlePollData']);
    $response->on('error', [$this, '_handlePollError']);
  }

  /**
   * @param array $data
   * @param \React\HttpClient\Response $response
   */
  public function _handlePollData($data, $response) {

The parameter $response is not used and could be removed.

    $data = json_decode($data, 1);
    $messageData = $data['result'];

    foreach ($messageData as $message) {

      if (!isset($message['message']['text'])) {
        continue;
      }

      $this->getEmitter()->emit(
        $message['message']['text'],
        ['message' => $message, 'responder' => $this->getResponder($message)]

The call to EmitterInterface::emit() has too many arguments starting with array('message' => $message, 'responder' => $this->getResponder($message)).

      );

      $this->setUpdateId($message['update_id']);
    }
  }

  /**
   * @param \React\HttpClient\Response $response
   */
  public function _handlePollError(Response $response) {
    print('Error: ');
    print_r($response);
  }

  /**
   * @param string $message
   */
  public function getResponder($message) {
    return function ($text) use($message){
        $this->sendResponse($text, $message);

$message is of type string, but the function expects a array.

    };
  }

  public function getMassagesRequest(): Request {
    return $this->client->request(
      'GET',
      $this->botCommand('getUpdates', ['offset' => $this->offset])
    );
  }

  public function sendResponse(string $responseText, array $incomingMessage) {
    $responseData = $this->postDataEncoder([
      'chat_id' => $incomingMessage['message']['chat']['id'],
      'reply_to_message_id' => $incomingMessage['message']['message_id'],
      'text' => $responseText
    ]);

    $responseCall = $this->client->request(
      'POST',
      $this->botCommand('sendMessage'),
      $this->getResponseHeaders($responseData)
    );

    $responseCall->end($responseData);
  }

  public function setUpdateId($id) {
    $this->offset = $id+1;
  }


  private function botCommand(string $command, array $params = []) :string {
    $params = (count($params)) ? '?' . $this->postDataEncoder($params) : '';

    return $this->assembleUri($command, $params);
  }


  private function assembleUri($command, $params) :string {
    return sprintf(
      'https://api.telegram.org/bot%s/%s%s',
      $this->botToken,
      $command,
      $params
    );
  }

  public function getResponseHeaders(string $responseString) :array {
    return [
      'Content-Type' =>  'application/x-www-form-urlencoded',
      'Content-Length' => strlen($responseString)
    ];
  }

  private function postDataEncoder(array $data) :string {
    $string = '';

    foreach ($data as $k => $v) {
      $string .= $k . '=' . urlencode($v) . '&';
    }

    return $string;
  }
}