File Coverage

blib/lib/JIRA/Client.pm

Criterion	Covered	Total	%
statement	13	15	86.6
branch			n/a
condition			n/a
subroutine	5	5	100.0
pod			n/a
total	18	20	90.0

package JIRA::Client;
# ABSTRACT: (DEPRECATED) Extended interface to JIRA's SOAP API
$JIRA::Client::VERSION = '0.43';
use strict;
use warnings;

use Carp;
use Data::Util qw(:check);
use SOAP::Lite;


sub new {
    my ($class, @args) = @_;

    my $args;

    if (@args == 1) {
	$args = shift @args;
	is_hash_ref($args) or croak "$class::new sole argument must be a hash-ref.\n";
	foreach my $arg (qw/baseurl user password/) {
	    exists $args->{$arg}
		or croak "Missing $arg key to $class::new hash argument.\n";
	}
	$args->{soapargs} = [] unless exists $args->{soapargs};
    } elsif (@args >= 3) {
        my $baseurl  = shift @args;
        my $user     = shift @args;
        my $password = shift @args;
	$args = {
	    baseurl  => $baseurl,
	    user     => $user,
	    password => $password,
	    soapargs => \@args,
	};
    } else {
	croak "Invalid number of arguments to $class::new.\n";
    }

    $args->{wsdl} = '/rpc/soap/jirasoapservice-v2?wsdl' unless exists $args->{wsdl};

    my $url = $args->{baseurl};
    $url =~ s{/$}{}; # clean trailing slash
    $url .= $args->{wsdl};

    my $soap = SOAP::Lite->proxy($url, @{$args->{soapargs}});

    # Make all scalars be encoded as strings by default.
    $soap->typelookup({default => [0, sub {1}, 'as_string']});

    my $auth = $soap->login($args->{user}, $args->{password});
    croak $auth->faultcode(), ', ', $auth->faultstring()
        if defined $auth->fault();

    my $auth_result = $auth->result()
	or croak "Unknown error while connecting to JIRA. Please, check the URL.\n";

    my $self = {
        soap  => $soap,
        auth  => $auth_result,
        iter  => undef,
        cache => {
            components => {}, # project_key => {name => RemoteComponent}
            versions   => {}, # project_key => {name => RemoteVersion}
        },
    };

    return bless $self, $class;
}

# This empty DESTROY is necessary because we're using AUTOLOAD.
# http://www.perlmonks.org/?node_id=93045
sub DESTROY { }

# The issue "https://jira.atlassian.com/browse/JRA-12300" explains why
# some fields in JIRA have nonintuitive names. Here we map them.

my %JRA12300 = (
    affectsVersions => 'versions',
    type            => 'issuetype',
);

my %JRA12300_backwards = reverse %JRA12300;

# These are some helper functions to convert names into ids.

sub _convert_type {
    my ($self, $type) = @_;
    if ($type =~ /\D/) {
        my $types = $self->get_issue_types();
        return $types->{$type}{id} if exists $types->{$type};

	$types = $self->get_subtask_issue_types();
        return $types->{$type}{id} if exists $types->{$type};

        croak "There is no issue type called '$type'.\n";
    }
    return $type;
}

sub _convert_priority {
    my ($self, $prio) = @_;
    if ($prio =~ /\D/) {
        my $prios = $self->get_priorities();
        croak "There is no priority called '$prio'.\n"
            unless exists $prios->{$prio};
        return $prios->{$prio}{id};
    }
    return $prio;
}

sub _convert_resolution {
    my ($self, $resolution) = @_;
    if ($resolution =~ /\D/) {
        my $resolutions = $self->get_resolutions();
        croak "There is no resolution called '$resolution'.\n"
            unless exists $resolutions->{$resolution};
        return $resolutions->{$resolution}{id};
    }
    return $resolution;
}

sub _convert_security_level {
    my ($self, $seclevel, $project) = @_;
    if ($seclevel =~ /\D/) {
        my $seclevels = $self->get_security_levels($project);
        croak "There is no security level called '$seclevel'.\n"
            unless exists $seclevels->{$seclevel};
        return $seclevels->{$seclevel}{id};
    }
    return $seclevel;
}

# This routine receives an array with a list of $components specified
# by RemoteComponent objects, names, and ids. It returns an array of
# RemoteComponent objects.

