File Coverage

blib/lib/Net/CampaignMonitor.pm

Criterion	Covered	Total	%
statement	133	634	20.9
branch	26	186	13.9
condition	9	252	3.5
subroutine	21	105	20.0
pod	85	92	92.3
total	274	1269	21.5

package Net::CampaignMonitor;

use strict;

use 5.008005;
use MIME::Base64;
use REST::Client;
use Params::Util qw{_STRING _NONNEGINT _POSINT _HASH _HASHLIKE _ARRAY};
use JSON;
use Carp;
use URI;
use URI::Escape;

use version; our $VERSION = version->declare("v2.2.1");
our $CAMPAIGN_MONITOR_DOMAIN = 'api.createsend.com';

sub authorize_url {
  my $class = shift;
  my ($args) = @_;
  unless(Params::Util::_HASH($args)) {
    $args = { @_ };
  }
  my $self = bless($args, $class);

  my $uri = URI->new('https://'.$Net::CampaignMonitor::CAMPAIGN_MONITOR_DOMAIN.'/oauth');

  my @query = map { $_ => $self->{$_} } qw(client_id redirect_uri scope);
  push @query, state => $self->{state} if exists $self->{state};
  $uri->query_form(\@query);

  return $uri->as_string;
}

sub exchange_token {
  my $class = shift;
  my ($args) = @_;
  unless(Params::Util::_HASH($args)) {
    $args = { @_ };
  }
  my $self = bless($args, $class);
  my $oauth_client = Net::CampaignMonitor->create_oauth_client();

  my $body = 'grant_type=authorization_code';
  $body .= "&$_=" . uri_escape($self->{$_}) for qw(client_id client_secret redirect_uri code);

  $oauth_client->POST('https://'.$Net::CampaignMonitor::CAMPAIGN_MONITOR_DOMAIN.'/oauth/token',
    $body, {'Content-type' => 'application/x-www-form-urlencoded'});
  my $result = $self->decode($oauth_client->responseContent());

  if (exists $result->{error}) {
    croak 'Error exchanging OAuth code for access token. '.$result->{error}.': '.$result->{error_description};
  }
  return $result;
}

sub new {
  my $class = shift;
  my ($args) = @_;
  unless(Params::Util::_HASH($args)) {
    if (@_ % 2 == 0) {
      $args = { @_ };
    } else {
      croak 'Error parsing constructor arguments, no hashref and odd number of arguments supplied';
    }
  }
  my $self = bless($args, $class);
  $self->{format} = 'json';
  $self->{useragent} = 'createsend-perl-'.$Net::CampaignMonitor::VERSION;
  unless( Params::Util::_STRING($self->{domain}) ) {
    $self->{domain} = $Net::CampaignMonitor::CAMPAIGN_MONITOR_DOMAIN;
  }

  my $uri = URI->new;
  $self->{secure} = 1 unless defined $self->{secure};
  $uri->scheme($self->{secure} ? 'https' : 'http');
  $uri->host($self->{domain});
  $self->{base_uri} = $uri;

  $self->{base_path} = ['api', 'v3'];

  unless( Params::Util::_POSINT($self->{timeout}) ) {
    $self->{timeout} = 600;
  }

  if ( (exists $self->{api_key} ) && !( Params::Util::_STRING( $self->{api_key} )) ) {
    Carp::croak("Missing or invalid api key");
  }

  if ( (exists $self->{access_token} ) && !( Params::Util::_STRING( $self->{access_token} )) ) {
    Carp::croak("Missing or invalid OAuth access token");
  }

  if ( exists $self->{api_key} || exists $self->{access_token} ) {
    # Create and initialise the rest client
    $self->{client} = $self->create_rest_client();
    $self->account_systemdate();
    return $self;
  }
  else {
    return $self;
  }
}

sub create_rest_client {
  my ($self) = @_;

  my $ua = LWP::UserAgent->new;
  $ua->agent($self->{useragent});
  if (exists $self->{access_token}) {
    $ua->default_header('Authorization' => 'Bearer '.$self->{access_token});
  } elsif (exists $self->{api_key}) {
    $ua->default_header('Authorization' => 'Basic '.encode_base64($self->{api_key}.':x'));
  }
  my $client = REST::Client->new({useragent => $ua});
  $client->setFollow(1);
  $client->setTimeout($self->{timeout});
  return $client;
}

sub create_oauth_client {
  my $ua = LWP::UserAgent->new;
  my $client = REST::Client->new({useragent => $ua});
  $client->setFollow(1);
  $client->setTimeout(600);
  return $client;
}

