/ 
RT-Client-REST-0.13
River stage one • 4 direct dependents • 4 total dependents
/ RT::Client::REST

NAME

RT::Client::REST -- talk to RT installation using REST protocol.

SYNOPSIS

my $rt = RT::Client::REST->new(
  username => $user,
  password => $pass,
  server => 'http://example.com/rt',
);

try {
  # Get tickets 10 through 20
  @tx = $rt->show(type => 'ticket', objects => [10 .. 20]);
} catch RT::Client::REST::Exception with {
  # something went wrong.
};

DESCRIPTION

RT::Client::REST is /usr/bin/rt converted to a Perl module. I needed to implement some RT interactions from my application, but did not feel that invoking a shell command is appropriate. Thus, I took rt tool, written by Abhijit Menon-Sen, and converted it to an object-oriented Perl module.

RT::Client::REST does not (at the moment, see TODO file) retrieve forms from RT server, which is either good or bad, depending how you look at it. More work on this module will be performed in the future as I get a better grip of this whole REST business.

USAGE NOTES

This API mimics that of 'rt'. For a more OO-style APIs, please use RT::Client::REST::Object-derived classes: RT::Client::REST::Ticket and RT::Client::REST::User (the latter is not implemented yet).

METHODS

new ()

The constructor can take these options:

  • server is a URI pointing to your RT installation.

  • username and password are used to authenticate your request. After an instance of RT::Client::REST is used to issue a successful request, subsequent requests will use a cookie, so the first request is an effect a log in.

  • Alternatively, if you have already authenticated against RT in some other part of your program, you can use cookie parameter to supply an object of type HTTP::Cookies to use for credentials information.

  • All of the above, server, username, password, and cookie can also be used as regular methods after your object is instantiated.

show (type => $type, objects => \@ids)

Get a list of objects of type 4type. One or more IDs should be specified. This returns an array of hashrefs (I don't get "forms", so I just take the third element and return it).

edit (type => $type, objects => \@ids, set => { status => 1 })

For all objects of type $type whose ID is in @ids, set fields as prescribed by the set parameter.

create (type => $type, set => \%params)

Create a new object of type $type and set initial parameters to %params. Returns numeric ID of the new object. If numeric ID cannot be parsed from the response, RT::Client::REST::MalformedRTResponseException is thrown.

search (type => $type, query => $query, %opts)

Search for object of type $type by using query $query. For example:

# Find all stalled tickets
my @ids = $rt->search(
  type => 'ticket',
  query => "Status = 'stalled'",
);

%opts is a list of key-value pairs:

orderby

The value is the name of the field you want to sort by. Plus or minus sign in front of it signifies ascending order (plus) or descending order (minus). For example:

# Get all stalled tickets in reverse order:
my @ids = $rt->search(
  type => 'ticket',
  query => "Status = 'stalled'",
  orderby => '-id',
);

search returns the list of numeric IDs of objects that matched your query. You can then use these to retrieve object information using show() method:

my @ids = $rt->search(
  type => 'ticket',
  query => "Status = 'stalled'",
);
for my $id (@ids) {
  my ($ticket) = $rt->show(type => 'ticket', ids => [$id]);
  print "Subject: ", $t->{Subject}, "\n";
}
comment (ticket_id => $id, message => $message, %opts)

Comment on a ticket with ID $id. Optionally takes arguments cc and bcc which are references to lists of e-mail addresses:

$rt->comment(
  ticket_id   => 5,
  message     => "Wild thing, you make my heart sing",
  cc          => [qw(dmitri@localhost some@otherdude.com)],
);
correspond (ticket_id => $id, message => $message, %opts)

Add correspondence to ticket ID $id. Takes optional cc and bcc parameters (see comment above).

merge_tickets (src => $id1, dst => $id2)

Merge ticket $id1 into ticket $id2.

Create a link between two tickets. A link type can be one of the following:

  • DependsOn

  • DependedOnBy

  • RefersTo

  • ReferredToBy

  • HasMember

  • MemberOf

Remove a link between two tickets (see link_tickets())

EXCEPTIONS

When an error occurs, this module will throw exceptions. I recommend using Error.pm's try{} mechanism to catch them, but you may also use simple eval{}. The former will give you flexibility to catch just the exceptions you want. Here is the hierarchy:

  • RT::Client::REST::Exception

    • RT::Client::REST::OddNumberOfArgumentsException

    • RT::Client::REST::InvaildObjectTypeException

    • RT::Client::REST::MalformedRTResponseException

    • RT::Client::REST::InvalidParameterValueException

    • RT::Client::REST::RTException. This exception is virtual; only its subclasses are thrown. This group is used when RT REST interface returns an error message. Exceptions derived from it all have a custom field code which can be used to get RT's numeric error code.

      • RT::Client::REST::ObjectNotFoundException

      • RT::Client::REST::CouldNotCreateObjectException

      • RT::Client::REST::AuthenticationFailureException

      • RT::Client::REST::UnknownRTException

    • RT::Client::REST::HTTPException. This is thrown if anything besides 200 OK code is returned by the underlying HTTP protocol. Custom field code can be used to access the actual HTTP status code.

DEPENDENCIES

The following modules are required:

  • Error

  • Exception::Class

  • LWP

  • HTTP::Cookies

  • HTTP::Request::Common

BUGS

Most likely. Please report.

TODO

  • Add the rest of the features available in /usr/bin/rt.

  • Implement /usr/bin/rt using this RT::Client::REST.

VERSION

This is version 0.13 of RT::Client::REST.

AUTHORS

Original /usr/bin/rt was written by Abhijit Menon-Sen <ams@wiw.org>. rt was later converted to this module by Dmitri Tikhonov <dtikhonov@vonage.com>

LICENSE

Since original rt is licensed under GPL, so is this module.