sub _convert_components {
    my ($self, $components, $project) = @_;
    is_array_ref($components) or croak "The 'components' value must be an ARRAY ref.\n";
    my @converted;
    my $pcomponents;		# project components
    foreach my $component (@{$components}) {
	if (is_instance($component => 'RemoteComponent')) {
	    push @converted, $component;
	} elsif (is_integer($component)) {
	    push @converted, RemoteComponent->new($component);
	} else {
	    # It's a component name. Let us convert it into its id.
	    croak "Cannot convert component names because I don't know for which project.\n"
		unless $project;
	    $pcomponents = $self->get_components($project) unless defined $pcomponents;
	    croak "There is no component called '$component'.\n"
		unless exists $pcomponents->{$component};
	    push @converted, RemoteComponent->new($pcomponents->{$component}{id});
	}
    }
    return \@converted;
}

# This routine receives an array with a list of $versions specified by
# RemoteVersion objects, names, and ids. It returns an array of
# RemoteVersion objects.

sub _convert_versions {
    my ($self, $versions, $project) = @_;
    is_array_ref($versions) or croak "The '$versions' value must be an ARRAY ref.\n";
    my @converted;
    my $pversions;		# project versions
    foreach my $version (@{$versions}) {
	if (is_instance($version => 'RemoteVersion')) {
	    push @converted, $version;
	} elsif (is_integer($version)) {
	    push @converted, RemoteVersion->new($version);
	} else {
	    # It is a version name. Let us convert it into its id.
	    croak "Cannot convert version names because I don't know for which project.\n"
		unless $project;
	    $pversions = $self->get_versions($project) unless defined $pversions;
	    croak "There is no version called '$version'.\n"
		unless exists $pversions->{$version};
	    push @converted, RemoteVersion->new($pversions->{$version}{id});
	}
    }
    return \@converted;
}

# This routine returns a duedate as a SOAP::Data object with type
# 'date'. It can generate this from a DateTime object or from a string
# in the format YYYY-MM-DD.

sub _convert_duedate {
    my ($self, $duedate) = @_;
    if (is_instance($duedate => 'DateTime')) {
	return SOAP::Data->type(date => $duedate->strftime('%F'));
    } elsif (is_string($duedate)) {
	if (my ($year, $month, $day) = ($duedate =~ /^(\d{4})-(\d{2})-(\d{2})/)) {
	    $month >= 1 and $month <= 12
		or croak "Invalid duedate ($duedate).\n";
	    return SOAP::Data->type(date => $duedate);
	}
    }
    return $duedate;
}

# This routine receives a hash mapping custom field's ids to
# values. The ids can be specified by their real id or by their id's
# numeric suffix (as the 1000 in 'customfield_1000'). Scalar values
# are substituted by references to arrays containing the original
# value. The routine returns a hash-ref to another hash with converted
# keys and values.

sub _convert_custom_fields {
    my ($self, $custom_fields) = @_;
    is_hash_ref($custom_fields) or croak "The 'custom_fields' value must be a HASH ref.\n";
    my %converted;
    while (my ($id, $values) = each %$custom_fields) {
	my $realid = $id;
        unless ($realid =~ /^customfield_\d+$/) {
            my $cfs = $self->get_custom_fields();
            croak "Can't find custom field named '$id'.\n"
                unless exists $cfs->{$id};
            $realid = $cfs->{$id}{id};
        }

	# Custom field values must be specified as ARRAYs but we allow for some short-cuts.
	if (is_value($values)) {
	    $converted{$realid} = [$values];
	} elsif (is_array_ref($values)) {
	    $converted{$realid} = $values;
	} elsif (is_hash_ref($values)) {
	    # This is a short-cut for a Cascading select field, which
	    # must be specified like this: http://tinyurl.com/2bmthoa
	    # The short-cut requires a HASH where each cascading level
	    # is indexed by its level number, starting at zero.
	    foreach my $level (sort {$a <=> $b} keys %$values) {
		my $level_values = $values->{$level};
		$level_values = [$level_values] unless ref $level_values;
		if ($level eq '0') {
		    # The first level doesn't have a colon
		    $converted{$realid} = $level_values
		} elsif ($level =~ /^\d+$/) {
		    $converted{"$realid:$level"} = $level_values;
		} else {
		    croak "Invalid cascading field values level spec ($level). It must be a natural number.\n";
		}
	    }
	} else {
	    croak "Custom field '$id' got a '", ref($values), "' reference as a value.\nValues can only be specified as scalars, ARRAYs, or HASHes though.\n";
	}
    }
    return \%converted;
}

