File Coverage

blib/lib/Telegram/Bot/Brain.pm

Criterion	Covered	Total	%
statement	69	302	22.8
branch	14	138	10.1
condition	0	93	0.0
subroutine	17	39	43.5
pod	10	19	52.6
total	110	591	18.6

package Telegram::Bot::Brain;
$Telegram::Bot::Brain::VERSION = '0.029';
# ABSTRACT: A base class to make your very own Telegram bot


use Mojo::Base -base;

use strict;
use warnings;

use Mojo::IOLoop;
use Mojo::UserAgent;
use Mojo::JSON qw/to_json/;
use Carp qw/croak/;
use Log::Any;
use Data::Dumper;

use Telegram::Bot::Object::Message;
use Telegram::Bot::Object::InlineQuery;
use Telegram::Bot::Object::CallbackQuery;
use Telegram::Bot::Object::ChatJoinRequest;
use Telegram::Bot::Object::ChatMemberUpdated;
use Telegram::Bot::Object::ChatMember;

# base class for building telegram robots with Mojolicious
has longpoll_time => 60;
has ua         => sub { Mojo::UserAgent->new->inactivity_timeout(shift->longpoll_time + 15) };
has token      => sub { croak "you need to supply your own token"; };

has tasks      => sub { [] };
has listeners  => sub { [] };

has log        => sub { Log::Any->get_logger };


sub add_repeating_task {
  my $self    = shift;
  my $seconds = shift;
  my $task    = shift;

  my $repeater = sub {

    # Perform operation every $seconds seconds
    my $last_check = time();
    Mojo::IOLoop->recurring(0.1 => sub {
                              my $loop = shift;
                              my $now  = time();
                              return unless ($now - $last_check) >= $seconds;
                              $last_check = $now;
                              $task->($self);
                            });
  };

  # keep a copy
  push @{ $self->tasks }, $repeater;

  # kick it off
  $repeater->();
}


sub add_listener {
  my $self    = shift;
  my $coderef = shift;

  push @{ $self->listeners }, $coderef;
}

sub init {
  die "init was not overridden!";
}


sub think {
  my $self = shift;
  $self->init();

  $self->_add_getUpdates_handler;
  Mojo::IOLoop->start unless Mojo::IOLoop->is_running;
}



sub getMe {
  my $self = shift;
  my $token = $self->token || croak "no token?";

  my $url = "https://api.telegram.org/bot${token}/getMe";
  my $api_response = $self->_post_request($url);

  return Telegram::Bot::Object::User->create_from_hash($api_response, $self);
}


sub sendMessage {
  my $self = shift;
  my $args = shift || {};

  my $send_args = {};
  croak "no chat_id supplied" unless $args->{chat_id};
  $send_args->{chat_id} = $args->{chat_id};

  croak "no text supplied"    unless $args->{text};
  $send_args->{text}    = $args->{text};

  # these are optional, send if they are supplied
  $send_args->{parse_mode} = $args->{parse_mode} if exists $args->{parse_mode};
  $send_args->{disable_web_page_preview} = $args->{disable_web_page_preview} if exists $args->{disable_web_page_preview};
  $send_args->{disable_notification} = $args->{disable_notification} if exists $args->{disable_notification};
  $send_args->{reply_parameters}     = to_json($args->{reply_parameters}->as_hashref)
      if exists $args->{reply_parameters};
  # deprecated reply_to_message_id
  if (exists $args->{reply_to_message_id}) {
      $send_args->{reply_parameters} = to_json({message_id => $args->{reply_to_message_id}});
  }
  # $send_args->{reply_to_message_id}  = $args->{reply_to_message_id}  if exists $args->{reply_to_message_id};

  # check reply_markup is the right kind
  if (exists $args->{reply_markup}) {
    my $reply_markup = $args->{reply_markup};
    die "bad reply_markup supplied"
      if ( ref($reply_markup) ne 'Telegram::Bot::Object::InlineKeyboardMarkup' &&
           ref($reply_markup) ne 'Telegram::Bot::Object::ReplyKeyboardMarkup'  &&
           ref($reply_markup) ne 'Telegram::Bot::Object::ReplyKeyboardRemove'  &&
           ref($reply_markup) ne 'Telegram::Bot::Object::ForceReply' );
    $send_args->{reply_markup} = to_json($reply_markup->as_hashref);
  }

  my $token = $self->token || croak "no token?";
  my $url = "https://api.telegram.org/bot${token}/sendMessage";
  my $api_response = $self->_post_request($url, $send_args);

  return Telegram::Bot::Object::Message->create_from_hash($api_response, $self);
}