sub refresh_token {
  my ($self) = @_;

  if (!exists $self->{refresh_token} ||
    (exists $self->{refresh_token} && !(Params::Util::_STRING($self->{refresh_token})))) {
    croak 'Error refreshing OAuth token. No refresh token exists.';
  }
  my $oauth_client = Net::CampaignMonitor->create_oauth_client();
  my $body = 'grant_type=refresh_token&refresh_token='.uri_escape($self->{refresh_token});
  $oauth_client->POST('https://'.$Net::CampaignMonitor::CAMPAIGN_MONITOR_DOMAIN.'/oauth/token', $body,
    {'Content-type' => 'application/x-www-form-urlencoded'});
  my $result = $self->decode($oauth_client->responseContent());

  if (exists $result->{error}) {
    croak 'Error refreshing OAuth token. '.$result->{error}.': '.$result->{error_description};
  }

  # Set the access token and refresh token, and re-create the client
  $self->{access_token} = $result->{access_token};
  $self->{refresh_token} = $result->{refresh_token};
  $self->{client} = $self->create_rest_client();
  return $result;
}

sub decode {
  my $self = shift;
  my $json = JSON->new->allow_nonref;

  if ( length $_[0] == 0 ) {
    return {};
  }
  else {
    return $json->decode( $_[0] );
  }
}

sub account_systemdate {
  my ($self) = @_;
  $self->_rest(GET => 'systemdate');

  return $self->_build_results();
}

sub account_billingdetails {
  my ($self) = @_;
  $self->_rest(GET => 'billingdetails');

  return $self->_build_results();
}

sub account_clients {
  if (scalar(@_) == 1) { # Get the list of clients
    my ($self) = @_;
    $self->_rest(GET => 'clients');

    return $self->_build_results();
  }
  else { # Create a new client
    my ($self, %request) = @_;

    $self->_rest(POST => 'clients', undef, \%request);

    return $self->_build_results();
  }
}

sub account_countries {
  my ($self) = @_;
  $self->_rest(GET => 'countries');

  return $self->_build_results();
}

sub account_timezones {
  my ($self) = @_;
  $self->_rest(GET => 'timezones');

  return $self->_build_results();
}

sub account_apikey {
  my ($self, $siteurl, $username, $password) = @_;

  my $ua = LWP::UserAgent->new;
  $ua->agent($self->{useragent});
  $ua->default_header('Authorization' => 'Basic '.encode_base64($username.':'.$password));
  my $api_client = REST::Client->new({useragent => $ua});

  $api_client->setFollow(1);
  $api_client->setTimeout(60);

  my $uri = $self->_build_uri('format', { siteurl => $siteurl });
  $api_client->GET($uri->as_string);

  return $self->_build_results($api_client);
}

sub account_addadmin{
  my ($self, %request) = @_;

  $self->_rest(POST => 'admins', undef, \%request);

  return $self->_build_results();
}

sub account_updateadmin{
  my ($self, %request) = @_;
  my $email = delete $request{email};

  my $json_request = encode_json \%request;

  $self->_rest(PUT => 'admins', { email => $email }, $json_request);

  return $self->_build_results();
}

sub account_getadmins {
  my ($self) = @_;
  $self->_rest(GET => 'admins');

  return $self->_build_results();
}

sub account_getadmin {
  my ($self, $email) = @_;

  $self->_rest(GET => 'admins', { email => $email });

  return $self->_build_results();
}

sub account_deleteadmin {
  my ($self, $email) = @_;

  $self->_rest(DELETE => 'admins', { email => $email });

  return $self->_build_results();
}

sub account_setprimarycontact {
  my ($self, $email) = @_;

  $self->_rest(PUT => 'primarycontact', { email => $email });

  return $self->_build_results();
}

sub account_getprimarycontact {
  my ($self) = @_;

  $self->_rest(GET => 'primarycontact');

  return $self->_build_results();
}

sub account_externalsession {
  my ($self, %request) = @_;

  $self->_rest(PUT => 'externalsession', undef, \%request);

  return $self->_build_results();
}

sub client_clientid {
  my ($self, $client_id) = @_;

  $self->_rest(GET => [ clients => $client_id ]);

  return $self->_build_results();
}

sub client_campaigns {
  my ($self, $client_id) = @_;

  $self->_rest(GET => [ clients => $client_id, 'campaigns' ]);

  return $self->_build_results();
}

sub client_drafts {
  my ($self, $client_id) = @_;

  $self->_rest(GET => [ clients => $client_id, 'drafts' ]);

  return $self->_build_results();
}

sub client_scheduled {
  my ($self, $client_id) = @_;

  $self->_rest(GET => [ clients => $client_id, 'scheduled' ]);

  return $self->_build_results();
}

sub client_lists {
  my ($self, $client_id) = @_;

  $self->_rest(GET => [ clients => $client_id, 'lists' ]);

  return $self->_build_results();
}

sub client_listsforemail {
  my ($self, %request) = @_;
  my $client_id  = $request{clientid};
  my $email      = $request{email};

  $self->_rest(GET => [ clients => $client_id, 'listsforemail' ], { email => $email });

  return $self->_build_results();
}