my %_converters = (
    affectsVersions => \&_convert_versions,
    components      => \&_convert_components,
    custom_fields   => \&_convert_custom_fields,
    duedate         => \&_convert_duedate,
    fixVersions     => \&_convert_versions,
    priority        => \&_convert_priority,
    resolution      => \&_convert_resolution,
    type            => \&_convert_type,
);

# Accept both names for fields with duplicate names.
foreach my $field (keys %JRA12300) {
    $_converters{$JRA12300{$field}} = $_converters{$field};
}

# This routine applies all the previous conversions to the $params
# hash. It returns a reference another hash with converted keys and
# values, which is the base for invoking the methods createIssue,
# UpdateIssue, and progressWorkflowAction.

sub _convert_params {
    my ($self, $params, $project) = @_;

    my %converted;

    # Convert fields' values
    while (my ($field, $value) = each %$params) {
	$converted{$field} =
	    exists $_converters{$field}
		? $_converters{$field}->($self, $value, $project)
		    : $value;
    }

    return \%converted;
}

# This routine gets a hash produced by _convert_params and flatens in
# place its Component, Version, and custom_fields fields. It also
# converts the hash's key according with the %JRA12300 table. It goes
# a step further before invoking the methods UpdateIssue and
# progressWorkflowAction.

sub _flaten_components_and_versions {
    my ($params) = @_;

    # Flaten Component and Version fields
    for my $field (grep {exists $params->{$_}} qw/components affectsVersions fixVersions/) {
	$params->{$field} = [map {$_->{id}} @{$params->{$field}}];
    }

    # Flaten the customFieldValues field
    if (my $custom_fields = delete $params->{custom_fields}) {
        while (my ($id, $values) = each %$custom_fields) {
            $params->{$id} = $values;
        }
    }

    # Due to a bug in JIRA we have to substitute the names of some fields.
    foreach my $field (grep {exists $params->{$_}} keys %JRA12300) {
	$params->{$JRA12300{$field}} = delete $params->{$field};
    }

    return;
}


sub create_issue
{
    my ($self, $params, $seclevel) = @_;
    is_hash_ref($params) or croak "create_issue's requires a HASH-ref argument.\n";
    for my $field (qw/project summary type/) {
        croak "create_issue's HASH ref must define a '$field'.\n"
            unless exists $params->{$field};
    }

    $params = $self->_convert_params($params, $params->{project});

    # Substitute customFieldValues array for custom_fields hash
    if (my $cfs = delete $params->{custom_fields}) {
        $params->{customFieldValues} = [map {RemoteCustomFieldValue->new($_, $cfs->{$_})} keys %$cfs];
    }

    if (my $parent = delete $params->{parent}) {
	if (defined $seclevel) {
	    return $self->createIssueWithParentWithSecurityLevel($params, $parent, _convert_security_level($self, $seclevel, $params->{project}));
	} else {
	    return $self->createIssueWithParent($params, $parent);
	}
    } else {
	if (defined $seclevel) {
	    return $self->createIssueWithSecurityLevel($params, _convert_security_level($self, $seclevel, $params->{project}));
	} else {
	    return $self->createIssue($params);
	}
    }
}


sub update_issue
{
    my ($self, $issue, $params) = @_;
    my $key;
    if (is_instance($issue => 'RemoteIssue')) {
	$key = $issue->{key};
    } else {
	$key = $issue;
	$issue = $self->getIssue($key);
    }

    is_hash_ref($params) or croak "update_issue second argument must be a HASH ref.\n";

    my ($project) = ($key =~ /^([^-]+)/);

    $params = $self->_convert_params($params, $project);

    _flaten_components_and_versions($params);

    return $self->updateIssue($key, $params);
}


sub get_issue_types {
    my ($self) = @_;
    $self->{cache}{issue_types} ||= {map {$_->{name} => $_} @{$self->getIssueTypes()}};
    return $self->{cache}{issue_types};
}


