File Coverage

blib/lib/WebService/Shutterstock/Customer.pm

Criterion	Covered	Total	%
statement	143	153	93.4
branch	44	62	70.9
condition	14	23	60.8
subroutine	23	24	95.8
pod	8	9	88.8
total	232	271	85.6

package WebService::Shutterstock::Customer;
{
  $WebService::Shutterstock::Customer::VERSION = '0.006';
}

# ABSTRACT: Class allowing API operations in the context of a specific customer

use strict;
use warnings;
use Moo;
use WebService::Shutterstock::Subscription;
use Carp qw(croak);
use JSON qw(encode_json);
use WebService::Shutterstock::LicensedVideo;

use WebService::Shutterstock::AuthedClient;
with 'WebService::Shutterstock::AuthedClient';


sub account_id {
	my $self = shift;
	return $self->_info->{account_id};
}


sub metadata_field_definitions {
	my $self = shift;
	return $self->_info->{metadata_field_definitions};
}

has _info => ( is => 'lazy' );
sub _build__info {
	my $self = shift;
	my $client = $self->client;
	$client->GET( sprintf( '/customers/%s.json', $self->username ), $self->with_auth_params );
	my $data = $client->process_response;
	return $data;
}


has subscriptions => ( is => 'lazy' );
sub _build_subscriptions {
	my $self = shift;
	$self->client->GET( sprintf( '/customers/%s/subscriptions.json', $self->username ), $self->with_auth_params );
	my $subscriptions = $self->client->process_response;
	return [ map { $self->new_with_auth( 'WebService::Shutterstock::Subscription', %$_ ) } @$subscriptions ]
}


sub subscription {
	my $self = shift;
	my ( $subscription, @extra ) = $self->find_subscriptions(@_);
	return $subscription;
}


sub find_subscriptions {
	my $self = shift;
	my %criteria = @_;
	my $filter = sub {
		my $s = shift;
		foreach my $m(keys %criteria){
			croak "Invalid subscription filter key '$m': no such attribute on WebService::Shutterstock::Subscription" if !$s->can($m);
			my $value = $s->$m;
			my $matcher = $criteria{$m};
			if(ref $matcher eq 'CODE'){
				local $_ = $value;
				return unless $matcher->($value);
			} elsif(ref $matcher eq 'Regexp'){
				return unless $value =~ $matcher;
			} else {
				return unless $value eq $matcher;
			}
		}
		return 1;
	};
	return grep { $filter->($_) } @{ $self->subscriptions };
}


sub lightboxes {
	my $self = shift;
	my $extended = shift || 0;
	$self->client->GET(
		sprintf(
			'/customers/%s/lightboxes%s.json',
			$self->username, $extended ? '/extended' : ''
		),
		$self->with_auth_params
	);
	my $lightboxes = $self->client->process_response;
	return [ map {$self->new_with_auth('WebService::Shutterstock::Lightbox', %$_) } @$lightboxes ];
}


sub lightbox {
	my $self = shift;
	my $id = shift;
	my $lightbox = $self->new_with_auth('WebService::Shutterstock::Lightbox', lightbox_id => $id);
	eval { $lightbox->load; 1 } or do {
		my $e = $@;
		if(eval { $e->isa('WebService::Shutterstock::Exception') } && ($e->code eq 404 || $e->code eq 500)){
			$lightbox = undef;
		} else {
			die $e;
		}
	};
	return $lightbox;
}


sub downloads {
	my $self = shift;
	my %args = @_;
	$self->client->GET(
		sprintf( '/customers/%s/images/downloads.json', $self->username ),
		$self->with_auth_params(%args) );
	return $self->client->process_response;
}


