File Coverage

blib/lib/Net/Mattermost/Bot.pm

Criterion	Covered	Total	%
statement	32	110	29.0
branch	0	32	0.0
condition	0	14	0.0
subroutine	11	28	39.2
pod	5	7	71.4
total	48	191	25.1

package Net::Mattermost::Bot;

use 5.6.1;

use Carp qw(carp croak);
use Furl;
use HTTP::Status ':is';
use JSON::MaybeXS qw(encode_json decode_json);
use List::Util 'pairs';
use Mojo::IOLoop;
use Mojo::UserAgent;
use Moo;
use MooX::HandlesVia;
use Types::Standard qw(ArrayRef Bool HashRef Int Object Str);

our $VERSION = '0.04';

################################################################################

has base_url  => (is => 'ro', isa => Str, required => 1);
has team_name => (is => 'ro', isa => Str, required => 1);
has username  => (is => 'ro', isa => Str, required => 1);
has password  => (is => 'ro', isa => Str, required => 1);

has debug         => (is => 'ro', isa => Bool,    default => 0);
has ping_interval => (is => 'ro', isa => Int,     default => 15);
has ssl_opts      => (is => 'ro', isa => HashRef, default => sub { {} });
has token         => (is => 'rw', isa => Str,     default => '');
has user_id       => (is => 'rw', isa => Str,     default => '');

has api_url   => (is => 'ro', isa => Str,      lazy => 1, builder => '_build_api_url');
has endpoints => (is => 'ro', isa => HashRef,  lazy => 1, builder => '_build_endpoints');
has furl      => (is => 'ro', isa => Object,   lazy => 1, builder => '_build_furl');
has headers   => (is => 'rw', isa => ArrayRef, lazy => 1, builder => '_build_headers',
    handles_via => 'Array',
    handles     => { add_header => 'push' });
has ws_url    => (is => 'ro', isa => Str,      lazy => 1, builder => '_build_ws_url');

################################################################################

sub connect {
    my $self = shift;

    my $login_endpoint = sprintf('%s/users/login', $self->api_url);

    my $init = $self->furl->post($login_endpoint, $self->headers, encode_json({
        name     => $self->team_name,
        login_id => $self->username,
        password => $self->password,
    }));

    my $out = decode_json($init->{content});

    if ($out->{status_code} && !is_success($init->{status_code})) {
        croak $out->{message};
    }

    if ($init->header('Token')) {
        $self->token($init->header('Token'));
        $self->user_id($out->{id});
        $self->add_header(
            Cookie        => sprintf('MMAUTHTOKEN=%s', $self->token),
            Authorization => sprintf('Bearer %s', $self->token),
            'Keep-Alive'  => 1,
        );
    } else {
        croak 'Unauthorized';
    }

    $self->event_connected();
    $self->_start();

    return 1;
}

sub handle_message {
    my $self    = shift;
    my $content = shift;

    # Filter out empty responses and messages from ourself
    return unless $content && $content->{event};

    if ($content->{data}->{post}) {
        my $post_data = decode_json($content->{data}->{post});

        return if $post_data->{user_id} eq $self->user_id;
    }

    my $output;

    if ($content->{event} eq 'hello') {
        if ($self->debug) {
            carp sprintf('Sending auth token (token: %s) at %d', $self->token, time());
        }

        $output = {
            seq    => 1,
            action => 'authentication_challenge',
            data   => { token => $self->token },
        };
    } elsif ($content->{event} eq 'typing') {
        $output = $self->event_typing($content);
    } elsif ($content->{event} eq 'channel_viewed') {
        $output = $self->event_channel_viewed($content);
    } elsif ($content->{event} eq 'posted') {
        $output = $self->event_posted($content);
    } else {
        $output = $self->event_generic($content);
    }

    return $output;
}

# Override these
sub event_connected      {}
sub event_typing         {}
sub event_channel_viewed {}
sub event_posted         {}
sub event_generic        {}

################################################################################

sub _start {
    my $self = shift;

    my $ua = Mojo::UserAgent->new();
    my ($id, $ping_loop_id);

    $ua->on('start' => sub {
        my ($ua, $tx) = @_;

        carp 'Started' if $self->debug;

        $tx->req->headers->header($_->[0] => $_->[1]) foreach pairs @{$self->headers};
    });

    $id = $ua->websocket($self->ws_url => sub {
        my ($ua, $tx) = @_;

        my $last = 0;

        croak 'Websocket handshake failed' unless $tx->is_websocket;

        $ping_loop_id = Mojo::IOLoop->recurring($self->ping_interval => sub {
            my $loop = shift;

            carp 'Ping '.time() if $self->debug;

            $tx->send(encode_json({ seq => ++$last, action => 'ping' }));
        });

        $tx->on(finish => sub {
            my ($tx, $code, $reason) = @_;
            carp sprintf('Finished (%d: %s)', $code, $reason // 'Unknown');
            return Mojo::IOLoop->remove($ping_loop_id);
        });

        $tx->on(message => sub {
            my ($tx, $message) = @_;

            my $content = decode_json($message);
            my $ret     = $self->handle_message($content);

            $last = $content->{seq};

            $tx->send(encode_json($ret->{ws_send})) if $ret && ref $ret eq 'HASH' && $ret->{ws_send};
        });
    });

    Mojo::IOLoop->start() unless Mojo::IOLoop->is_running();
}

sub _format_mm_url {
    my $self = shift;
    my $end  = shift;

    return sprintf('%s/%s', $self->base_url, $end);
}

sub _post_to_channel {
    my $self = shift;
    my $args = shift;

    unless ($args->{channel_id}) {
        carp 'No channel_id provided - could not send to channel';
        return;
    }

    return $self->furl->post($self->endpoints->{channel_msg}, $self->headers, encode_json($args));
}

################################################################################

sub _build_endpoints {
    my $self = shift;

    my $base = $self->api_url;

    return {
        channel_msg => sprintf('%s/posts', $base),
    };
}

sub _build_furl {
    my $self = shift;

    return Furl->new(ssl_opts => $self->ssl_opts);
}

sub _build_headers {
    # Initial headers, added to at connection
    return [
        'Content-Type'     => 'application/json',
        'X-Requested-With' => 'XMLHttpRequest',
    ];
}

sub _build_api_url {
    my $self = shift;

    return $self->_format_mm_url('api/v4');
}

sub _build_ws_url {
    my $self = shift;

    my $url = $self->_format_mm_url('api/v4/websocket');

    $url =~ s/^http(?:s)?/wss/s;

    return $url;
}

################################################################################

1;
__END__