sub client_segments {
  my ($self, $client_id) = @_;

  $self->_rest(GET => [ clients => $client_id, 'segments' ]);

  return $self->_build_results();
}

sub client_suppressionlist {
  my ($self, %input) = @_;
  my $client_id = delete $input{clientid};

  unless( Params::Util::_POSINT($input{page}) ) {
    $input{page} = 1;
  }
  unless( Params::Util::_POSINT($input{pagesize}) && $input{pagesize} >= 10 && $input{pagesize} <= 1000) {
    $input{pagesize} = 1000;
  }
  unless( Params::Util::_STRING($input{orderfield}) && ($input{orderfield} eq 'email' || $input{orderfield} eq 'name' || $input{orderfield} eq 'date')) {
    $input{orderfield} = 'email';
  }
  unless( Params::Util::_STRING($input{orderdirection}) && ($input{orderdirection} eq 'asc' || $input{orderdirection} eq 'desc')) {
    $input{orderdirection} = 'asc';
  }

  $self->_rest(GET => [ clients => $client_id, 'suppressionlist' ], \%input);

  return $self->_build_results();
}

sub client_suppress {
  my ($self, %request) = @_;
  my $client_id = delete $request{clientid};

  $self->_rest(POST => [ clients => $client_id, 'suppress' ], undef, \%request);

  return $self->_build_results();
}

sub client_unsuppress {
  my ($self, %request) = @_;
  my $client_id  = delete $request{clientid};
  my $email      = delete $request{email};

  $self->_rest(PUT => [ clients => $client_id, 'unsuppress' ], { email => $email }, \%request);

  return $self->_build_results();
}

sub client_templates {
  my ($self, $client_id) = @_;

  $self->_rest(GET => [ clients => $client_id, 'templates' ]);

  return $self->_build_results();
}

sub client_setbasics {
  my ($self, %request) = @_;
  my $client_id = delete $request{clientid};

  $self->_rest(PUT => [ clients => $client_id, 'setbasics' ], undef, \%request);

  return $self->_build_results();
}

sub client_setpaygbilling {
  my ($self, %request) = @_;
  my $client_id = delete $request{clientid};

  $self->_rest(PUT => [ clients => $client_id, 'setpaygbilling' ], undef, \%request);

  return $self->_build_results();
}

sub client_setmonthlybilling {
  my ($self, %request) = @_;
  my $client_id = delete $request{clientid};

  $self->_rest(PUT => [ clients => $client_id, 'setmonthlybilling' ], undef, \%request);

  return $self->_build_results();
}

sub client_transfercredits {
  my ($self, %request) = @_;
  my $client_id = delete $request{clientid};

  $self->_rest(POST => [ clients  => $client_id, 'credits' ], undef, \%request);

  return $self->_build_results();
}

sub client_delete {
  my ($self, $client_id) = @_;

  $self->_rest(DELETE => [ clients  => $client_id ]);

  return $self->_build_results();
}

sub client_addperson {
  my ($self, %request) = @_;
  my $client_id = delete $request{clientid};

  $self->_rest(POST => [ clients  => $client_id, 'people' ], undef, \%request);

  return $self->_build_results();
}

sub client_updateperson {
  my ($self, %request) = @_;
  my $client_id  = delete $request{clientid};
  my $email      = delete $request{email};

  $self->_rest(PUT => [ clients => $client_id, 'people' ], { email => $email }, \%request);

  return $self->_build_results();
}

sub client_getpeople {
  my ($self, $client_id) = @_;

  $self->_rest(GET => [ clients => $client_id, 'people' ]);

  return $self->_build_results();
}

sub client_getperson {
  my ($self, %request) = @_;
  my $client_id  = $request{clientid};
  my $email      = $request{email};

  $self->_rest(GET => [ clients => $client_id, 'people' ], { email => $email });

  return $self->_build_results();
}

sub client_deleteperson {
  my ($self, %request) = @_;
  my $client_id  = $request{clientid};
  my $email      = $request{email};

  $self->_rest(DELETE => [ clients => $client_id, 'people' ], { email => $email });

  return $self->_build_results();
}

sub client_setprimarycontact {
  my ($self, %request) = @_;
  my $client_id = $request{clientid};
  my $email = $request{email};

  $self->_rest(PUT => [ clients => $client_id, 'primarycontact' ], { email => $email });

  return $self->_build_results();
}

sub client_getprimarycontact {
  my ($self, $client_id) = @_;

  $self->_rest(GET => [ clients => $client_id, 'primarycontact' ]);

  return $self->_build_results();
}

sub lists { # Create a list
  my ($self, %request) = @_;
  my $client_id = delete $request{clientid};

  $self->_rest(POST => [ lists => $client_id ], undef, \%request);

  return $self->_build_results();
}