sub get_subtask_issue_types {
    my ($self) = @_;
    $self->{cache}{subtask_issue_types} ||= {map {$_->{name} => $_} @{$self->getSubTaskIssueTypes()}};
    return $self->{cache}{subtask_issue_types};
}


sub get_statuses {
    my ($self) = @_;
    $self->{cache}{statuses} ||= {map {$_->{name} => $_} @{$self->getStatuses()}};
    return $self->{cache}{statuses};
}


sub get_priorities {
    my ($self) = @_;
    $self->{cache}{priorities} ||= {map {$_->{name} => $_} @{$self->getPriorities()}};
    return $self->{cache}{priorities};
}


sub get_resolutions {
    my ($self) = @_;
    $self->{cache}{resolutions} ||= {map {$_->{name} => $_} @{$self->getResolutions()}};
    return $self->{cache}{resolutions};
}


sub get_security_levels {
    my ($self, $project_key) = @_;
    $self->{cache}{seclevels}{$project_key} ||= {map {$_->{name} => $_} @{$self->getSecurityLevels($project_key)}};
    return $self->{cache}{seclevels}{$project_key};
}


sub get_custom_fields {
    my ($self) = @_;
    $self->{cache}{custom_fields} ||= {map {$_->{name} => $_} @{$self->getCustomFields()}};
    return $self->{cache}{custom_fields};
}


sub set_custom_fields {
    my ($self, $cfs) = @_;
    $self->{cache}{custom_fields} = $cfs;
    return;
}


sub get_components {
    my ($self, $project_key) = @_;
    $self->{cache}{components}{$project_key} ||= {map {$_->{name} => $_} @{$self->getComponents($project_key)}};
    return $self->{cache}{components}{$project_key};
}


sub get_versions {
    my ($self, $project_key) = @_;
    $self->{cache}{versions}{$project_key} ||= {map {$_->{name} => $_} @{$self->getVersions($project_key)}};
    return $self->{cache}{versions}{$project_key};
}


sub get_favourite_filters {
    my ($self) = @_;
    $self->{cache}{filters} ||= {map {$_->{name} => $_} @{$self->getFavouriteFilters()}};
    return $self->{cache}{filters};
}


sub set_filter_iterator {
    my ($self, $filter, $cache_size) = @_;

    if ($filter =~ /\D/) {
        my $filters = $self->getSavedFilters();
        foreach my $f (@$filters) {
            if ($f->{name} eq $filter) {
                $filter = $f->{id};
                last;
            }
        }
        croak "Can't find filter '$filter'\n" if $filter =~ /\D/;
    }

    if ($cache_size) {
        croak "set_filter_iterator's second arg must be a number ($cache_size).\n"
            if $cache_size =~ /\D/;
    }

    $self->{iter} = {
        id     => $filter,
        offset => 0,  # offset to be used in the next call to getIssuesFromFilterWithLimit
        issues => [], # issues returned by the last call to getIssuesFromFilterWithLimit
        size   => $cache_size || 128,
    };

    return;
}


sub next_issue {
    my ($self) = @_;
    defined $self->{iter}
        or croak "You must call setFilterIterator before calling nextIssue\n";
    my $iter = $self->{iter};
    if (@{$iter->{issues}} == 0) {
        if ($iter->{id}) {
            my $issues = eval {$self->getIssuesFromFilterWithLimit($iter->{id}, $iter->{offset}, $iter->{size})};
            if ($@) {
                # The getIssuesFromFilterWithLimit appeared in JIRA
                # 3.13.4. Before that we had to use the unsafe
                # getIssuesFromFilter. Here we detect that we're talking
                # with an old JIRA and resort to the deprecated method
                # instead.
                croak $@ unless $@ =~ /No such operation/;
                $iter->{issues} = $self->getIssuesFromFilter($iter->{id});
                $iter->{id}     = undef;
            }
            elsif (@$issues) {
                $iter->{offset} += @$issues;
                $iter->{issues}  =  $issues;
            }
            else {
                $self->{iter} = undef;
                return;
            }
        }
        else {
            return;
        }
    }
    return shift @{$iter->{issues}};
}


