File Coverage

blib/lib/WWW/FreshBooks/API.pm

Criterion	Covered	Total	%
statement	22	24	91.6
branch			n/a
condition			n/a
subroutine	8	8	100.0
pod			n/a
total	30	32	93.7

package WWW::FreshBooks::API;
use warnings;
use strict;
use Carp;

use version; our $VERSION = qv('0.1.0');

use base qw/Class::Accessor::Children::Fast/;
__PACKAGE__->mk_accessors( qw/svc_url auth_token method m_api m_func r_args ua xs response results item_class item_fields/ );
__PACKAGE__->mk_child_accessors(
				Response => [qw(http ref content as_string status)],
				Results  => [qw(page per_page pages total fields items iterator)],
			);

use Iterator::Simple qw(iter);
use LWP::UserAgent;
use XML::Simple;

sub new {
	my $class = shift;
    my $args  = shift;

	if ((!exists $args->{'svc_url'}) || (!exists $args->{'auth_token'})) {
		warn "Undefined svc_url or auth_token.";
		return;
	}

    $class = ref($class) || $class;
    my $self = bless {}, $class;

    $self->init($args);
    return $self;
}

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

    $self->svc_url($args->{'svc_url'});
    $self->auth_token($args->{'auth_token'});
    $self->ua(LWP::UserAgent->new(agent => $self->_agent, timeout => 30));
    $self->xs(XML::Simple->new(RootName => ''));

	return $self;
}

sub call {
    my $self   = shift;
    my $method = shift;
    my $args   = shift;

    $self->r_args($args);
	$self->_parse_method($method);

    my $req = HTTP::Request->new(POST => $self->svc_url);
    $req->authorization_basic($self->auth_token, "X");
    $req->content($self->_rxml);

	print STDERR Data::Dumper->Dump([$req]);
    my $resp = $self->ua->request($req);
    if ($resp->code != 200) {
		return(0,$resp);
	}

    my $ref = $self->xs->xml_in($resp->content, KeyAttr => []);
	my $response = WWW::FreshBooks::API::Response->new({
		http	=> $resp,
		ref		=> $ref,
		status	=> $ref->{'status'},
		content => $resp->content,
		as_string => $resp->as_string,
	});
	$self->response($response);

	my $robj;
	my $ritems;
	my $item_class;
	unless (($self->m_func eq "list") || (!exists $ref->{$self->m_api})) {
		$self->_mk_item_class($ref->{$self->m_api});
		$ritems = [ $ref->{$self->m_api} ];
		$robj = {};
	}

	unless (defined $item_class) {
		foreach my $k(keys %{$ref}) {
			my $v = $ref->{$k};
			if ((ref $v eq "HASH") && (exists $v->{$self->m_api})) {
				$robj = $v;

				$self->_mk_item_class($v->{$self->m_api});
				$ritems = $v->{$self->m_api};
			}
		}
	}
	$item_class = $self->item_class;

	my $items;
	my $fmap = $self->item_fields;
	my $fields = $fmap->{$item_class};
	foreach my $i(@{$ritems}) {
		my $item = $item_class->new($i);
		push(@{$items}, $item);
	}

	$robj->{'items'} = $items;
	$robj->{'fields'} = $fields;
	$robj->{'iterator'} = iter($items);
	my $results = WWW::FreshBooks::API::Results->new($robj);
	$self->results($results);

    return (wantarray) ? ($ref,$resp) : $self->results;
}

sub _mk_item_class {
	my $self = shift;
	my $tmpl = shift;

	$tmpl = $$tmpl[0] if ref($tmpl) eq "ARRAY";
	my $fields = [keys %{$tmpl}];
	my $item_name = ucfirst($self->m_api);
	__PACKAGE__->mk_child_accessors($item_name => $fields);
	my $class = __PACKAGE__ . "::" . $item_name;

	$self->item_class($class);
	my $item_fields = $self->item_fields;
	$item_fields->{$class} = $fields;
	$self->item_fields($item_fields);

	return $self;
}

sub _parse_method {
	my $self = shift;
	my $method = shift;

    $self->method($method);
	my ($api, $func) = split(/\./, $method);
	$self->m_api($api);
	$self->m_func($func);

	return $self;
}

sub _rxml {
    my $self = shift;

    my $w = $self->_xwrap();
    my $x = $self->xs->xml_out($self->r_args, RootName => $self->_root_name);
    my $fnr = {
		'__M__' => $self->method,
        '__X__' => $x,
	};

    foreach my $f(keys %{$fnr}) {
		$w =~ s/$f/$fnr->{$f}/g;
	}
    return $w;
}

sub _root_name {
	my $self = shift;
	my $root_name = (($self->m_func eq "create") || ($self->m_func eq "update")) ? $self->m_api : "";
	return $root_name;
}

sub _xwrap {
        return qq{

__X__
};
}

sub _agent { __PACKAGE__ . "/" . $VERSION }

1;

__END__