sub list_listid {
  my $self = shift;

  if ( @_ == 1 ) { # Get the list details
    my $list_id = $_[0];
    $self->_rest(GET => [ lists => $list_id ]);

    return $self->_build_results();
  }
  else { # Updating a list
    my (%request) = @_;
    my $list_id = delete $request{listid};

    $self->_rest(PUT => [ lists => $list_id ], undef, \%request);

    return $self->_build_results();
  }
}

sub list_stats {
  my ($self, $list_id) = @_;

  $self->_rest(GET => [ lists => $list_id, 'stats' ]);

  return $self->_build_results();
}

sub list_customfields {
  my $self = shift;

  if (scalar(@_) == 1) { # Get the custom field details
    my $list_id = $_[0];
    $self->_rest(GET => [ lists => $list_id, 'customfields' ]);

    return $self->_build_results();
  }
  else { # Create a new custom field
    my (%request) = @_;
    my $list_id = delete $request{listid};

    $self->_rest(POST => [ lists => $list_id, 'customfields' ], undef, \%request);

    return $self->_build_results();
  }
}

sub list_customfields_update {
  my ($self, %request) = @_;
  my $list_id  = delete $request{listid};
  my $key      = delete $request{customfieldkey};

  $self->_rest(PUT => [ lists => $list_id, customfields => $key ], undef, \%request);

  return $self->_build_results();
}

sub list_segments {
  my ($self, $list_id) = @_;

  $self->_rest(GET => [ lists => $list_id, 'segments' ]);

  return $self->_build_results();
}

sub list_active {
  my ($self, %input) = @_;
  my $list_id = delete $input{listid};

  unless( Params::Util::_STRING($input{date}) ) {
    $input{date} = '';
  }
  unless( Params::Util::_POSINT($input{page}) ) {
    $input{page} = 1;
  }
  unless( Params::Util::_POSINT($input{pagesize}) && $input{pagesize} >= 10 && $input{pagesize} <= 1000) {
    $input{pagesize} = 1000;
  }
  unless( Params::Util::_STRING($input{orderfield}) && ($input{orderfield} eq 'email' || $input{orderfield} eq 'name' || $input{orderfield} eq 'date')) {
    $input{orderfield} = 'date';
  }
  unless( Params::Util::_STRING($input{orderdirection}) && ($input{orderdirection} eq 'asc' || $input{orderdirection} eq 'desc')) {
    $input{orderdirection} = 'asc';
  }

  $self->_rest(GET => [ lists => $list_id, 'active' ], \%input);

  return $self->_build_results();
}

sub list_unconfirmed {
  my ($self, %input) = @_;
  my $list_id = delete $input{listid};

  unless( Params::Util::_STRING($input{date}) ) {
    $input{date} = '';
  }
  unless( Params::Util::_POSINT($input{page}) ) {
    $input{page} = 1;
  }
  unless( Params::Util::_POSINT($input{pagesize}) && $input{pagesize} >= 10 && $input{pagesize} <= 1000) {
    $input{pagesize} = 1000;
  }
  unless( Params::Util::_STRING($input{orderfield}) && ($input{orderfield} eq 'email' || $input{orderfield} eq 'name' || $input{orderfield} eq 'date')) {
    $input{orderfield} = 'date';
  }
  unless( Params::Util::_STRING($input{orderdirection}) && ($input{orderdirection} eq 'asc' || $input{orderdirection} eq 'desc')) {
    $input{orderdirection} = 'asc';
  }

  $self->_rest(GET => [ lists => $list_id, 'active' ], \%input);

  return $self->_build_results();
}

sub list_unsubscribed {
  my ($self, %input) = @_;
  my $list_id = delete $input{listid};

  unless( Params::Util::_STRING($input{date}) ) {
    $input{date} = '';
  }
  unless( Params::Util::_POSINT($input{page}) ) {
    $input{page} = 1;
  }
  unless( Params::Util::_POSINT($input{pagesize}) && $input{pagesize} >= 10 && $input{pagesize} <= 1000) {
    $input{pagesize} = 1000;
  }
  unless( Params::Util::_STRING($input{orderfield}) && ($input{orderfield} eq 'email' || $input{orderfield} eq 'name' || $input{orderfield} eq 'date')) {
    $input{orderfield} = 'date';
  }
  unless( Params::Util::_STRING($input{orderdirection}) && ($input{orderdirection} eq 'asc' || $input{orderdirection} eq 'desc')) {
    $input{orderdirection} = 'asc';
  }

  $self->_rest(GET => [ lists => $list_id, 'unsubscribed' ], \%input);

  return $self->_build_results();
}