sub progress_workflow_action_safely {
    my ($self, $issue, $action, $params) = @_;
    my $key;
    if (is_instance($issue => 'RemoteIssue')) {
        $key   = $issue->{key};
    } else {
	$key   = $issue;
	$issue = undef;
    }
    $params = {} unless defined $params;
    is_hash_ref($params) or croak "progress_workflow_action_safely's third arg must be a HASH-ref\n";

    # Grok the action id if it's not a number
    if ($action =~ /\D/) {
        my @available_actions = @{$self->getAvailableActions($key)};
        my @named_actions     = grep {$action eq $_->{name}} @available_actions;
        if (@named_actions) {
            $action = $named_actions[0]->{id};
        } else {
            croak "Unavailable action ($action).\n";
        }
    }

    # Make sure $params contains all the fields that are present in
    # the action screen.
    my @fields = @{$self->getFieldsForAction($key, $action)};
    foreach my $id (map {$_->{id}} @fields) {
        # Due to a bug in JIRA we have to substitute the names of some fields.
	$id = $JRA12300_backwards{$id} if $JRA12300_backwards{$id};

        next if exists $params->{$id};

        $issue = $self->getIssue($key) unless defined $issue;
        if (exists $issue->{$id}) {
            $params->{$id} = $issue->{$id} if defined $issue->{$id};
        }
	# NOTE: It's not a problem if we can't find a missing
	# parameter in the issue. It will simply stay undefined.
    }

    my ($project) = ($key =~ /^([^-]+)/);

    $params = $self->_convert_params($params, $project);

    _flaten_components_and_versions($params);

    return $self->progressWorkflowAction($key, $action, $params);
}


sub get_issue_custom_field_values {
    my ($self, $issue, @cfs) = @_;
    my @values;
    my $cfs;
  CUSTOM_FIELD:
    foreach my $cf (@cfs) {
        unless ($cf =~ /^customfield_\d+$/) {
            $cfs = $self->get_custom_fields() unless defined $cfs;
            croak "Can't find custom field named '$cf'.\n"
                unless exists $cfs->{$cf};
            $cf = $cfs->{$cf}{id};
        }
        foreach my $rcfv (@{$issue->{customFieldValues}}) {
            if ($rcfv->{customfieldId} eq $cf) {
                push @values, $rcfv->{values};
                next CUSTOM_FIELD;
            }
        }
        push @values, undef;    # unset custom field
    }
    return wantarray ? @values : \@values;
}


sub attach_files_to_issue {
    my ($self, $issue, @files) = @_;

    # First we process the @files specification. Filenames are pushed
    # in @filenames and @attachments will end up with IO objects from
    # which the file contents are going to be read later.

    my (@filenames, @attachments);

    for my $file (@files) {
	if (is_string($file)) {
	    require File::Basename;
	    push @filenames, File::Basename::basename($file);
	    open my $fh, '<:raw', $file
		or croak "Can't open $file: $!\n";
	    push @attachments, $fh;
            close $fh;
	} elsif (is_hash_ref($file)) {
	    while (my ($name, $contents) = each %$file) {
		push @filenames, $name;
		if (is_string($contents)) {
		    open my $fh, '<:raw', $contents
			or croak "Can't open $contents: $!\n";
		    push @attachments, $fh;
                    close $fh;
		} elsif (is_glob_ref($contents)
			     || is_instance($contents => 'IO::File')
				 || is_instance($contents => 'FileHandle')) {
		    push @attachments, $contents;
		} else {
		    croak "Invalid content specification for file $name.\n";
		}
	    }
	} else {
	    croak "Files must be specified by STRINGs or HASHes, not by " . ref($file) . "s\n";
	}
    }

    # Now we have to read all file contents and encode them to Base64.

    require MIME::Base64;
    for my $i (0 .. $#attachments) {
	my $fh = $attachments[$i];
	my $attachment = '';
	my $chars_read;
	while ($chars_read = read $fh, my $buf, 57*72) {
	    $attachment .= MIME::Base64::encode_base64($buf);
	}
	defined $chars_read
	    or croak "Error reading '$filenames[$i]': $!\n";
	length $attachment
	    or croak "Can't attach empty file '$filenames[$i]'\n";
	$attachments[$i] = $attachment;
    }

    return $self->addBase64EncodedAttachmentsToIssue($issue, \@filenames, \@attachments);
}


