File Coverage

blib/lib/WebService/IdoitAPI.pm

Criterion	Covered	Total	%
statement	70	113	61.9
branch	23	50	46.0
condition			n/a
subroutine	11	14	78.5
pod	6	6	100.0
total	110	183	60.1

# vim: set sw=4 ts=4 et si ai:
#
package WebService::IdoitAPI;

use 5.006;
use strict;
use warnings;

use Carp;
use JSON::RPC::Legacy::Client;

our $VERSION = 'v0.2.2';

my @CONFIG_VARS = qw(apikey password url username);

sub new {
    my ($class,$config) = @_;
    my $self = {
        config => {},
        version => '2.0',
    };

    bless($self, $class);
    if (defined $config) {
        for my $cv (@CONFIG_VARS) {
            if (exists $config->{$cv}) {
                $self->{config}->{$cv} = $config->{$cv};
            }
        }
        $self->_test_minimum_config();
    }
    return $self;
} # new()

sub DESTROY {
    my $self = shift;

    if ($self->is_logged_in()) {
        $self->logout();
    }
    return;
} # DESTROY()

sub request {
    my ($self,$request) = @_;
    if (defined $request) {
        my $client;
        if (exists $self->{client}) {
            $client = $self->{client};
        }
        else {
            $client = new JSON::RPC::Legacy::Client;
            $self->{client} = $client;
            if ($self->{session_id}) {
                $client->{ua}->default_header('X-RPC-Auth-Session' => $self->{session_id});
            }
            else {
                if (defined $self->{config}->{password}) {
                    $client->{ua}->default_header( 'X-RPC-Auth-Password' => $self->{config}->{password} );
                }
                if (defined $self->{config}->{username}) {
                    $client->{ua}->default_header( 'X-RPC-Auth-Username' => $self->{config}->{username} );
                }
            }
        }
        $request->{version} = "2.0"
            unless (defined $request->{version});
        $request->{id} = 1
            unless (defined $request->{id});
        $request->{params}->{language} = 'en'
            unless (defined $request->{params}->{language});
        $request->{params}->{apikey} = $self->{config}->{apikey};

        my $res = do {
            local $@;
            my $ret;
            eval { $ret = $client->call($self->{config}->{url},$request); 1};
            if ( $@ ) {
                my $status_line = $self->{client}->{status_line};
                if ( $status_line !~ /^2[0-9]{2} / ) {
                    die "Connection problem: $status_line";
                }
                die "JSON RPC client failed: $@";
            }
            $ret;
        };
        return $res;
    }
    return;
} # request()

sub login {
    my ($self,$user,$pass) = @_;

    $user = $self->{config}->{username} unless ($user);
    $pass = $self->{config}->{password} unless ($pass);

    my $client = new JSON::RPC::Legacy::Client;
    $client->{ua}->default_header( 'X-RPC-Auth-Password' => $pass );
    $client->{ua}->default_header( 'X-RPC-Auth-Username' => $user );
    $self->{client} = $client;

    my $res = $self->request( { method => 'idoit.login' } );
    if ($res->{is_success}) {
        my $h = $self->{client}->{ua}->default_headers();
        $h->header('X-RPC-Auth-Session' => $res->{content}->{result}->{'session-id'});
        $h->remove_header('X-RPC-Auth-Username');
        $h->remove_header('X-RPC-Auth-Password');
        $self->{session_id} = $res->{content}->{result}->{'session-id'};
        return $res;
    }
    return;
} # login()

sub logout {
    my $self = shift;

    my $res = $self->request( { method => 'idoit.login' } );
    delete $self->{session_id};
    delete $self->{client}; # grab a fresh client next time
    return $res;
} # logout()

sub is_logged_in {
    return exists $_[0]->{session_id};
} # is_logged_in()

sub read_config {
    my $fname = shift;

    my $known_paths = [ # some known paths of other configuration files
        "$ENV{HOME}/.idoitcli/config.json",
    ];

    unless ( $fname ) {
        for ( @$known_paths ) {
            if ( -r $_ ) {
                $fname = $_;
                last;
            }
        }
    }
    open(my $fh, '<', $fname)
      or die "Can't open config file '$fname': $!";

    my $config = _read_config_fh($fh);

    close($fh);

    $config->{config_file} = $fname;

    return $config;
} # read_config()

sub _read_config_fh {
    my $fh = shift;

    my $config = {};
    my %valid = map { $_ => 1 } qw(
        apikey key password url username
    );

    while (<$fh>) {
        if ( /^\s*(\S[^:=]+)[:=]\s*(\S.+)$/ ) {
            my ($key, $val) = ($1, $2);
            for ($key, $val) {
                s/\s+$//;
                s/[,;]$//;
                s/^"(.*)"$/$1/;
                s/^'(.*)'$/$1/;
            }
            next unless ( $valid{$key} );
            $config->{$key} = $val;
        }
    }

    $config->{apikey} = $config->{key} unless ( exists $config->{apikey} );
    unless ( $config->{url} =~ m|/src/jsonrpc[.]php$| ) {
        $config->{url} =~ s#/?$#/src/jsonrpc.php#;
    }

    return $config;
} # _read_config_fh()

sub _test_minimum_config {
    my $self = shift;
    croak "configuration is missing the API key"
        unless ( $self->{config}->{apikey} );
    croak "configuration is missing the URL for the API"
        unless ( $self->{config}->{url} );
} # _test_minimum_config()

1; # End of WebService::IdoitAPI

__DATA__