File Coverage

blib/lib/Net/Zendesk.pm

Criterion	Covered	Total	%
statement	50	76	65.7
branch	36	62	58.0
condition	6	29	20.6
subroutine	6	10	60.0
pod	3	4	75.0
total	101	181	55.8

package Net::Zendesk;
use strict;
use warnings;
use MIME::Base64;
use JSON::MaybeXS;

our $VERSION = '0.02';

sub new {
    my ($class, %args) = @_;
    die 'please provide a zendesk domain name (e.g. domain => "obscura.zendesk.com")'
        unless $args{domain} && $args{domain} =~ /\.zendesk\.com\z/ && $args{domain} !~ m{/};

    die 'sorry! only API version 2 is supported at the moment'
        if exists $args{api} && $args{api} != 2;

    die 'please provide the email of a valid zendesk account' unless $args{email};
    if ($args{token}) {
        $args{auth} = "$args{email}/token:$args{token}";
    }
    elsif ($args{password}) {
        $args{auth} = "$args{email}:$args{password}";
    }
    else {
        die 'please provide a password or a token for zendesk authentication. Oauth is not yet supported by this module';
    }

    return bless {
        _domain => $args{domain},
        _api    => $args{api},
        _auth   => MIME::Base64::encode($args{auth}),
        _ua    => $args{ua} || undef,
    }, $class;
}

sub create_ticket {
    my ($self, $ticket, %extra) = @_;
    my $path = 'tickets.json';
    if (%extra) {
        $path .= '?' . join('&', map("$_=$extra{$_}", keys %extra));
    }
    return $self->make_request('POST', $path, { ticket => $ticket });
}

sub search {
    my ($self, $search_args) = @_;
    my $parsed_args = $self->_parse_search_args($search_args);

    require URI::Escape;
    my $query = URI::Escape::uri_escape(join(' ' => @$parsed_args));

    return $self->make_request('GET', 'search.json?query=' . $query, {});
}

sub make_request {
    my ($self, $type, $path, $params) = @_;
    die 'please provide a type' unless $type
        && ($type eq 'GET' || $type eq 'POST' || $type eq 'PUT' || $type eq 'DELETE');
    die 'please provide a relative path' unless $path && $path !~ m{\A/api};
    die 'please provide a HASHREF with parameters' unless $params && ref $params eq 'HASH';
    my $method = lc $type;
    return $self->_ua->$method(
        'https://' . $self->{_domain} . '/api/v2/' . $path,
        [
            ($method eq 'post' || $method eq 'put'
                ? ('Content-Type' => 'application/json') : ()
            ),
        ],
        encode_json($params),
    );
}

sub _parse_search_args {
    my ($self, $search_args) = @_;
    my @query;
    foreach my $keyword (keys %$search_args) {
        die "Net::Zendesk: malformed search keyword '$keyword' contains spaces"
            if $keyword =~ /\s/;
        my $value = $search_args->{$keyword};
        if (ref $value) {
            if (ref $value eq 'HASH') {
                foreach my $inner_key (keys %$value) {
                    my %tokens = (
                        '='   => ':',
                        '>'   => '>',
                        '<'   => '<',
                        '>='  => '>=',
                        '<='  => '<=',
                        '!='  => ':',
                        'or'  => ':',
                        'and' => ':',
                    );
                    die "Net::Zendesk: invalid token '$inner_key' for keyword '$keyword'. Available tokens are " . join(', ', keys %tokens) unless exists $tokens{$inner_key};

                    my $inner_value = $value->{$inner_key};
                    $inner_value = 'none' unless defined $inner_value;

                    if (ref $inner_value) {
                        die 'Net::Zendesk: only scalar values or ARRAY references are supported. Got ' . ref($inner_value) . " for keyword '$keyword' under '$inner_key'." unless ref $inner_value eq 'ARRAY';
                        if ($inner_key eq 'and') {
                            push @query, $keyword . ':'
                            . join ' ', map {
                                defined $_ ? $_ =~ /\s/ ? qq("$_") : $_ : 'none'
                            } @$inner_value;
                        }
                        elsif ($inner_key eq '=' || $inner_key eq 'or') {
                            foreach my $or (@$inner_value) {
                                $or = 'none' unless defined $or;
                                $or = qq("$or") if $or =~ /\s/;
                                push @query, "$keyword$tokens{$inner_key}$or";
                            }
                        }
                        else {
                            die 'Net::Zendesk: only =,and,or tokens are allowed for references';
                        }
                    }
                    else {
                        $inner_value = qq("$inner_value") if $inner_value =~ /\s/;
                        push @query, ($inner_key eq '!=' ? '-' : '')
                                . "$keyword$tokens{$inner_key}$inner_value";
                            }
                }
            }
            elsif (ref $value eq 'ARRAY') {
                foreach my $or (@$value) {
                    $or = 'none' unless defined $or;
                    $or = qq("$or") if $or =~ /\s/;
                    push @query, "$keyword:$or";
                }
            }
            else {
                die 'Net::Zendesk: unsuported reference ' . ref($value) . '. Please use either a scalar or an ARRAY/HASH reference as a value for ' . $keyword;
            }
        }
        else {
            $value = 'none' unless defined $value;
            $value = qq("$value") if $value =~ /\s/;
            push @query, "$keyword:$value";
        }
    }
    return \@query;
}

sub _ua {
    my ($self) = @_;
    return $self->{_ua} if $self->{_ua};
    require Furl;
    require IO::Socket::SSL;
    IO::Socket::SSL->import;
    $self->{_ua} = Furl->new(
        headers => [
            'Accept'        => 'application/json',
            'Authorization' => 'Basic ' . $self->{_auth},
        ],
        ssl_opts => {
            SSL_verify_mode => SSL_VERIFY_PEER(),
        },
    );
}

1;
__END__