File Coverage

blib/lib/WWW/Asana.pm

Criterion	Covered	Total	%
statement	7	61	11.4
branch	0	24	0.0
condition	0	3	0.0
subroutine	3	20	15.0
pod	6	11	54.5
total	16	119	13.4

package WWW::Asana;
BEGIN {
  $WWW::Asana::AUTHORITY = 'cpan:GETTY';
}
{
  $WWW::Asana::VERSION = '0.003';
}
# ABSTRACT: Client Class for accessing Asana API


use MooX qw(
	+LWP::UserAgent
	+WWW::Asana::Response
	+WWW::Asana::Request
	+URI
);

use Carp qw( croak );

our $VERSION ||= '0.000';


has api_key => (
	is => 'ro',
	required => 1,
);


has version => (
	is => 'ro',
	lazy => 1,
	builder => 1,
);

sub _build_version { '1.0' }


has base_uri => (
	is => 'ro',
	lazy => 1,
	builder => 1,
);

sub _build_base_uri { 'https://app.asana.com/api' }


has useragent => (
	is => 'ro',
	lazy => 1,
	builder => 1,
);

sub _build_useragent {
	my ( $self ) = @_;
	LWP::UserAgent->new(
		agent => $self->useragent_agent,
		$self->has_useragent_timeout ? (timeout => $self->useragent_timeout) : (),
	);
}


has useragent_agent => (
	is => 'ro',
	lazy => 1,
	builder => 1,
);

sub _build_useragent_agent { (ref $_[0] ? ref $_[0] : $_[0]).'/'.$VERSION }


has useragent_timeout => (
	is => 'ro',
	predicate => 'has_useragent_timeout',
);


has request_class => (
	is => 'ro',
	lazy => 1,
	builder => 1,
);

sub _build_request_class { 'WWW::Asana::Request' }


has response_class => (
	is => 'ro',
	lazy => 1,
	builder => 1,
);

sub _build_response_class { 'WWW::Asana::Response' }

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

sub BUILDARGS {
	my ( $class, @args ) = @_;
	unshift @args, "api_key" if @args % 2 && ref $args[0] ne 'HASH';
	return { @args };
}


sub request {
	my ( $self, @args ) = @_;
	my $request;
	if (ref $args[0] eq $self->request_class) {
		$request = $args[0];
	} else {
		$request = $self->get_request(@args);
	}
	my $http_response = $self->useragent->request($request->http_request);
	my $class_response = $self->response_class;
	return $class_response->new($request, $http_response, $request->to, $self);
}


sub get_uri {
	my ( $self, @args ) = @_;
	return join('/',$self->base_uri,$self->version,@args);
}


sub get_request {
	my ( $self, @args ) = @_;
	my $to = shift @args;
	my $method = shift @args;
	my @path_parts;
	my %data;
	my @params;
	my @codes;
	for my $arg (@args) {
		if (ref $arg eq 'HASH') {
			$data{$_} = $arg->{$_} for (keys %{$arg});
		} elsif (ref $arg eq 'ARRAY') {
			push @params, [@{$arg}];
		} elsif (ref $arg eq 'CODE') {
			push @codes, $arg;
		} else {
			push @path_parts, $arg;
		}
	}
	my $uri = $self->get_uri(@path_parts);
	my $request_class = $self->request_class;
	return $request_class->new(
		api_key => $self->api_key,
		uri => $uri,
		to => $to,
		method => $method,
		%data ? ( data => \%data ) : (),
		@params ? ( params => \@params ) : (),
		@codes ? ( codes => \@codes ) : (),
	);
}


sub do {
	my ( $self, @args ) = @_;
	my $response = $self->request(@args);
	if ($response->has_errors) {
		croak "Asana Errors:\n".join("\n",map { $_->message.( $_->has_phrase ? " [phrase:".$_->phrase."]" : "" ) } @{$response->errors})."\n";
	}
	return $response->result;
}


sub me_args { 'User','GET','users','me' }
sub me {
	my $self = shift;
	$self->do($self->me_args(@_));
}


sub users_args { '[User]','GET','users' }
sub users {
	my $self = shift;
	$self->do($self->users_args(@_));
}


sub user_args { shift; '[User]','GET','users',shift }
sub user {
	my $self = shift;
	$self->do($self->user_args(@_));
}

1;


__END__