File Coverage

blib/lib/Net/AppNotifications.pm

Criterion	Covered	Total	%
statement	21	129	16.2
branch	0	28	0.0
condition	0	22	0.0
subroutine	7	26	26.9
pod	0	7	0.0
total	28	212	13.2

package Net::AppNotifications;

use strict;
use 5.008_001;
our $VERSION = '0.03';
use AnyEvent::HTTP;
use Carp;
use URI::Escape 'uri_escape_utf8';

use constant POST_URI =>
    q{https://www.appnotifications.com/account/notifications.xml};

use constant KEY_URI =>
    q{https://www.appnotifications.com/account/user_session.xml};

sub new {
    my $class = shift;
    my %param = @_;
    my $notifier = bless { %param }, ref $class || $class;
    unless ($param{key}) {
        $param{key} = $class->get_key( %param );
    }
    croak "Key (or valid email, pass to get it) is needed" unless $param{key};
    return $notifier;
}

sub send {
    my $notifier = shift;

    my %cbs;
    my $key    = $notifier->{key};
    my $finish = sub {};
    my %param;

    if (scalar @_ == 1) {
        my $message = shift;
        unless (defined $message && length $message) {
            croak "Please, give me a message to push";
        }
        $param{message} = $message;

        my $done = AnyEvent->condvar;

        $cbs{on_posted} = sub {
            my ($data, $hds) = @_;
            $done->send;
            croak "Something happend" unless defined $data;
        };

        $cbs{on_timeout} = sub {
            $done->send;
            croak "timeout";
        };
        $cbs{on_error} = sub {
            $done->send;
            croak "Error $_[0]";
        };

        $finish = sub {
            $done->recv;
        };
    }
    else {
        %param = @_;

        $cbs{$_} = $param{$_} for qw{on_error on_timeout};

        my $early_error = $cbs{on_error} || sub { croak "$_[0]" };

        my $on_success = $param{on_success};
        unless ($on_success) {
            $early_error->("On success must be passed");
            return;
        }

        ## callback definitions
        $cbs{on_posted} = sub {
            my $data = shift;
            unless (defined $data) {
                $cbs{on_error}->("Something happened");
                return;
            }
            $on_success->($data, @_);
        };

        $cbs{on_error} ||= sub {
            warn "Error: $_[0]";
        };

        $cbs{on_timeout} ||= sub {
            warn "Timeout: $_[0]";
        };
    }
    my $notification_params = $notifier->normalize(%param);

    my $uri  = POST_URI;
    my $body = build_body(
        "user_credentials" => $key,
        %$notification_params,
    );
    $notifier->post_request($uri, $body, %cbs);

    ## wait here for synchronous calls
    $finish->();
    return;
}

sub normalize {
    my $notifier = shift;
    my %param    = @_;

    my %nparam;
    my $N = "notification";

    my @keys = qw/
        message message_level action_loc_key run_command
        title long_message long_message_preview
        icon_url subtitle
    /;
    for (@keys) {
        next unless exists $param{$_};
        $nparam{"${N}[$_]"} = $param{$_} || "";
    }

    my $silent = 0;
    my $sound  = $param{sound};
    if ($sound) {
        unless ($sound =~ /^[1..7]$/) {
            $sound = "1";
        }
        $sound .= ".caf";
    }

    if (my $s = $param{silent}) {
        $s = lc $s;
        unless ($s eq 'off' or $s eq 'no' or $s eq 'false') {
            $silent = 1;
            $sound  = undef;
        }
    }
    $nparam{"${N}[silent]"} = $silent;
    $nparam{"${N}[sound]"}  = $sound || "";

    return \%nparam;
}

sub post_request {
    my $notifier = shift;
    my ($uri, $body, %cbs) = @_;

    http_request
        POST      => $uri,
        body      => $body,
        headers   => {
            'Content-Type' => 'application/x-www-form-urlencoded',
            'User-Agent'   => q{yann's Net::AppNotifications},
        },
        on_header => sub {
            my ($hds) = @_;
            if ($hds->{Status} ne '200') {
                return $cbs{on_error}->("$hds->{Status}: $hds->{Reason}");
            }
            return 1;
        },
        $cbs{on_posted};
    return
}

sub get_key {
    my $class = shift;

    my $done = AnyEvent->condvar;
    my $key;
    my $got_key = sub { $key = shift; $done->send };

    $class->async_get_key( @_, got_key => $got_key );

    $done->recv;
    return $key;
}

sub async_get_key {
    my $class = shift;
    my %param = shift;

    my $email    = $param{email} or return;
    my $password = $param{password};
    my $uri      = KEY_URI;

    my $body     = build_body(
       'user_session[email]'    => $email,
       'user_session[password]' => $password,
    );
    my %cbs = (
        on_posted => sub {
            my $key = shift;
            $param{got_key}->($key);
        },
    );
    $class->post_request($uri, $body, %cbs);
    return;
}

sub build_body {
    my %param = @_;
    return
        join "&", map {
            join "=", $_, uri_escape_utf8($param{$_})
        }
        keys %param;
}


1;
__END__