sub forwardMessage {
  my $self = shift;
  my $args = shift || {};
  my $send_args = {};
  croak "no chat_id supplied" unless $args->{chat_id};
  $send_args->{chat_id} = $args->{chat_id};

  croak "no from_chat_id supplied"    unless $args->{from_chat_id};
  $send_args->{from_chat_id}    = $args->{from_chat_id};

  croak "no message_id supplied"    unless $args->{message_id};
  $send_args->{message_id}    = $args->{message_id};

  # these are optional, send if they are supplied
  $send_args->{disable_notification} = $args->{disable_notification} if exists $args->{disable_notification};

  my $token = $self->token || croak "no token?";
  my $url = "https://api.telegram.org/bot${token}/forwardMessage";
  my $api_response = $self->_post_request($url, $send_args);

  return Telegram::Bot::Object::Message->create_from_hash($api_response, $self);
}


sub deleteMessage {
  my $self = shift;
  my $args = shift || {};
  my $send_args = {};
  croak "no message_id supplied" unless $args->{message_id};
  $send_args->{message_id} = $args->{message_id};

  my $token = $self->token || croak "no token?";
  my $url = "https://api.telegram.org/bot${token}/deleteMessage";
  my $api_response = $self->_post_request($url, $send_args);

  return $api_response;
}

sub editMessageText {
  my $self = shift;
  my $args = shift || {};
  my $send_args = {};
  croak "no chat_id supplied" unless $args->{chat_id};
  $send_args->{chat_id} = $args->{chat_id};
  croak "no message_id supplied"    unless $args->{message_id};
  $send_args->{message_id}    = $args->{message_id};

  # these are optional, send if they are supplied
  $send_args->{text} = $args->{text} if exists $args->{text};
  $send_args->{parse_mode} = $args->{parse_mode} if exists $args->{parse_mode};
  $send_args->{disable_web_page_preview} = $args->{disable_web_page_preview} if exists $args->{disable_web_page_preview};

  if (exists $args->{reply_markup}) {
    my $reply_markup = $args->{reply_markup};
    die "bad reply_markup supplied"
      if ( ref($reply_markup) ne 'Telegram::Bot::Object::InlineKeyboardMarkup' &&
           ref($reply_markup) ne 'Telegram::Bot::Object::ReplyKeyboardMarkup'  &&
           ref($reply_markup) ne 'Telegram::Bot::Object::ReplyKeyboardRemove'  &&
           ref($reply_markup) ne 'Telegram::Bot::Object::ForceReply' );
    $send_args->{reply_markup} = to_json($reply_markup->as_hashref);
  }
  my $token = $self->token || croak "no token?";
  my $url = "https://api.telegram.org/bot${token}/editMessageText";
  my $api_response = $self->_post_request($url, $send_args);

  return Telegram::Bot::Object::Message->create_from_hash($api_response, $self);

}


sub sendPhoto {
  my $self = shift;
  my $args = shift || {};

  croak "no chat_id supplied" unless $args->{chat_id};

  # photo can be a string (which might be either a URL for telegram servers
  # to fetch, or a file_id string) or a file on disk to upload - we need
  # to handle that last case here as it changes the way we create the HTTP
  # request
  croak "no photo supplied" unless $args->{photo};
  if (-e $args->{photo}) {
    $args->{photo} = { file => $args->{photo} };
  }

  my $token = $self->token || croak "no token?";
  my $url = "https://api.telegram.org/bot${token}/sendPhoto";
  my $api_response = $self->_post_request($url, $args);

  return Telegram::Bot::Object::Message->create_from_hash($api_response, $self);
}


sub sendDocument {
  my $self = shift;
  my $args = shift || {};
  my $send_args = {};

  croak "no chat_id supplied" unless $args->{chat_id};
  $send_args->{chat_id} = $args->{chat_id};

  # document can be a string (which might be either a URL for telegram servers
  # to fetch, or a file_id string) or a file on disk to upload - we need
  # to handle that last case here as it changes the way we create the HTTP
  # request
  croak "no document supplied" unless $args->{document};
  if (-e $args->{document}) {
    $send_args->{document} = { document => { file => $args->{document} } };
  }
  else {
    $send_args->{document} = $args->{document};
  }

  my $token = $self->token || croak "no token?";
  my $url = "https://api.telegram.org/bot${token}/sendDocument";
  my $api_response = $self->_post_request($url, $send_args);

  return Telegram::Bot::Object::Message->create_from_hash($api_response, $self);
}


