View source for Contribute: Plugins/ImportPluginsAWS

= Import Plugin Tutorial 2: Amazon Web Services =

In the [[Contribute:_Plugins/ImportPluginsCSV|last tutorial]] we created an import plugin that took data which needed very little modification to import into the respository. The column names in the [http://en.wikipedia.org/wiki/Comma-Separated_Values CSV] file matched the names of metadata fields present in the repository. In this tutorial we'll look at importing data that needs some modification to be imported, needs more error checking and is obtained in a different way.

We will be using Amazon's E-Commerce Webservice to import books from their website into our respository given a list of [http://en.wikipedia.org/wiki/ASIN ASIN].

We will be accessing the service using a [http://en.wikipedia.org/wiki/REST REST] approach, communicating with the server using URL parameters and retrieving an XML document in response to our request. It is also possible to access their services using [http://en.wikipedia.org/wiki/SOAP SOAP], but that will not be discussed here.

= Before You Start =

== Amazon Web Services ==
To use Amazon's web services you must first signup for an account [http://aws.amazon.com here]. Their site has extensive documentation on the services that they offer as well as example programs including some written in Perl.

== Required Modules ==
To prepare for this tutorial you should make sure the [http://search.cpan.org/~gaas/libwww-perl-5.805/lib/LWP/UserAgent.pm LWP::UserAgent] module is installed. The following command as root, or using sudo should work.

<pre>
cpan LWP::UserAgent
</pre>

= AWS.pm = 
The code in the section below should be placed in a file called CSV.pm in the directory created previously, and MyPlugins should be changed to the name of that directory.

<pre>
package EPrints::Plugin::Import::MyPlugins::AWS;

use EPrints::Plugin::Import::TextFile;
use strict;
use URI::Escape;

our @ISA = ('EPrints::Plugin::Import::TextFile');

my $endpoint = 'http://ecs.amazonaws.co.uk/onca/xml';
my $accesskey = '<YOURAMAZONWSKEY>';
my $service = 'AWSECommerceService';
my $operation = 'ItemLookup';
my $version = '2007-07-16';
my $responsegroup = 'Large';

sub new
{
        my( $class, %params ) = @_;
        my $self = $class->SUPER::new( %params );

        $self->{name} = 'AWS';
        $self->{visible} = 'all';
        $self->{produce} = [ 'list/eprint' , 'dataobj/eprint'];

        my $rc = EPrints::Utils::require_if_exists('LWP::UserAgent');
        unless ($rc)
        {
                $self->{visible} = '';
                $self->{error} = 'Unable to load required module LWP::UserAgent';
        }

        return $self;
}

sub input_fh
{
        my( $plugin, %opts ) = @_;
        my @ids;
        my $fh = $opts{fh};

        my @records = <$fh>;
        foreach my $input_data (@records)
        {
                my $epdata = $plugin->convert_input($input_data);
                next unless defined $epdata;

                my $dataobj = $plugin->epdata_to_dataobj($opts{dataset},$epdata);
                if( defined $dataobj )
                {
                        push @ids, $dataobj->get_id;
                }
        }

        return EPrints::List->new(
                        dataset => $opts{dataset},
                        session => $plugin->{session},
                        ids=>\@ids );
}

sub convert_input
{
        my ($plugin, $input) = @_;
        my %output = ();

        $input =~ m/([0-9]+)/;
        $input = $1;

        my $request =
                "$endpoint?".
                "Service=$service&".
                "AWSAccessKeyId=$accesskey&".
                "Operation=$operation&".
                "ItemId=$input&".
                "Version=$version&".
                "ResponseGroup=$responsegroup";

        my $ua = LWP::UserAgent->new;
        $ua->timeout(30);
        my $response = $ua->get($request);

        my $dom = EPrints::XML::parse_xml_string($response->content);

        my $rep =
                $dom->getElementsByTagName('Items')->item(0)->
                getElementsByTagName('Request')->item(0);

        my $reptext =
                EPrints::Utils::tree_to_utf8($rep->getElementsByTagName('IsValid')->item(0));

        unless ($reptext eq 'True') 
        {
                $plugin->error('Invalid AWS Request');
                return undef;
        }

        #Get Item Object
        my $item =
                $dom->getElementsByTagName('Items')->item(0)->
                getElementsByTagName('Item')->item(0);

        unless (defined $item) 
        {
                $plugin->error('No Item element found');
                return undef;
        }

        my $attr = $item->getElementsByTagName('ItemAttributes')->item(0);

        my $pg = EPrints::Utils::tree_to_utf8($attr->getElementsByTagName('ProductGroup')->item(0));

        unless ($pg eq 'Book') 
        {
                $plugin->error('Product is not a book.');
                return undef;
        }

        $output{type} = 'book';
        $output{refereed} = 'FALSE';
        $output{ispublished} = 'pub';

        my $title = $attr->getElementsByTagName('Title')->item(0);
        $output{title} = EPrints::Utils::tree_to_utf8($title);

        my $url = $item->getElementsByTagName('DetailPageURL')->item(0);
        $output{official_url} = uri_unescape(EPrints::Utils::tree_to_utf8($url));

        my $isbn = $attr->getElementsByTagName('ISBN')->item(0);
        if (defined $isbn)
        {
                $output{isbn} = EPrints::Utils::tree_to_utf8($isbn);
        }

        my $pages = $attr->getElementsByTagName('NumberOfPages')->item(0);
        if (defined $pages)
        {
                $output{pages} = EPrints::Utils::tree_to_utf8($pages);
        }

        my $publisher = $attr->getElementsByTagName('Publisher')->item(0);
        if (defined $publisher)
        {
                $output{publisher} = EPrints::Utils::tree_to_utf8($publisher);
        }

        my $pubdate = $attr->getElementsByTagName('PublicationDate')->item(0);
        if (defined $pubdate)
        {
                $output{date} = EPrints::Utils::tree_to_utf8($pubdate);
        }

        return \%output;
}

1;
</pre>

= In More Detail =
We will use the URI::Escape module in this plugin. As it is included with EPrints we don't need to check if it exists first.
<pre>
use URI::Escape;
</pre>

Here we setup a number of values for parameters that will be part of our web service requests. The endpoint variable determines which server will be sent the request. Here we have used the UK server, but by changing the TLD we can use the US, Canadian, German or French servers.

The accesskey stores the access key you will have gained from signing up to Amazon earlier. You should use the normal access key and not the secret one.

Here we use the ItemLookup operation of the AWSECommerceService with the 2007-07-16 version of the service API. Other operations allow searching for items, but here we want to look up specific products. Finally the variable responsegroup determines the amount and nature of the information returned, we select "Large" in this case, giving a lot of information about the item.

<pre>
my $endpoint = 'http://ecs.amazonaws.co.uk/onca/xml';
my $accesskey = '<YOURAMAZONWSKEY>';
my $service = 'AWSECommerceService';
my $operation = 'ItemLookup';
my $version = '2007-07-16';
my $responsegroup = 'Large';
</pre>

== Constructor ==
The constructor is similar to the one used for the CSV plugin, except this one will import individual eprints, given an ASIN.
<pre>
        $self->{produce} = [ 'list/eprint' , 'dataobj/eprint'];
</pre>

Like we imported Text::CSV in the last tutorial, here we import LWP::UserAgent which will be used for making requests to the web service.
<pre>
        my $rc = EPrints::Utils::require_if_exists('LWP::UserAgent');
        unless ($rc)
        {
                $self->{visible} = '';
                $self->{error} = 'Unable to load required module LWP::UserAgent';
        }
</pre>

== Input ==
=== input_fh ===
This method is similar to the one used in the CSV plugin, but doesn't have to do quite so much work.

First we create the array to hold our imported eprint ids.
<pre>
        my @ids;
</pre>

Next we read all the lines in the supplied file handle into our records array.
<pre>
        my $fh = $opts{fh};

        my @records = <$fh>;
</pre>

Then we iterate over each record, running convert_input on it, importing it into our repository and adding the id to our array.
<pre>
        foreach my $input_data (@records)
        {
                my $epdata = $plugin->convert_input($input_data);
                next unless defined $epdata;

                my $dataobj = $plugin->epdata_to_dataobj($opts{dataset},$epdata);
                if( defined $dataobj )
                {
                        push @ids, $dataobj->get_id;
                }
        }
</pre>

Then we return a List object of the items imported.
<pre>
        return EPrints::List->new(
                        dataset => $opts{dataset},
                        session => $plugin->{session},
                        ids=>\@ids );
</pre>

=== convert_input ===

ASINs are strings of decimal digits which may have leading zeroes which identify a product. Here we remove any non-numerical characters which are surrounding the ASIN.
<pre>
        $input =~ m/([0-9]+)/;
        $input = $1;
</pre>

We form the request from the variables we created earlier and the ASIN we have just obtained.
<pre>
        my $request =
                "$endpoint?".
                "Service=$service&".
                "AWSAccessKeyId=$accesskey&".
                "Operation=$operation&".
                "ItemId=$input&".
                "Version=$version&".
                "ResponseGroup=$responsegroup";
</pre>

We now send the request, by creating a new LWP::UserAgent object, setting its timeout to 30 seconds and then performing the request using HTTP GET.
<pre>
        my $ua = LWP::UserAgent->new;
        $ua->timeout(30);
        my $response = $ua->get($request);
</pre>

We then create a DOM object from the XML document returned.
<pre>
        my $dom = EPrints::XML::parse_xml_string($response->content);
</pre>

Each request contains an Items element within the root element of the document which contains a Request element. This element contains an element IsValid. This element will contain the value True or False depending on whether a valid request was made or not.

Here we obtain the Request element and check that the IsValid element within it contains the value True. If it doesn't we  call the error method and return undef.
<pre>
        my $rep =
                $dom->getElementsByTagName("Items")->item(0)->
                getElementsByTagName('Request')->item(0);

        my $reptext =
                EPrints::Utils::tree_to_utf8($rep->getElementsByTagName('IsValid')->item(0));

        unless ($reptext eq 'True') 
        {
                $plugin->error('Invalid AWS Request');
                return undef;
        }
</pre>

The product found with the ItemLookup method is contained within an Item element within the Items element. Here we attempt to get that element and raise the error and return undef if we can't.
<pre>
        my $item =
                $dom->getElementsByTagName('Items')->item(0)->
                getElementsByTagName('Item')->item(0);

        unless (defined $item) 
        {
                $plugin->error('No Item element found');
                return undef;
        }
</pre>

Each item contains an ItemAttributes element which contains most of the metadata about an item.
<pre>
        my $attr = $item->getElementsByTagName('ItemAttributes')->item(0);
</pre>

For some specialised repositories it might make sense to import DVDs, computer games and electronic equipment, but we're just going to deal with books. The ProductGroup element within the ItemAttributes element tells you what sort of item we're dealing with. We're looking for the value 'Book'.
<pre>
        my $pg = EPrints::Utils::tree_to_utf8($attr->getElementsByTagName('ProductGroup')->item(0));

        unless ($pg eq 'Book') 
        {
                $plugin->error('Product is not a book.');
                return undef;
        }
</pre>

Here we set a few fields without consulting the imported data. We know this is a book, so we set the type. We assume that it has not been refereed. We also assume it has been published, because we can buy it. 
<pre>
        $output{type} = 'book';
        $output{refereed} = 'FALSE';
        $output{ispublished} = 'pub';
</pre>

We get and set the title.
<pre>
        my $title = $attr->getElementsByTagName('Title')->item(0);
        $output{title} = EPrints::Utils::tree_to_utf8($title);
</pre>

Here we set the official URL to the Amazon product page. We have to do a bit of extra work using the uri_unescape method from the URI::Escape package to convert URI escape codes into characters.
<pre>
        my $url = $item->getElementsByTagName('DetailPageURL')->item(0);
        $output{official_url} = uri_unescape(EPrints::Utils::tree_to_utf8($url));
</pre>

We can set the ISBN. Note that the ISBN is often the same as the ASIN.
<pre>
        my $isbn = $attr->getElementsByTagName('ISBN')->item(0);
        if (defined $isbn)
        {
                $output{isbn} = EPrints::Utils::tree_to_utf8($isbn);
        }
</pre>

We can set the number of pages.
<pre>
        my $pages = $attr->getElementsByTagName('NumberOfPages')->item(0);
        if (defined $pages)
        {
                $output{pages} = EPrints::Utils::tree_to_utf8($pages);
        }
</pre>

We can set the publisher.
<pre>
        my $publisher = $attr->getElementsByTagName('Publisher')->item(0);
        if (defined $publisher)
        {
                $output{publisher} = EPrints::Utils::tree_to_utf8($publisher);
        }
</pre>

We can set the publication date and finally return our output hash.
<pre>
        my $pubdate = $attr->getElementsByTagName('PublicationDate')->item(0);
        if (defined $pubdate)
        {
                $output{date} = EPrints::Utils::tree_to_utf8($pubdate);
        }

        return \%output;
</pre>

= Testing Your Plugin =
After restarting your webserver go to the Import Items screen from the Manage Deposits screen. If you can't find this, make sure you're logged in.

We'll start by collecting a few ASINS. Go to [http://www.amazon.co.uk Amazon] and pick a few books. The URL for each project page is in the form http://www.amazon.co.uk/Combination-of-title-an-author/dp/ASIN... Collect a few different ASINS.

Now we'll demonstrate importing from Amazon with a few sample ASINs.
Type this into the "Cut and Paste Records" box:
<pre>
0946719616
0297843877
</pre>

Select "AWS" from the Select import format drop down menu and click "Test Run + Import". You should end up at the Manage Deposits screen with the following message being displayed "Import completed: 2 item(s) imported.".