sub license_image {
	my $self     = shift;
	my %args     = @_;

	my $image_id = $args{image_id} or croak "Must specify image_id to license";

	my $editorial_acknowledgement = $args{editorial_acknowledgement} || 0;

	my $subscription = $self->_find_subscription_from_arg('photo', $args{subscription});
	if(!$subscription){
		croak "Must specify a subscription to license images under";
	}

	my $metadata = $self->_valid_metadata($args{metadata});

	my $size = $self->_valid_size_for_subscription($subscription, $args{size});

	my $format = $size eq 'vector' ? 'eps' : 'jpg';
	my $client = $self->client;

	$client->POST(
		sprintf(
			'/subscriptions/%s/images/%s/sizes/%s.json',
			$subscription->id, $image_id, $size
		),
		$self->with_auth_params(
			format                    => $format,
			editorial_acknowledgement => $editorial_acknowledgement,
			( $metadata ? ( metadata => encode_json($metadata) ) : () ),
		)
	);

	return WebService::Shutterstock::LicensedImage->new($client->process_response);
}


sub license_video {
	my $self     = shift;
	my %args     = @_;

	my $video_id = $args{video_id} or croak "Must specify video_id to license";

	my $editorial_acknowledgement = $args{editorial_acknowledgement} || 0;

	my $subscription = $self->_find_subscription_from_arg('video', $args{subscription});
	if(!$subscription){
		croak "Must specify a subscription to license videos under";
	}

	my $metadata = $self->_valid_metadata($args{metadata});

	my $size = $self->_valid_size_for_subscription($subscription, $args{size});

	my $client = $self->client;

	$client->POST(
		sprintf(
			'/subscriptions/%s/videos/%s/sizes/%s.json',
			$subscription->id, $video_id, $size
		),
		$self->with_auth_params(
			editorial_acknowledgement => $editorial_acknowledgement,
			( $metadata ? ( metadata => encode_json($metadata) ) : () ),
		)
	);

	return WebService::Shutterstock::LicensedVideo->new($client->process_response);
}

sub _find_subscription_from_arg {
	my $self = shift;
	my $type = shift;
	my $sub_arg = shift;


	my $single_finder = sub {
		my %criteria = @_;
		my @matching = $self->find_subscriptions( %criteria, is_active => 1, site => "${type}_subscription" );
		if ( @matching == 0 ) {
			croak "Unable to find a matching subscription to license ${type}s";
		} elsif ( @matching > 1 ) {
			croak "You have more than one active subscription.  Please provide a WebService::Shutterstock::Subscription object or specify unique critiria to identify which subscription you would like to use (i.e. { license => 'standard' } or { id => 26374582 } )";
		}
		return $matching[0];
	};

	my $subscription;

	if($sub_arg){
		if(!ref($sub_arg)){
			$subscription = $self->subscription( id => $sub_arg );
		} elsif(ref($sub_arg) eq 'HASH'){
			$subscription = $single_finder->( %$sub_arg );
		} elsif(eval { $sub_arg->isa('WebService::Shutterstock::Subscription') }){
			$subscription = $sub_arg;
		}
	} else {
		$subscription = $single_finder->();
	}
	if($subscription && $subscription->site ne "${type}_subscription"){
		croak sprintf('The subscription specified is for the wrong "site" (needed "%s_subscription", found %s)', $type, $subscription->site);
	}
	return $subscription;
}

sub _valid_size_for_subscription {
	my $self = shift;
	my $subscription = shift;
	my $size = shift;

	my @valid_sizes = $subscription->sizes_for_licensing;

	if(!$size && @valid_sizes == 1){
		$size = $valid_sizes[0];
	}
	croak "Must specify size of video to license" if !$size;

	if ( !grep { $_ eq $size } @valid_sizes ) {
		my %uniq_sizes = map {$_ => 1} @valid_sizes;
		croak "Invalid size '$size', please specify a valid size: " . join(", ", keys %uniq_sizes);
	}
	return $size;
}

sub _valid_metadata {
	my $self = shift;
	my $metadata = shift;
	my $valid;
	if(my $metadata_definitions = $self->metadata_field_definitions){
		$valid = $metadata || {};
		my @missing;
		foreach my $md(@{ $metadata_definitions }){
			$valid->{$md->{name_api}} = '' if !defined $valid->{$md->{name_api}};
			if($md->{is_required} && $valid->{$md->{name_api}} eq ''){
				push @missing, $md->{name_api};
			}
		}
		if(@missing){
		croak
			sprintf(
			'Missing required metadata field%s for licensing image: %s',
			@missing == 1 ? '' : 's', join ', ', @missing );
		}
	}
	return $valid;
}

1;

__END__