sub attach_strings_to_issue {
    my ($self, $issue, $hash) = @_;

    require MIME::Base64;

    my (@filenames, @attachments);

    while (my ($filename, $contents) = each %$hash) {
	push @filenames,   $filename;
	push @attachments, MIME::Base64::encode_base64($contents);
    }

    return $self->addBase64EncodedAttachmentsToIssue($issue, \@filenames, \@attachments);
}


sub filter_issues_unsorted {
    my ($self, $filter, $limit) = @_;

    $filter =~ s/^\s*"?//;
    $filter =~ s/"?\s*$//;

    if ($filter =~ /^(?:[A-Z]+-\d+\s+)*[A-Z]+-\d+$/i) {
        # space separated key list

        # Let's construct a JQL query in the form "issuekey IN (...)" to
        # pass to getIssuesFromJqlSearch.

        my %keys = map {($_ => undef)} split / /, $filter; # discard duplicates
        my @keys = keys %keys;

        # If the list is too big we split it up and invoke
        # getIssuesFromJqlSearch several times.
        my @issues;
        while (my @subkeys = splice(@keys, 0, 128)) {
            my $jql = 'issuekey IN (' . join(',', @subkeys) . ')';
            push @issues, @{$self->getIssuesFromJqlSearch($jql, 1000)};
        }
        return @issues;
    } elsif ($filter =~ /^[\w-]+$/i) {
        # saved filter
        return @{$self->getIssuesFromFilterWithLimit($filter, 0, $limit || 1000)};
    } else {
        # JQL filter
        return @{$self->getIssuesFromJqlSearch($filter, $limit || 1000)};
    }
}


sub filter_issues {
    my ($self, $filter, $limit) = @_;

    # Order the issues by project key and then by numeric value using
    # a Schwartzian transform.
    return
        map  {$_->[2]}
            sort {$a->[0] cmp $b->[0] or $a->[1] <=> $b->[1]}
                map  {my ($p, $n) = ($_->{key} =~ /([A-Z]+)-(\d+)/); [$p, $n, $_]}
                    filter_issues_unsorted($self, $filter, $limit);
}


## no critic (Modules::ProhibitMultiplePackages)

package RemoteFieldValue;
$RemoteFieldValue::VERSION = '0.43';
sub new {
    my ($class, $id, $values) = @_;

    # Due to a bug in JIRA we have to substitute the names of some fields.
    $id = $JRA12300{$id} if exists $JRA12300{$id};

    $values = [$values] unless ref $values;
    return bless({id => $id, values => $values}, $class);
}


package RemoteCustomFieldValue;
$RemoteCustomFieldValue::VERSION = '0.43';
sub new {
    my ($class, $id, $values) = @_;

    $values = [$values] unless ref $values;
    return bless({customfieldId => $id, key => undef, values => $values} => $class);
}


package RemoteComponent;
$RemoteComponent::VERSION = '0.43';
sub new {
    my ($class, $id, $name) = @_;
    my $o = bless({id => $id}, $class);
    $o->{name} = $name if $name;
    return $o;
}


package RemoteVersion;
$RemoteVersion::VERSION = '0.43';
sub new {
    my ($class, $id, $name) = @_;
    my $o = bless({id => $id}, $class);
    $o->{name} = $name if $name;
    return $o;
}

package JIRA::Client;

# Almost all of the JIRA API parameters are strings. The %typeof hash
# specifies the exceptions. It maps a method name to a hash mapping a
# parameter position to its type. (The parameter position is
# zero-based, after the authentication token.