sub answerInlineQuery {
  my $self = shift;
  my $args = shift || {};
  my $send_args = {};

  croak "no inline_query_id supplied" unless $args->{inline_query_id};
  $send_args->{inline_query_id} = $args->{inline_query_id};

  croak "no results supplied" unless $args->{results};
  $send_args->{results} = $args->{results};

  # these are optional, send if they are supplied
  $send_args->{cache_time} = $args->{cache_time} if exists $args->{cache_time};
  $send_args->{is_personal} = $args->{is_personal} if exists $args->{is_personal};
  $send_args->{next_offset} = $args->{next_offset} if exists $args->{next_offset};
  $send_args->{button} = $args->{button} if exists $args->{button};

  my $token = $self->token || croak "no token?";
  my $url = "https://api.telegram.org/bot${token}/answerInlineQuery";
  my $api_response = $self->_post_request($url, $send_args);

  return $api_response;
}

sub setMyCommands {
  my $self = shift;
  my $args = shift || {};

  my $send_args = {};
  croak "no commands supplied" unless $args->{commands};
  $send_args->{commands} = to_json $args->{commands};
  $send_args->{language_code} = $args->{language_code} if ($args->{language_code}//'') ne '';
  my $token = $self->token || croak "no token?";
  my $url = "https://api.telegram.org/bot${token}/setMyCommands";
  return $self->_post_request($url, $send_args);
}

sub answerCallbackQuery {
  my $self = shift;
  my $args = shift || {};

  my $answer_args = {};
  croak "no callback_query_id supplied" unless $args->{callback_query_id};
  $answer_args->{callback_query_id} = $args->{callback_query_id};

  # optional args
  $answer_args->{text} = $args->{text} if exists $args->{text};
  $answer_args->{show_alert} = $args->{show_alert} if exists $args->{show_alert};
  $answer_args->{url} = $args->{url} if exists $args->{url};
  $answer_args->{cache_time} = $args->{cache_time} if exists $args->{cache_time};
  my $token = $self->token || croak "no token?";
  my $url = "https://api.telegram.org/bot${token}/answerCallbackQuery";
  my $api_response = $self->_post_request($url, $answer_args);

  return 1;
}

sub getChatMember {
  my $self = shift;
  my $chat_id = shift;
  my $user_id = shift;

  my $gcm_args = {};
  croak "no chat_id supplied to getChatMember" unless $chat_id;
  croak "no user_id supplied to getChatMember" unless $user_id;
  $gcm_args->{user_id} = $user_id;
  $gcm_args->{chat_id} = $chat_id;

  my $token = $self->token || croak "no token?";
  my $url = "https://api.telegram.org/bot${token}/getChatMember";
  my $api_response = $self->_post_request($url, $gcm_args);

  return Telegram::Bot::Object::ChatMember->create_from_hash($api_response, $self);
}

sub approveChatJoinRequest {
  my $self = shift;
  my $args = shift || {};

  my $answer_args = {};
  croak "no chat_id supplied" unless $args->{chat_id};
  $answer_args->{chat_id} = $args->{chat_id};
  croak "no user_id supplied" unless $args->{user_id};
  $answer_args->{user_id} = $args->{user_id};

  # no optional args

  my $token = $self->token || croak "no token?";
  my $url =  "https://api.telegram.org/bot${token}/approveChatJoinRequest";
  my $api_response = $self->_post_request($url, $answer_args);

  return 1;
}

sub declineChatJoinRequest {
  my $self = shift;
  my $args = shift || {};

  my $answer_args = {};
  croak "no chat_id supplied" unless $args->{chat_id};
  $answer_args->{chat_id} = $args->{chat_id};
  croak "no user_id supplied" unless $args->{user_id};
  $answer_args->{user_id} = $args->{user_id};

  # no optional args

  my $token = $self->token || croak "no token?";
  my $url =  "https://api.telegram.org/bot${token}/declineChatJoinRequest";
  my $api_response = $self->_post_request($url, $answer_args);

  return 1;
}

sub banChatMember {
  my $self = shift;
  my $args = shift || {};

  my $answer_args = {};
  croak "no chat_id supplied" unless $args->{chat_id};
  $answer_args->{chat_id} = $args->{chat_id};
  croak "no user_id supplied" unless $args->{user_id};
  $answer_args->{user_id} = $args->{user_id};

  # optional args
  $answer_args->{until_date} = $args->{until_date} if exists $args->{until_date};
  $answer_args->{revoke_messages} = $args->{revoke_messages} if exists $args->{revoke_messages};

  my $token = $self->token || croak "no token?";
  my $url =  "https://api.telegram.org/bot${token}/banChatMember";
  my $api_response = $self->_post_request($url, $answer_args);

  return 1;
}

sub unbanChatMember {
  my $self = shift;
  my $args = shift || {};

  my $answer_args = {};
  croak "no chat_id supplied" unless $args->{chat_id};
  $answer_args->{chat_id} = $args->{chat_id};
  croak "no user_id supplied" unless $args->{user_id};
  $answer_args->{user_id} = $args->{user_id};

  # optional args
  $answer_args->{only_if_banned} = $args->{only_if_banned} if exists $args->{only_if_banned};

  my $token = $self->token || croak "no token?";
  my $url =  "https://api.telegram.org/bot${token}/unbanChatMember";
  my $api_response = $self->_post_request($url, $answer_args);

  return 1;
}

sub _add_getUpdates_handler {
  my $self = shift;

  my $http_active = 0;
  my $last_update_id = -1;
  my $token  = $self->token;

  Mojo::IOLoop->recurring(0.1 => sub {
    # do nothing if our previous longpoll is still going
    return if $http_active;

    my $offset = $last_update_id + 1;
    my $updateURL = "https://api.telegram.org/bot${token}/getUpdates?offset=${offset}&timeout=60";
    $http_active = 1;

    $self->ua->get_p($updateURL)->then(sub {
      my ($tx) = @_;
      my $res = $tx->res->json;
      my $items = $res->{result};
      foreach my $item (@$items) {
        $last_update_id = $item->{update_id};
        $self->_process_message($item);
      }

      $http_active = 0;
    })->catch(sub {
      my ($error) = @_;
      warn "Connection error: $error";

      $http_active = 0;
    });
  });
}

# process a message which arrived via getUpdates
sub _process_message {
    my $self = shift;
    my $item = shift;

    my $update_id = $item->{update_id};
    # There can be several types of responses. But only one response.
    # https://core.telegram.org/bots/api#update
    my $update;
    $update = Telegram::Bot::Object::Message->create_from_hash($item->{message}, $self)             if $item->{message};
    $update = Telegram::Bot::Object::Message->create_from_hash($item->{edited_message}, $self)      if $item->{edited_message};
    $update = Telegram::Bot::Object::Message->create_from_hash($item->{channel_post}, $self)        if $item->{channel_post};
    $update = Telegram::Bot::Object::Message->create_from_hash($item->{edited_channel_post}, $self) if $item->{edited_channel_post};
    $update = Telegram::Bot::Object::InlineQuery->create_from_hash($item->{inline_query}, $self)    if $item->{inline_query};
    $update = Telegram::Bot::Object::Message->create_from_hash($item->{my_chat_member}, $self)      if $item->{my_chat_member};		# after v0.025
    $update = Telegram::Bot::Object::CallbackQuery->create_from_hash($item->{callback_query}, $self) if $item->{callback_query};
    $update = Telegram::Bot::Object::ChatJoinRequest->create_from_hash($item->{chat_join_request}, $self) if $item->{chat_join_request};
    $update = Telegram::Bot::Object::ChatMemberUpdated->create_from_hash($item->{chat_member}, $self) if $item->{chat_member};
    $update = Telegram::Bot::Object::ChatMemberUpdated->create_from_hash($item->{my_chat_member}, $self) if $item->{my_chat_member};
    # chat_member => someone else
    # my_chat_member => actually us

    # if we got to this point without creating a response, it must be a type we
    # don't handle yet
    if (! $update) {
      warn "Do not know how to handle this update: " . Dumper($item);
      return;
    }

    foreach my $listener (@{ $self->listeners }) {
      # call the listener code, supplying ourself and the update
      $listener->($self, $update);
    }
}


sub _post_request {
  my $self = shift;
  my $url  = shift;
  my $form_args = shift || {};

  my $res = $self->ua->post($url, form => $form_args)->result;
  if    ($res->is_success) { return $res->json->{result}; }
  elsif ($res->is_error)   { warn "Failed to post: " . $res->json->{description} . "\n" . Data::Dumper::Dumper($form_args); }
  else                     { die "Not sure what went wrong"; }
}


1;

__END__