sub list_deleted {
  my ($self, %input) = @_;
  my $list_id = delete $input{listid};

  unless( Params::Util::_STRING($input{date}) ) {
    $input{date} = '';
  }
  unless( Params::Util::_POSINT($input{page}) ) {
    $input{page} = 1;
  }
  unless( Params::Util::_POSINT($input{pagesize}) && $input{pagesize} >= 10 && $input{pagesize} <= 1000) {
    $input{pagesize} = 1000;
  }
  unless( Params::Util::_STRING($input{orderfield}) && ($input{orderfield} eq 'email' || $input{orderfield} eq 'name' || $input{orderfield} eq 'date')) {
    $input{orderfield} = 'date';
  }
  unless( Params::Util::_STRING($input{orderdirection}) && ($input{orderdirection} eq 'asc' || $input{orderdirection} eq 'desc')) {
    $input{orderdirection} = 'asc';
  }

  $self->_rest(GET => [ lists => $list_id, 'deleted' ], \%input);

  return $self->_build_results();
}

sub list_bounced {
  my ($self, %input) = @_;
  my $list_id = delete $input{listid};

  unless( Params::Util::_STRING($input{date}) ) {
    $input{date} = '';
  }
  unless( Params::Util::_POSINT($input{page}) ) {
    $input{page} = 1;
  }
  unless( Params::Util::_POSINT($input{pagesize}) && $input{pagesize} >= 10 && $input{pagesize} <= 1000) {
    $input{pagesize} = 1000;
  }
  unless( Params::Util::_STRING($input{orderfield}) && ($input{orderfield} eq 'email' || $input{orderfield} eq 'name' || $input{orderfield} eq 'date')) {
    $input{orderfield} = 'date';
  }
  unless( Params::Util::_STRING($input{orderdirection}) && ($input{orderdirection} eq 'asc' || $input{orderdirection} eq 'desc')) {
    $input{orderdirection} = 'asc';
  }

  $self->_rest(GET => [ lists => $list_id, 'bounced' ], \%input);

  return $self->_build_results();
}

sub list_options {
  my ($self, %request) = @_;
  my $list_id = delete $request{listid};
  my $customfield_key = delete $request{customfieldkey};

  $self->_rest(PUT => [ lists => $list_id, customfields => $customfield_key, 'options' ], undef, \%request);

  return $self->_build_results();
}

sub list_delete_customfieldkey {
  my ($self, %request) = @_;
  my $list_id = $request{listid};
  my $customfield_key = $request{customfieldkey};

  $self->_rest(DELETE => [ lists => $list_id, customfields => $customfield_key ]);

  return $self->_build_results();
}

sub list_delete {
  my ($self, $list_id) = @_;

  $self->_rest(DELETE => [ lists => $list_id ]);

  return $self->_build_results();
}

sub list_webhooks {
  my $self = shift;

  if (scalar(@_) == 1) { #get the list of webhooks
    my $list_id = $_[0];
    $self->_rest(GET => [ lists => $list_id, 'webhooks' ]);

    return $self->_build_results();
  }
  else { #create a new webhook
    my (%request) = @_;
    my $list_id = delete $request{listid};

    $self->_rest(POST => [ lists => $list_id, 'webhooks' ], undef, \%request);

    return $self->_build_results();
  }
}

sub list_test {
  my ($self, %request) = @_;
  my $list_id = $request{listid};
  my $webhook_id = $request{webhookid};

  $self->_rest(GET => [ lists => $list_id, webhooks => $webhook_id, 'test' ]);

  return $self->_build_results();
}

sub list_delete_webhook {
  my ($self, %request) = @_;
  my $list_id = $request{listid};
  my $webhook_id = $request{webhookid};

  $self->_rest(DELETE => [ lists => $list_id, webhooks => $webhook_id ]);

  return $self->_build_results();
}

sub list_activate {
  my ($self, %request) = @_;
  my $list_id = $request{listid};
  my $webhook_id = $request{webhookid};

  $self->_rest(PUT => [ lists => $list_id, webhooks => $webhook_id, 'activate' ]);

  return $self->_build_results();
}

sub list_deactivate {
  my ($self, %request) = @_;
  my $list_id = $request{listid};
  my $webhook_id = $request{webhookid};

  $self->_rest(PUT => [ lists => $list_id, webhooks => $webhook_id, 'deactivate' ]);

  return $self->_build_results();
}

sub segments {
  my ($self, %request) = @_;
  my $list_id = delete $request{listid};

  $self->_rest(POST => [ segments => $list_id ], undef, \%request);

  return $self->_build_results();
}

sub segment_segmentid {
  my $self = shift;

  if (scalar(@_) == 1) { #get the segment details
    my $segment_id = $_[0];
    $self->_rest(GET => [ segments => $segment_id ]);

    return $self->_build_results();
  }
  else { #update the segment
    my (%request) = @_;
    my $segment_id = delete $request{segmentid};

    $self->_rest(PUT => [ segments => $segment_id ], undef, \%request);

    return $self->_build_results();
  }
}