my %typeof = (
    addActorsToProjectRole                   => {1 => \&_cast_remote_project_role},
    addAttachmentsToIssue              	     => \&_cast_attachments,
    addBase64EncodedAttachmentsToIssue 	     => \&_cast_base64encodedattachments,
    addComment                         	     => {0 => \&_cast_issue_key, 1 => \&_cast_remote_comment},
    addDefaultActorsToProjectRole            => {1 => \&_cast_remote_project_role},
    # addPermissionTo
    # addUserToGroup
    # addVersion
    addWorklogAndAutoAdjustRemainingEstimate => {0 => \&_cast_issue_key},
    addWorklogAndRetainRemainingEstimate     => {0 => \&_cast_issue_key},
    addWorklogWithNewRemainingEstimate       => {0 => \&_cast_issue_key},
    archiveVersion                     	     => {2 => 'boolean'},
    # createGroup
    # createIssue
    createIssueWithParent                    => {1 => \&_cast_issue_key},
    createIssueWithParentWithSecurityLevel   => {1 => \&_cast_issue_key, 2 => 'long'},
    createIssueWithSecurityLevel       	     => {1 => 'long'},
    # createPermissionScheme
    # createProject
    # createProjectFromObject
    createProjectRole                        => {0 => \&_cast_remote_project_role},
    # createUser
    # deleteGroup
    deleteIssue                 	     => {0 => \&_cast_issue_key},
    # deletePermissionFrom
    # deletePermissionScheme
    # deleteProject
    deleteProjectAvatar                	     => {0 => 'long'},
    deleteProjectRole                  	     => {0 => \&_cast_remote_project_role, 1 => 'boolean'},
    # deleteUser
    # deleteWorklogAndAutoAdjustRemainingEstimate
    # deleteWorklogAndRetainRemainingEstimate
    # deleteWorklogWithNewRemainingEstimate
    # editComment
    # getAllPermissions
    getAssociatedNotificationSchemes         => {0 => \&_cast_remote_project_role},
    getAssociatedPermissionSchemes           => {0 => \&_cast_remote_project_role},
    getAttachmentsFromIssue           	     => {0 => \&_cast_issue_key},
    getAvailableActions           	     => {0 => \&_cast_issue_key},
    getComment                         	     => {0 => 'long'},
    getComments                        	     => {0 => \&_cast_issue_key},
    # getComponents
    # getConfiguration
    # getCustomFields
    getDefaultRoleActors                     => {0 => \&_cast_remote_project_role},
    # getFavouriteFilters
    getFieldsForAction                 	     => {0 => \&_cast_issue_key},
    getFieldsForCreate                       => {1 => 'long'},
    getFieldsForEdit                 	     => {0 => \&_cast_issue_key},
    # getGroup
    getIssue	                 	     => {0 => \&_cast_issue_key},
    # getIssueById
    getIssueCountForFilter             	     => {0 => \&_cast_filter_name_to_id},
    getIssuesFromFilter                	     => {0 => \&_cast_filter_name_to_id},
    getIssuesFromFilterWithLimit       	     => {0 => \&_cast_filter_name_to_id, 1 => 'int', 2 => 'int'},
    getIssuesFromJqlSearch             	     => {1 => 'int'},
    # getIssuesFromTextSearch
    getIssuesFromTextSearchWithLimit   	     => {1 => 'int', 2 => 'int'},
    getIssuesFromTextSearchWithProject 	     => {2 => 'int'},
    # getIssueTypes
    # getIssueTypesForProject
    # getNotificationSchemes
    # getPermissionSchemes
    # getPriorities
    # getProjectAvatar
    getProjectAvatars                  	     => {1 => 'boolean'},
    getProjectById                     	     => {0 => 'long'},
    # getProjectByKey
    getProjectRole                     	     => {0 => 'long'},
    getProjectRoleActors               	     => {0 => \&_cast_remote_project_role},
    # getProjectRoles
    # getProjectsNoSchemes
    getProjectWithSchemesById          	     => {0 => 'long'},
    getResolutionDateById              	     => {0 => 'long'},
    getResolutionDateByKey             	     => {0 => \&_cast_issue_key},
    # getResolutions
    # getSavedFilters
    getSecurityLevel             	     => {0 => \&_cast_issue_key},
    # getSecurityLevels
    # getSecuritySchemes
    # getServerInfo
    # getStatuses
    # getSubTaskIssueTypes
    # getSubTaskIssueTypesForProject
    # getUser
    # getVersions
    getWorklogs		             	     => {0 => \&_cast_issue_key},
    hasPermissionToCreateWorklog       	     => {0 => \&_cast_issue_key},
    # hasPermissionToDeleteWorklog
    # hasPermissionToEditComment
    # hasPermissionToUpdateWorklog
    # isProjectRoleNameUnique
    # login ##NOT USED##
    # logout ##NOT USED##
    progressWorkflowAction             	     => {0 => \&_cast_issue_key, 2 => \&_cast_remote_field_values},
    # refreshCustomFields
    # releaseVersion
    removeActorsFromProjectRole              => {1 => \&_cast_remote_project_role},
    # removeAllRoleActorsByNameAndType
    # removeAllRoleActorsByProject
    removeDefaultActorsFromProjectRole       => {1 => \&_cast_remote_project_role},
    # removeUserFromGroup
    # setNewProjectAvatar
    setProjectAvatar                   	     => {1 => 'long'},
    # setUserPassword
    # updateGroup
    updateIssue                        	     => {0 => \&_cast_issue_key, 1 => \&_cast_remote_field_values},
    # updateProject
    updateProjectRole                        => {0 => \&_cast_remote_project_role},
    # updateUser
    # updateWorklogAndAutoAdjustRemainingEstimate
    # updateWorklogAndRetainRemainingEstimate
    # updateWorklogWithNewRemainingEstimate
);