sub segment_rules {
  my ($self, %request) = @_;
  my $segment_id = delete $request{segmentid};

  $self->_rest(POST => [ segments => $segment_id, 'rules' ], undef, \%request);

  return $self->_build_results();
}

sub segment_active {
  my ($self, %input) = @_;
  my $segment_id = delete $input{segmentid};

  unless( Params::Util::_STRING($input{date}) ) {
    $input{date} = '';
  }
  unless( Params::Util::_POSINT($input{page}) ) {
    $input{page} = 1;
  }
  unless( Params::Util::_POSINT($input{pagesize}) && $input{pagesize} >= 10 && $input{pagesize} <= 1000) {
    $input{pagesize} = 1000;
  }
  unless( Params::Util::_STRING($input{orderfield}) && ($input{orderfield} eq 'email' || $input{orderfield} eq 'name' || $input{orderfield} eq 'date')) {
    $input{orderfield} = 'date';
  }
  unless( Params::Util::_STRING($input{orderdirection}) && ($input{orderdirection} eq 'asc' || $input{orderdirection} eq 'desc')) {
    $input{orderdirection} = 'asc';
  }

  $self->_rest(GET => [ segments => $segment_id, 'active' ], \%input);

  return $self->_build_results();
}

sub segment_delete {
  my ($self, $segment_id) = @_;

  $self->_rest(DELETE => [ segments => $segment_id ]);

  return $self->_build_results();
}

sub segment_delete_rules {
  my ($self, $segment_id) = @_;

  $self->_rest(DELETE => [ segments => $segment_id, 'rules' ]);

  return $self->_build_results();
}

sub subscribers {
  my ($self, %request) = @_;
  my $list_id = delete $request{listid};

  if ($request{email}) { # Get subscribers details
    $self->_rest(GET => [ subscribers => $list_id ], { email => $request{email} });

    return $self->_build_results();
  }
  else { # Add subscriber

    $self->_rest(POST => [ subscribers => $list_id ], undef, \%request);

    return $self->_build_results();
  }
}

sub subscribers_update {
  my ($self, %request) = @_;
  my $list_id  = delete $request{listid};
  my $email    = delete $request{email};

  $self->_rest(PUT => [ subscribers => $list_id ], { email => $email }, \%request);

  return $self->_build_results();
}

sub subscribers_import {
  my ($self, %request) = @_;
  my $list_id = delete $request{listid};

  $self->_rest(POST => [ subscribers => $list_id, 'import' ], undef, \%request);

  return $self->_build_results();
}

sub subscribers_history {
  my ($self, %request) = @_;
  my $list_id  = $request{listid};
  my $email    = $request{email};

  $self->_rest(GET => [ subscribers => $list_id, 'history' ], { email => $email });

  return $self->_build_results();
}

sub subscribers_unsubscribe {
  my ($self, %request) = @_;
  my $list_id = delete $request{listid};

  $self->_rest(POST => [ subscribers => $list_id, 'unsubscribe' ], undef, \%request);

  return $self->_build_results();
}

sub subscribers_delete {
  my ($self, %request) = @_;
  my $list_id  = $request{listid};
  my $email    = $request{email};

  $self->_rest(DELETE => [ subscribers => $list_id ], { email => $email });

  return $self->_build_results();
}

sub templates {
  my $self = shift;

  if ( @_ == 1 ) { #get the template details
    my $template_id = $_[0];
    $self->_rest(GET => [ templates => $template_id ]);

    return $self->_build_results();
  }
  else {
    my (%request) = @_;
    if ( $request{templateid} ) { #update the template
      my $template_id = delete $request{templateid};

      $self->_rest(PUT => [ templates => $template_id ], undef, \%request);

      return $self->_build_results();
    }
    elsif ( $request{clientid} ) { #create a template
      my $client_id = delete $request{clientid};

      $self->_rest(POST => [ templates => $client_id ], undef, \%request);

      return $self->_build_results();
    }
  }
}

sub templates_delete {
  my ($self, $template_id) = @_;

  $self->_rest(DELETE => [ templates  => $template_id ]);

  return $self->_build_results();
}

sub campaigns {
  my ($self, %request) = @_;
  my $client_id = delete $request{clientid};

  $self->_rest(POST => [ campaigns  => $client_id ], undef, \%request);

  return $self->_build_results();
}

sub campaigns_fromtemplate {
  my ($self, %request) = @_;
  my $client_id = delete $request{clientid};

  $self->_rest(POST => [ campaigns  => $client_id, 'fromtemplate' ], undef, \%request);

  return $self->_build_results();
}

sub campaigns_send {
  my ($self, %request) = @_;
  my $campaign_id = delete $request{campaignid};

  $self->_rest(POST => [ campaigns  => $campaign_id, 'send' ], undef, \%request);

  return $self->_build_results();
}

sub campaigns_unschedule {
  my ($self, %request) = @_;
  my $campaign_id = delete $request{campaignid};

  $self->_rest(POST => [ campaigns  => $campaign_id, 'unschedule' ], undef, \%request);

  return $self->_build_results();
}

sub campaigns_sendpreview {
  my ($self, %request) = @_;
  my $campaign_id = delete $request{campaignid};

  $self->_rest(POST => [ campaigns  => $campaign_id, 'sendpreview' ], undef, \%request);

  return $self->_build_results();
}

sub campaigns_summary {
  my ($self, $campaign_id) = @_;

  $self->_rest(GET => [ campaigns  => $campaign_id, 'summary' ]);

  return $self->_build_results();
}

sub campaigns_emailclientusage {
  my ($self, $campaign_id) = @_;

  $self->_rest(GET => [ campaigns  => $campaign_id, 'emailclientusage' ]);

  return $self->_build_results();
}

sub campaigns_listsandsegments {
  my ($self, $campaign_id) = @_;

  $self->_rest(GET => [ campaigns  => $campaign_id, 'listsandsegments' ]);

  return $self->_build_results();
}

sub campaigns_recipients {
  my ($self, %input) = @_;
  my $campaign_id = delete $input{campaignid};

  unless( Params::Util::_POSINT($input{page}) ) {
    $input{page} = 1;
  }
  unless( Params::Util::_POSINT($input{pagesize}) && $input{pagesize} >= 10 && $input{pagesize} <= 1000) {
    $input{pagesize} = 1000;
  }
  unless( Params::Util::_STRING($input{orderfield}) && ($input{orderfield} eq 'email' || $input{orderfield} eq 'name' || $input{orderfield} eq 'date')) {
    $input{orderfield} = 'date';
  }
  unless( Params::Util::_STRING($input{orderdirection}) && ($input{orderdirection} eq 'asc' || $input{orderdirection} eq 'desc')) {
    $input{orderdirection} = 'asc';
  }

  $self->_rest(GET => [ campaigns  => $campaign_id, 'recipients' ], \%input);

  return $self->_build_results();
}

sub campaigns_bounces {
  my ($self, %input) = @_;
  my $campaign_id = delete $input{campaignid};

  unless( Params::Util::_POSINT($input{page}) ) {
    $input{page} = 1;
  }
  unless( Params::Util::_POSINT($input{pagesize}) && $input{pagesize} >= 10 && $input{pagesize} <= 1000) {
    $input{pagesize} = 1000;
  }
  unless( Params::Util::_STRING($input{orderfield}) && ($input{orderfield} eq 'email' || $input{orderfield} eq 'name' || $input{orderfield} eq 'date')) {
    $input{orderfield} = 'date';
  }
  unless( Params::Util::_STRING($input{orderdirection}) && ($input{orderdirection} eq 'asc' || $input{orderdirection} eq 'desc')) {
    $input{orderdirection} = 'asc';
  }

  $self->_rest(GET => [ campaigns  => $campaign_id, 'bounces' ], \%input);

  return $self->_build_results();
}

sub campaigns_opens {
  my ($self, %input) = @_;
  my $campaign_id = delete $input{campaignid};

  unless( Params::Util::_POSINT($input{page}) ) {
    $input{page} = 1;
  }
  unless( Params::Util::_POSINT($input{pagesize}) && $input{pagesize} >= 10 && $input{pagesize} <= 1000) {
    $input{pagesize} = 1000;
  }
  unless( Params::Util::_STRING($input{orderfield}) && ($input{orderfield} eq 'email' || $input{orderfield} eq 'name' || $input{orderfield} eq 'date')) {
    $input{orderfield} = 'date';
  }
  unless( Params::Util::_STRING($input{orderdirection}) && ($input{orderdirection} eq 'asc' || $input{orderdirection} eq 'desc')) {
    $input{orderdirection} = 'asc';
  }

  $self->_rest(GET => [ campaigns  => $campaign_id, 'opens' ], \%input);

  return $self->_build_results();
}

sub campaigns_clicks {
  my ($self, %input) = @_;
  my $campaign_id = delete $input{campaignid};

  unless( Params::Util::_POSINT($input{page}) ) {
    $input{page} = 1;
  }
  unless( Params::Util::_POSINT($input{pagesize}) && $input{pagesize} >= 10 && $input{pagesize} <= 1000) {
    $input{pagesize} = 1000;
  }
  unless( Params::Util::_STRING($input{orderfield}) && ($input{orderfield} eq 'email' || $input{orderfield} eq 'name' || $input{orderfield} eq 'date')) {
    $input{orderfield} = 'date';
  }
  unless( Params::Util::_STRING($input{orderdirection}) && ($input{orderdirection} eq 'asc' || $input{orderdirection} eq 'desc')) {
    $input{orderdirection} = 'asc';
  }

  $self->_rest(GET => [ campaigns  => $campaign_id, 'clicks' ], \%input);

  return $self->_build_results();
}