sub _cast_issue_key {
    my ($self, $issue) = @_;
    return ref $issue ? $issue->{key} : $issue;
}

sub _cast_remote_comment {
    my ($self, $arg) = @_;
    return ref $arg ? $arg : bless({body => $arg} => 'RemoteComment');
}

sub _cast_filter_name_to_id {
    my ($self, $arg) = @_;
    is_string($arg) or croak "Filter arg must be a string.\n";
    return $arg unless $arg =~ /\D/;
    my $filters = $self->get_favourite_filters();
    exists $filters->{$arg} or croak "Unknown filter: $arg\n";
    return $filters->{$arg}{id};
}

sub _cast_remote_field_values {
    my ($self, $arg) = @_;
    return is_hash_ref($arg) ? [map {RemoteFieldValue->new($_, $arg->{$_})} keys %$arg] : $arg;
}

sub _cast_remote_project_role {
    my ($self, $arg) = @_;
    if (is_instance($arg => 'RemoteProjectRole') && exists $arg->{id} && is_string($arg->{id})) {
	$arg->{id} = SOAP::Data->type(long => $arg->{id});
    }
    return $arg;
}

sub _cast_attachments {
    my ($self, $method, $args) = @_;
    # The addAttachmentsToIssue method is deprecated and requires too
    # much overhead to pass the file contents over the wire. Here we
    # convert the arguments to call the newer
    # addBase64EncodedAttachmentsToIssue method instead.
    require MIME::Base64;
    for my $content (@{$args->[2]}) {
	$content = MIME::Base64::encode_base64($content);
    }
    $$method = 'addBase64EncodedAttachmentsToIssue';
    _cast_base64encodedattachments($self, $method, $args);
    return;
}

sub _cast_base64encodedattachments {
    my ($self, $method, $args) = @_;
    $args->[0] = _cast_issue_key($self, $args->[0]);
    # We have to set the names of the arrays and of its elements
    # because the default naming isn't properly understood by JIRA.
    for my $i (1 .. 2) {
	$args->[$i] = SOAP::Data->name(
	    "array$i",
	    [map {SOAP::Data->name("elem$i", $_)} @{$args->[$i]}],
	);
    }
    return;
}

# All methods follow the same call convention, which makes it easy to
# implement them all with an AUTOLOAD.

our $AUTOLOAD;
sub AUTOLOAD {
    my ($self, @args) = @_;
    (my $method = $AUTOLOAD) =~ s/.*:://;

    # Perform any non-default type coersion
    if (my $typeof = $typeof{$method}) {
	if (is_hash_ref($typeof)) {
	    while (my ($i, $type) = each %$typeof) {
		if (is_code_ref($type)) {
		    $args[$i] = $type->($self, $args[$i]);
		} elsif (is_value($args[$i])) {
		    $args[$i] = SOAP::Data->type($type => $args[$i]);
		} elsif (is_array_ref($args[$i])) {
		    foreach (@{$args[$i]}) {
			$_ = SOAP::Data->type($type => $_);
		    }
		} elsif (is_hash_ref($args[$i])) {
		    foreach (values %{$args[$i]}) {
			$_ = SOAP::Data->type($type => $_);
		    }
		} else {
		    croak "Can't coerse argument $i of method $AUTOLOAD.\n";
		}
	    }
	} elsif (is_code_ref($typeof)) {
	    $typeof->($self, \$method, \@args);
	}
    }

    my $call = $self->{soap}->call($method, $self->{auth}, @args);
    croak $call->faultcode(), ', ', $call->faultstring()
        if defined $call->fault();
    return $call->result();
}


1; # End of JIRA::Client

__END__