sub campaigns_unsubscribes {
  my ($self, %input) = @_;
  my $campaign_id = delete $input{campaignid};

  unless( Params::Util::_POSINT($input{page}) ) {
    $input{page} = 1;
  }
  unless( Params::Util::_POSINT($input{pagesize}) && $input{pagesize} >= 10 && $input{pagesize} <= 1000) {
    $input{pagesize} = 1000;
  }
  unless( Params::Util::_STRING($input{orderfield}) && ($input{orderfield} eq 'email' || $input{orderfield} eq 'name' || $input{orderfield} eq 'date')) {
    $input{orderfield} = 'date';
  }
  unless( Params::Util::_STRING($input{orderdirection}) && ($input{orderdirection} eq 'asc' || $input{orderdirection} eq 'desc')) {
    $input{orderdirection} = 'asc';
  }

  $self->_rest(GET => [ campaigns  => $campaign_id, 'unsubscribes' ], \%input);

  return $self->_build_results();
}

sub campaigns_spam {
  my ($self, %input) = @_;
  my $campaign_id = delete $input{campaignid};

  unless( Params::Util::_POSINT($input{page}) ) {
    $input{page} = 1;
  }
  unless( Params::Util::_POSINT($input{pagesize}) && $input{pagesize} >= 10 && $input{pagesize} <= 1000) {
    $input{pagesize} = 1000;
  }
  unless( Params::Util::_STRING($input{orderfield}) && ($input{orderfield} eq 'email' || $input{orderfield} eq 'name' || $input{orderfield} eq 'date')) {
    $input{orderfield} = 'date';
  }
  unless( Params::Util::_STRING($input{orderdirection}) && ($input{orderdirection} eq 'asc' || $input{orderdirection} eq 'desc')) {
    $input{orderdirection} = 'asc';
  }

  $self->_rest(GET => [ campaigns  => $campaign_id, 'spam' ], \%input);

  return $self->_build_results();
}

sub campaigns_delete {
  my ($self, $campaign_id) = @_;

  $self->_rest(DELETE => [ campaigns => $campaign_id ]);

  return $self->_build_results();
}

sub _build_results {
  my ($self, $client) = @_;
  $client ||= $self->{client};

  my %results = (
    response => $self->decode( $client->responseContent() ),
    code     => $client->responseCode(),
    headers  => +{ map { $_ => scalar $client->responseHeader($_) } $client->responseHeaders() },
  );

  return \%results;
}

# The _build_uri method takes two parameters:
# $path is either an array of path components,
#       or a string which converts to a 1 element array
# $query is either an array of query_form parameters
#       or a hash of same
# A URI object is returned
sub _build_uri {
  my ($self, $path, $query) = @_;

  unless (_ARRAY($path)) {
    if (_STRING($path)) {
      $path = [ $path ];

    } else {
      croak "Unable to parse URL recipe";
    }
  }

  my $uri = $self->{base_uri}->clone;

  @$path = (@{ $self->{base_path} }, @$path);
  # specify the type as a file-extension to the last path segment
  $path->[-1] .= ".$self->{format}";
  $uri->path_segments(@$path);

  if (_HASH($query)) {
    $uri->query_form([ map { $_ => $query->{$_} } sort keys %$query ], '&');

  } elsif (_ARRAY($query)) {
    $uri->query_form($query, '&');
  }

  return $uri;
}

# The _rest method takes either a list of parameters or a single hashref
# If a list, they are interpreted in order as method, path, query, body, headers
#   where method is the HTTP/REST method to use
#   path is the path component of the URL to call, appended to the REST API base
#        it can also be an array reference used to construct the path
#   query is the query component of the URL to call, it can be a hashref
#   body is the body of the HTTP request, for PUT/PATCH/POST methods
#        it can be a hashref which will be json encoded
#
# If the first parameter to this function is a hashref, the values correspond to
# keys of those names: method, path, query, body, headers
#
# The method and path parameters are required
#
# A call to the REST::Client instance is built and performed, the result
# of which is returned.
sub _rest {
  my $self = shift;
  my $params;
  if (Params::Util::_HASH($_[0])) {
    $params = shift;

  } else {
    $params = {};
    @$params{qw(method path query body headers)} = @_;
  }

  my $method = $params->{method};
  my $uri = $self->_build_uri($params->{path}, $params->{query});

  my @args = ($uri->as_string);
  if ($method =~ /^(?:PUT|PATCH|POST)$/) {
    if (ref $params->{body}) {
      my $body = encode_json $params->{body};
      push @args, $body;

	} else {
      push @args, $params->{body};
    }
  }

  push @args, $params->{headers} if defined $params->{headers};

  return $self->{client}->$method(@args);
}

1;

__END__