You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1183 lines
51 KiB
1183 lines
51 KiB
#!/usr/bin/perl
|
|
|
|
# Project: Web Reference Database (refbase) <http://www.refbase.net>
|
|
# Copyright: Matthias Steffens <mailto:refbase@extracts.de> and the file's
|
|
# original author(s).
|
|
#
|
|
# This code is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY. Please see the GNU General Public
|
|
# License for more details.
|
|
#
|
|
# File: ./contrib/command_line/refbase
|
|
# Repository: $HeadURL: file:///svn/p/refbase/code/branches/bleeding-edge/contrib/command_line/refbase $
|
|
# Author(s): Matthias Steffens <mailto:refbase@extracts.de>
|
|
#
|
|
# Created: 06-Jun-06, 18:00
|
|
# Modified: $Date: 2008-11-13 21:08:22 +0000 (Thu, 13 Nov 2008) $
|
|
# $Author: msteffens $
|
|
# $Revision: 1315 $
|
|
|
|
# REFBASE -- a refbase command line interface
|
|
|
|
# Purpose: Perl script that allows to search a refbase online database from the command line and retrieve results in various formats
|
|
# Usage: refbase [OPTIONS]
|
|
|
|
# Help: For help with the syntax type 'refbase -h'
|
|
# To view some usage examples type 'refbase -X'
|
|
# Further information is available at <http://cli.refbase.net/>
|
|
|
|
# Version: 1.2.1
|
|
|
|
# Requires: - a shell with Perl execution capabilities
|
|
# - the Perl CPAN modules LWP::UserAgent, HTTP::Request::Common, HTTP::Response, HTTP::Cookies and URI::URL
|
|
# - access to a refbase database (refbase-0.9.0 or greater, refbase-0.9.5 required for '-A|--append' and '-B|--update' mode)
|
|
|
|
# Limits: - Currently, this utility supports search & retrieve, but does not support update actions such as add, edit or delete.
|
|
# - This script is currently just an interface to 'show.php', which for example does not support arbitrary sort orders.
|
|
# - Specifying the record offset (using '-S|--start') as well as the number of records to be returned (using '-R|--rows') will
|
|
# only work for the formats 'html', 'rtf', 'pdf', 'latex', 'latex_bbl', 'markdown', 'ascii', 'atom', 'srw_dc' and 'srw_mods',
|
|
# since the other formats are designed to always export the entire result set. Note that for 'html', '--start' is adjusted to
|
|
# the next lower value that is an exact multiple of '--rows' (which ensures correct behaviour of the browse links).
|
|
# - The authentication mechanism is currently limited in that a given password will be transferred as parameter in the POST request
|
|
# - The '-A|--append' and '-B|--update' modes currently only work with formats 'bibtex', 'mods' and 'srw_mods'
|
|
|
|
# --------------------------------------------------------------------------------------------------------------
|
|
|
|
$version = "1.2.1";
|
|
|
|
# Configure variables:
|
|
|
|
# Specify the full URLs to any refbase servers that shall be queried:
|
|
# Notes: - the given hash keys will work as shortcuts, e.g. '--host=local' would query
|
|
# your local refbase installation; one hash key must be named 'default',
|
|
# all other keys can be freely chosen
|
|
# - by default, the server labeled with key 'default' will be queried
|
|
%hosts = (
|
|
'default' => 'http://beta.refbase.net/',
|
|
'local' => 'http://localhost/refs/',
|
|
'beta' => 'http://beta.refbase.net/',
|
|
'beta2' => 'http://refbase.textdriven.com/beta/',
|
|
'demo' => 'http://demo.refbase.net/',
|
|
'org' => 'http://www.refbase.org/'
|
|
);
|
|
|
|
# Specify the default values for all options that are not explicitly specified:
|
|
%params = (
|
|
# query options:
|
|
'author' => '', # -a|--author
|
|
'abstract' => '', # -b|--abstract
|
|
'cite_key' => '', # -c|--citekey => requires '--userid'
|
|
'date' => '', # -d|--date
|
|
'area' => '', # -e|--area
|
|
'thesis' => '', # -f|--thesis
|
|
'contribution_id' => '', # -i|--contribid
|
|
'abbrev_journal' => '', # -j|--journal
|
|
'keywords' => '', # -k|--keywords
|
|
'location' => '', # -l|--location
|
|
'ismarked' => '', # -m|--marked => requires '--userid'
|
|
'notes' => '', # -n|--notes
|
|
'publication' => '', # -p|--publication
|
|
'queryType' => 'and', # -q|--query => multiple options will by default be connected with 'AND'
|
|
'records' => '', # -r|--records
|
|
'selected' => '', # -s|--selected => requires '--userid'
|
|
'title' => '', # -t|--title
|
|
'userID' => '', # -u|--userid => the user ID of your account at the refbase database you're querying
|
|
'where' => '', # -w|--where
|
|
'type' => '', # -x|--type
|
|
'year' => '', # -y|--year
|
|
'serial' => '.+', # -z|--serial => the default '.+' causes all database records to be returned if only empty params are given (normally, you should leave this default as is)
|
|
|
|
# output options:
|
|
'appendFile' => '', # -A|--append => file to which search results will be appended
|
|
'updateRecords' => '0', # -B|--update => update existing records in '-A, --append' file; must be '0' (=no) or '1' (=yes)
|
|
'citeStyle' => '', # -C|--style => desired citation style, given name must match an entry within the database's MySQL table 'styles' (keep empty to use the database default)
|
|
'extractFile' => '', # -E|--extract => file from which citations will be extracted
|
|
'format' => 'ascii', # -F|--format => output format must be 'html', 'rtf', 'pdf', 'latex', 'latex_bbl', 'markdown', 'ascii', 'ads', 'bibtex', 'endnote', 'isi', 'ris', 'atom', 'mods', 'oai_dc', 'odf', 'srw_dc', 'srw_mods', 'word' or '' (the empty string '' will produce the default 'ascii' output style)
|
|
'showLinks' => '1', # -L|--showlinks => hide/display links column in HTML output; must be '0', '1', or '' (the empty string '' will produce the default output style, i.e. print any links)
|
|
'citeOrder' => 'author', # -O|--order => cite order must be 'author', 'year', 'type', 'type-year', 'creation-date' or '' (the empty string '' will produce the default 'author' sort order)
|
|
'showQuery' => '0', # -Q|--showquery => hide/display SQL query in ASCII output; must be '0', '1', or '' (the empty string '' will produce the default output style, i.e. not showing the SQL query)
|
|
'showRows' => '', # -R|--rows => desired number of search results (keep empty to use the database default)
|
|
'startRecord' => '1', # -S|--start => offset of the first search result, starting with one
|
|
'viewType' => 'web', # -V|--view => view type of HTML output; must be 'Web', 'Print', 'Mobile' or '' (the empty string '' will produce the default 'Web' output style)
|
|
|
|
# fixed parameters:
|
|
'submit' => 'Cite', # display type for HTML output; must be 'Display', 'Cite', 'Export', or '' (the empty string '' will produce the default 'columnar' output style); this param's value will get adopted below based on the chosen '--format'
|
|
'client' => "cli-refbase-" . $version # the client ID of this command line utility
|
|
|
|
);
|
|
|
|
# Specify the default login credentials for a refbase user account:
|
|
%loginParams = (
|
|
'loginEmail' => '', # -U|--user -> the login email address of an existing refbase user
|
|
'loginPassword' => '' # -P|--password -> the password for the given user account
|
|
);
|
|
|
|
# Specify the location of the cookie jar file:
|
|
# This file will be used to store & retrieve cookies
|
|
$cookieJarFile = "$ENV{HOME}/.lwpcookies.txt";
|
|
|
|
# For '-A|--append' mode, specify whether all records in the given file
|
|
# shall be sorted by cite key after any records have been appended/updated:
|
|
$sortAppendFileData = 1; # must be '1' (=yes) or '0' (=no)
|
|
|
|
# For '-A|--append' mode, specify whether all appended/updated
|
|
# records shall be reported as citations to STDOUT:
|
|
$reportResults = 1; # must be '1' (=yes) or '0' (=no)
|
|
|
|
# For '-A|--append' mode, specify whether a backup file shall be created
|
|
# before anything gets updated or appended to the given file:
|
|
$backupAppendFile = 1; # must be '1' (=yes) or '0' (=no)
|
|
|
|
# By default, the backup file uses the given file name with a tilde character
|
|
# added at the end of the file name. Adopt to your needs if necessary:
|
|
$backupFileNameSuffix = "~";
|
|
|
|
# For '-E|--extract' mode, specify regular expression patterns that match the
|
|
# citation IDs (i.e. refbase serial numbers or cite keys from the 'cite_key'
|
|
# field) in the given file:
|
|
|
|
# For each recognized file name extension[*], there must be a triplet of code
|
|
# (as shown below), each hash element contains an array with three elements:
|
|
# 1) a regex pattern that matches the cite IDs in the file (e.g. '\\\\cite\{(.+?)\}')
|
|
# (note that the regex patterns will be applied using the 'msg' mode modifiers)
|
|
# 2) the number of the sub-pattern that captures the cite IDs (e.g. '1')
|
|
# 3) a regex split pattern that matches the delimiter(s) used between multiple cite IDs (e.g. '[, ]+')
|
|
# [*]: The hash key must match the file's file name extension. If the given file is
|
|
# of unknown file type the 'default' pattern will be applied.
|
|
%citeIDPatterns = (
|
|
# - LaTeX, .tex file:
|
|
'tex' => [ '\\\\(?:(?:no)?cite|cite(?:n|num|online)|cite(?:al)?[tp]\*?|cite(?:author\*?|year(?:par)?|text|[tp]alias))(?:\[.*?\])*\{(.+?)\}', # 1), matches e.g.: '\cite{...}', '\nocite{...}', '\cite[...]{...}' and cite commands from the 'cite' & 'natbib' packages
|
|
'1', # 2)
|
|
'[, ]+' ], # 3)
|
|
|
|
# - LaTeX, .aux file:
|
|
'aux' => [ '\\\\(?:citation|bibcite)\{(.+?)\}', # matches '\citation{...}' or '\bibcite{...}'
|
|
'1',
|
|
'[, ]+' ],
|
|
|
|
# - LaTeX, .bib file:
|
|
'bib' => [ '^[\t ]*@[A-Za-z]+\{(.+?),', # matches '@Article{...,' etc
|
|
'1',
|
|
'[, ]+' ],
|
|
|
|
# - LaTeX, .bbl file:
|
|
'bbl' => [ '\\\\bibitem(?s:\[.*?\])*\{(.+?)\}', # matches '\bibitem{...}' or '\bibitem[...]{...}'
|
|
'1',
|
|
'[, ]+' ],
|
|
|
|
# - MODS, SRW_MODS, or Endnote XML file:
|
|
# TODO: add support for OAI_DC, SRW_DC and refbase OpenSearch Atom XML (<dc.identifier>citekey:...</dc.identifier>)
|
|
'xml' => [ '(?:<mods.+?ID="|<identifier.+?type="citekey">|<(?:label|accession-num)>\s*<style.*?>\s*)(.+?)(?:</identifier>|\s*</style>\s*</(?:label|accession-num)>|")', # matches MODS IDs like '<mods ID="..."', '<mods version="..." ID="..."' or '<identifier type="citekey">...</identifier>' etc -OR- Endnote XML IDs, e.g. '<label><style face="normal" font="default" size="100%">...</style></label>' etc
|
|
'1',
|
|
'[, ]+' ],
|
|
|
|
# - Endnote tagged text, .enw file:
|
|
'enw' => [ '^%F ([^\n\r]+)$', # matches '%F ...'
|
|
'1',
|
|
'[, ]+' ],
|
|
|
|
# - RIS, .ris file:
|
|
'ris' => [ '^ID - ([^\n\r]+)$', # matches 'ID - ...'
|
|
'1',
|
|
'[, ]+' ],
|
|
|
|
# - Generic, extracts IDs from lists of comma-separated refbase serial numbers (or cite keys) that are enclosed by braces:
|
|
'default' => [ '\{([^\n\r]+?)\}', # matches e.g.: '{123}', '{1,12,33}', '{Arrigo+Thomas2004}' or '{Arrigo+Thomas2004,Assur1958}'
|
|
'1',
|
|
'[,]+' ],
|
|
);
|
|
|
|
# --------------------------------------------------------------------------------
|
|
|
|
# NOTE: You shouldn't need to change anything below this line
|
|
|
|
# CPAN modules:
|
|
use LWP::UserAgent; # more info: <http://search.cpan.org/~gaas/libwww-perl-5.805/lib/LWP/UserAgent.pm>
|
|
use HTTP::Request::Common; # more info: <http://search.cpan.org/~gaas/libwww-perl-5.805/lib/HTTP/Request/Common.pm>
|
|
use HTTP::Response; # more info: <http://search.cpan.org/~gaas/libwww-perl-5.805/lib/HTTP/Response.pm>
|
|
use HTTP::Cookies; # more info: <http://search.cpan.org/~gaas/libwww-perl-5.805/lib/HTTP/Cookies.pm>
|
|
use URI::URL; # more info: <http://search.cpan.org/~gaas/URI-1.35/URI/URL.pm>
|
|
|
|
# standard modules:
|
|
use Time::Local;
|
|
|
|
# initialize variables:
|
|
$host = $hosts{'default'};
|
|
$optCt = 0;
|
|
$format = '';
|
|
@appendFileSerials = ();
|
|
$updateRecords = 0;
|
|
@extractFileSerials = ();
|
|
@extractFileKeys = ();
|
|
|
|
%months = (
|
|
'Jan' => 0,
|
|
'Feb' => 1,
|
|
'Mar' => 2,
|
|
'Apr' => 3,
|
|
'May' => 4,
|
|
'Jun' => 5,
|
|
'Jul' => 6,
|
|
'Aug' => 7,
|
|
'Sep' => 8,
|
|
'Oct' => 9,
|
|
'Nov' => 10,
|
|
'Dec' => 11
|
|
);
|
|
|
|
# Extract options:
|
|
# TODO: use Getopt::Long
|
|
|
|
# general options:
|
|
if (($ARGV[0] eq '--help') or ($ARGV[0] eq '-h') or ($ARGV[0] eq '')) { &usage (0); } # if the user asked for --help/-h or didn't provide any input, call the 'usage' subroutine
|
|
elsif (($ARGV[0] eq '--version') or ($ARGV[0] eq '-v')) { &version (0); } # show version information
|
|
elsif (($ARGV[0] eq '--examples') or ($ARGV[0] eq '-X')) { &examples (0); } # print some usage examples
|
|
|
|
else {
|
|
foreach (@ARGV) {
|
|
# extract query options:
|
|
if ($_ =~ /^(?:-a|--author)=(.+)$/) { $params{'author'} = $1; $optCt++; }
|
|
elsif ($_ =~ /^(?:-b|--abstract)=(.+)$/) { $params{'abstract'} = $1; $optCt++; }
|
|
elsif ($_ =~ /^(?:-c|--citekey)=(.+)$/) { $params{'cite_key'} = $1; $optCt++; }
|
|
elsif ($_ =~ /^(?:-d|--date)=(.+)$/) { $params{'date'} = $1; $optCt++; }
|
|
elsif ($_ =~ /^(?:-e|--area)=(.+)$/) { $params{'area'} = $1; $optCt++; }
|
|
elsif ($_ =~ /^(?:-f|--thesis)=(.+)$/) { $params{'thesis'} = $1; $optCt++; }
|
|
elsif ($_ =~ /^(?:-i|--contribid)=(.+)$/) { $params{'contribution_id'} = $1; $optCt++; }
|
|
elsif ($_ =~ /^(?:-j|--journal)=(.+)$/) { $params{'abbrev_journal'} = $1; $optCt++; }
|
|
elsif ($_ =~ /^(?:-k|--keywords)=(.+)$/) { $params{'keywords'} = $1; $optCt++; }
|
|
elsif ($_ =~ /^(?:-l|--location)=(.+)$/) { $params{'location'} = $1; $optCt++; }
|
|
elsif ($_ =~ /^(?:-m|--marked)=(.+)$/) { $params{'ismarked'} = $1; $optCt++; }
|
|
elsif ($_ =~ /^(?:-n|--notes)=(.+)$/) { $params{'notes'} = $1; $optCt++; }
|
|
elsif ($_ =~ /^(?:-p|--publication)=(.+)$/) { $params{'publication'} = $1; $optCt++; }
|
|
elsif ($_ =~ /^(?:-q|--query)=(.+)$/) { $params{'queryType'} = $1; }
|
|
elsif ($_ =~ /^(?:-r|--records)=(.+)$/) { $params{'records'} = $1; $optCt++; }
|
|
elsif ($_ =~ /^(?:-s|--selected)=(.+)$/) { $params{'selected'} = $1; $optCt++; }
|
|
elsif ($_ =~ /^(?:-t|--title)=(.+)$/) { $params{'title'} = $1; $optCt++; }
|
|
elsif ($_ =~ /^(?:-u|--userid)=(.+)$/) { $params{'userID'} = $1; $optCt++; }
|
|
elsif ($_ =~ /^(?:-w|--where)=(.+)$/) { $params{'where'} = $1; $optCt++; }
|
|
elsif ($_ =~ /^(?:-x|--type)=(.+)$/) { $params{'type'} = $1; $optCt++; }
|
|
elsif ($_ =~ /^(?:-y|--year)=(.+)$/) { $params{'year'} = $1; $optCt++; }
|
|
elsif ($_ =~ /^(?:-z|--serial)=(.+)$/) { $params{'serial'} = $1; }
|
|
|
|
# extract output options:
|
|
elsif ($_ =~ /^(?:-A|--append)=(.+)$/) { $params{'appendFile'} = $1; }
|
|
elsif ($_ =~ /^(?:-B|--update)=(.+)$/) { $params{'updateRecords'} = $1; }
|
|
elsif ($_ =~ /^(?:-C|--style)=(.+)$/) { $params{'citeStyle'} = $1; }
|
|
elsif ($_ =~ /^(?:-E|--extract)=(.+)$/) { $params{'extractFile'} = $1; }
|
|
elsif ($_ =~ /^(?:-F|--format)=(.+)$/) { $params{'format'} = $1; }
|
|
elsif ($_ =~ /^(?:-L|--showlinks)=(.+)$/) { $params{'showLinks'} = $1; }
|
|
elsif ($_ =~ /^(?:-O|--order)=(.+)$/) { $params{'citeOrder'} = $1; }
|
|
elsif ($_ =~ /^(?:-Q|--showquery)=(.+)$/) { $params{'showQuery'} = $1; }
|
|
elsif ($_ =~ /^(?:-R|--rows)=(.+)$/) { $params{'showRows'} = $1; }
|
|
elsif ($_ =~ /^(?:-S|--start)=(.+)$/) { $params{'startRecord'} = $1; }
|
|
elsif ($_ =~ /^(?:-V|--view)=(.+)$/) { $params{'viewType'} = $1; }
|
|
|
|
# extract server options:
|
|
elsif ($_ =~ /^(?:-H|--host)=(.+)$/) { $host = $1; }
|
|
elsif ($_ =~ /^(?:-P|--password)=(.+)$/) { $loginParams{'loginPassword'} = $1; }
|
|
elsif ($_ =~ /^(?:-U|--user)=(.+)$/) { $loginParams{'loginEmail'} = $1; }
|
|
}
|
|
}
|
|
|
|
# resolve any host shortcuts:
|
|
if (exists($hosts{$host})) {
|
|
$host = $hosts{$host};
|
|
}
|
|
elsif ($host !~ /^https?:\/\//i) {
|
|
$host = $hosts{'default'}; # can't resolve given host, reset back to default
|
|
}
|
|
|
|
# if any query option other than the 'serial' parameter was explicitly set,
|
|
# remove any default '.+' value from the 'serial' parameter:
|
|
# (otherwise an 'OR' query would always match everything)
|
|
if (($optCt > 0) && ($params{'serial'} eq '.+')) {
|
|
# if '--citekey', '--selected' or '--marked' is given, '--userid' must be specified as well; i.e.,
|
|
# in case of these user-specific params, we'll only empty the 'serial' param if a user ID is present
|
|
if (($params{'cite_key'} eq '') && ($params{'selected'} eq '') && ($params{'ismarked'} eq '')) {
|
|
$params{'serial'} = '';
|
|
}
|
|
elsif ($params{'userID'} ne '') { # at least one of '--citekey', '--selected' or '--marked' was given together with a '--userid'
|
|
$params{'serial'} = '';
|
|
}
|
|
}
|
|
|
|
# assign correct URL params based on the '-F|--format' option:
|
|
if (exists($params{'format'})) {
|
|
$format = $params{'format'};
|
|
if ($format =~ /^(rtf|pdf|latex|latex_bbl|markdown|ascii)$/i) {
|
|
$params{'submit'} = "Cite";
|
|
}
|
|
if ($format =~ /^(html|rtf|pdf|latex|latex_bbl|markdown|ascii)$/i) {
|
|
$format =~ s/^latex_bbl$/LaTeX .bbl/i;
|
|
$params{'citeType'} = $format;
|
|
}
|
|
elsif ($format =~ /^(ads|bibtex|endnote|isi|ris|atom|mods|oai_dc|odf|srw(_dc|_mods)?|word)$/i) {
|
|
$params{'submit'} = "Export";
|
|
$params{'exportType'} = "file";
|
|
|
|
if ($format =~ /^(ads|bibtex|endnote|isi|ris)$/i) {
|
|
$params{'exportFormat'} = $format;
|
|
}
|
|
elsif ($format =~ /^(atom|mods|oai_dc|odf|srw(_dc|_mods)?|word)$/i) {
|
|
$params{'exportFormat'} = $format . " xml";
|
|
}
|
|
}
|
|
else {
|
|
$params{'citeType'} = "ascii";
|
|
}
|
|
|
|
delete($params{'format'});
|
|
}
|
|
|
|
# '-E|--extract' functionality:
|
|
if ($params{'extractFile'} ne '') {
|
|
$extractFile = $params{'extractFile'};
|
|
# remove 'extractFile' parameter (which we don't need to send to the refbase server):
|
|
delete($params{'extractFile'});
|
|
|
|
# check if the given file exists and is readable:
|
|
if (!(-r $extractFile)) {
|
|
print "The '-E|--extract' option requires a name/path to an existing file.\n\n";
|
|
exit;
|
|
}
|
|
else { # the given '$extractFile' exists and is readable
|
|
$fileExtension = "default"; # triggers default regex patterns for extraction of cite IDs
|
|
# extract any file name extension:
|
|
if ($extractFile =~ /\.([^.\n]+)$/) {
|
|
if (exists($citeIDPatterns{$1})) { # if '$extractFile' has a recognized file name extension
|
|
$fileExtension = $1; # use file-specific regex patterns for extraction of cite IDs
|
|
}
|
|
}
|
|
|
|
$citeIDRegex = @{$citeIDPatterns{$fileExtension}}[0]; # get regex pattern that matches the cite IDs in '$extractFile'
|
|
$citeIDNum = @{$citeIDPatterns{$fileExtension}}[1]; # get number of the sub-pattern that captures the cite IDs
|
|
$citeIDSplit = @{$citeIDPatterns{$fileExtension}}[2]; # get regex split pattern that matches the delimiter(s) used between multiple cite IDs
|
|
|
|
# open '$extractFile' in read mode:
|
|
open(KEYS, "<", $extractFile) || die "Can't open file '" . $extractFile . "': $!\n";
|
|
|
|
# read the entire file at once:
|
|
undef $/;
|
|
$extractFileString = <KEYS>;
|
|
|
|
# close '$extractFile':
|
|
close(KEYS) || die "Can't close file: $!\n";
|
|
|
|
# extract all refbase serial numbers or cite keys that exist in '$extractFile':
|
|
while ($extractFileString =~ /$citeIDRegex/msg) {
|
|
$citeID = $$citeIDNum;
|
|
if ($citeID =~ /^(?:\d+|$citeIDSplit)+$/) { # '$citeID' is assumed to be a refbase serial number (or a list of multiple serials)
|
|
while ($citeID =~ /(\d+)/g) {
|
|
push(@extractFileSerials, $1);
|
|
}
|
|
}
|
|
else { # '$citeID' is assumed to be a cite key (or a list of multiple cite keys)
|
|
push(@extractFileKeys, split(/$citeIDSplit/, $citeID));
|
|
}
|
|
}
|
|
|
|
# remove any duplicate cite IDs:
|
|
@extractFileSerials = &uniquify(@extractFileSerials);
|
|
@extractFileKeys = &uniquify(@extractFileKeys);
|
|
|
|
# add query clause to restrict search results to records existing in '$extractFile':
|
|
if (@extractFileSerials || @extractFileKeys) {
|
|
if ($params{'where'} ne '') { $params{'where'} .= " AND "; }
|
|
$params{'where'} .= "(";
|
|
if (@extractFileSerials) {
|
|
$params{'where'} .= 'serial RLIKE "^(' . join('|', @extractFileSerials) . ')$"';
|
|
}
|
|
if (@extractFileKeys) {
|
|
if (@extractFileSerials) { $params{'where'} .= " OR "; }
|
|
$params{'where'} .= 'cite_key RLIKE "^(' . join('|', map {quotemeta(quotemeta($_))} @extractFileKeys) . ')$"'; # quotes each key before joining them
|
|
}
|
|
$params{'where'} .= ")";
|
|
}
|
|
else { # no citation IDs could be extracted from '$extractFile'
|
|
print "No citation IDs were found in file '" . $extractFile . "'!\n\n";
|
|
exit;
|
|
}
|
|
}
|
|
}
|
|
|
|
# '-A|--append' mode:
|
|
if ($params{'appendFile'} ne '') {
|
|
# '-A|--append' mode currently only works with formats 'bibtex', 'mods' and 'srw_mods',
|
|
# for all other formats (or if no format was specified), we'll return an error message:
|
|
if ($format !~ /^(bibtex|mods|srw(_mods)?)$/i) {
|
|
print "The '-A, --append' option requires '-F, --format' set to 'bibtex', 'mods' or 'srw_mods'.\n\n";
|
|
exit;
|
|
}
|
|
|
|
$appendFile = $params{'appendFile'};
|
|
# remove 'appendFile' parameter (which we don't need to send to the refbase server):
|
|
delete($params{'appendFile'});
|
|
|
|
$appendFileString = '';
|
|
|
|
# if the given '$appendFile' exists and is readable:
|
|
if (-r $appendFile) {
|
|
# open '$appendFile' in read mode:
|
|
open(FILEIN, "<", $appendFile) || die "Can't open file '" . $appendFile . "': $!\n";
|
|
|
|
# read the entire file at once:
|
|
undef $/;
|
|
$appendFileString = <FILEIN>;
|
|
|
|
# extract all refbase serial numbers (which already exist in '$appendFile') into an array:
|
|
while ($appendFileString =~ /(?<=show\.php\?record=)(\d+)/g) {
|
|
push(@appendFileSerials, $1);
|
|
}
|
|
|
|
# close '$appendFile':
|
|
close(FILEIN) || die "Can't close file: $!\n";
|
|
|
|
# backup existing contents of '$appendFile':
|
|
# (note that, currently, this will overwrite contents of any existing backup file
|
|
# with the same backup file name, even if nothing gets updated/appended further down)
|
|
if ($backupAppendFile) {
|
|
# create suitable backup file name:
|
|
if ($appendFile =~ /\.([^.\n]+)$/) { # if the file has a file name extension
|
|
($appendFileBackup = $appendFile) =~ s/\.([^.\n]+)$/$backupFileNameSuffix.$1/; # add backup suffix in front of the file name extension
|
|
}
|
|
else {
|
|
$appendFileBackup = $appendFile . $backupFileNameSuffix; # add backup suffix at end of file
|
|
}
|
|
|
|
# open backup file in write mode (creates new file if it doesn't exist):
|
|
open(FILEBACKUP, ">", $appendFileBackup) || die "Can't open file '" . $appendFileBackup . "': $!\n";
|
|
|
|
# write existing contents of '$appendFile' to backup file (replacing any previous contents):
|
|
print FILEBACKUP $appendFileString;
|
|
|
|
# close backup file:
|
|
close(FILEBACKUP) || die "Can't close file: $!\n";
|
|
}
|
|
|
|
# add query clause to exclude existing records from search results:
|
|
if (@appendFileSerials) {
|
|
# save current contents of the '-w|--where' option before messing with it further:
|
|
# (it will be needed in the 'append' and 'update' subroutines below)
|
|
$where = $params{'where'};
|
|
|
|
if ($params{'where'} ne '') { $params{'where'} .= " AND "; }
|
|
$params{'where'} .= 'serial NOT RLIKE "^(' . join('|', @appendFileSerials) . ')$"';
|
|
}
|
|
}
|
|
# if no '$appendFile' exists, it will be created by the 'append' subroutine below
|
|
}
|
|
|
|
# '-B|--update' functionality:
|
|
if ($params{'updateRecords'} == 1) {
|
|
$updateRecords = 1;
|
|
}
|
|
# remove 'updateRecords' parameter (which we don't need to send to the refbase server):
|
|
delete($params{'updateRecords'});
|
|
|
|
# for HTML output, we'll adjust the display type if the '-r|--records' option contains a single record serial number:
|
|
if (($params{'citeType'} eq 'html') && ($params{'records'} =~ /^[0-9]+$/)) {
|
|
$params{'submit'} = "Display";
|
|
}
|
|
|
|
# NOTE: I tried to put all query-related code into a dedicated function but for
|
|
# some reason that didn't work with redirects. ?:-/
|
|
|
|
# initialize new user agent:
|
|
# (uses LWP::UserAgent)
|
|
$userAgent = LWP::UserAgent->new;
|
|
|
|
# set user agent string:
|
|
$userAgent->agent("refbase/" . $version . " (http://cli.refbase.net/) ");
|
|
|
|
# allow redirection for 'POST' requests:
|
|
# (by default, the list of request names that '$userAgent->redirect_ok(...)'
|
|
# will allow redirection for is only set to ['GET', 'HEAD'], as per RFC 2616)
|
|
push @{ $userAgent->requests_redirectable }, 'POST';
|
|
|
|
# set cookie jar object:
|
|
# LWP will collect cookies and respond to cookie requests via its cookie jar, thus
|
|
# enabling the user agent to fetch a PHP session ID from the refbase login response
|
|
# and automatically resend it upon next request
|
|
$userAgent->cookie_jar({ file => $cookieJarFile, autosave => 1 });
|
|
|
|
# attempt to authenticate using the given login credentials:
|
|
if (($loginParams{'loginEmail'} ne '') && ($loginParams{'loginPassword'} ne '')) {
|
|
$loginSuccessful = &login(0); # call the 'login' subroutine
|
|
}
|
|
|
|
# construct URL:
|
|
# (uses URI::URL)
|
|
$script = "show.php";
|
|
$url = url($host . $script);
|
|
|
|
# build and send GET/POST request:
|
|
# (uses HTTP::Request::Common & HTTP::Response)
|
|
|
|
# build POST request using the 'application/x-www-form-urlencoded' content type:
|
|
$request = POST $url, \%params;
|
|
|
|
# or, build POST request using the 'multipart/form-data' content type:
|
|
# $request = POST $url, Content_Type => 'form-data', Content => \%params;
|
|
|
|
# alternatively, build GET request:
|
|
# (note that for large URLs, a GET request may cause an "414 Request-URI Too Large" error)
|
|
# $url->query_form(%params);
|
|
# $request = GET $url;
|
|
|
|
# print $request->as_string(); # DEBUG (dumps the GET/POST request)
|
|
|
|
# send the GET/POST request:
|
|
$response = $userAgent->request($request); # or use: $response = $userAgent->get($url);
|
|
|
|
# print returned results:
|
|
if ($response->is_error()) { # if the request fails, print error message to STDERR:
|
|
print STDERR $response->status_line, "\n";
|
|
}
|
|
|
|
elsif (defined($appendFile)) { # if an '$appendFile' was given print results to FILE:
|
|
if ($updateRecords == 1 && @appendFileSerials) {
|
|
&update(0); # update existing records in '$appendFile' with found results
|
|
}
|
|
|
|
$resultsString = $response->content();
|
|
|
|
# TODO: it would be better to use function 'splitRecs' to check whether there
|
|
# were any results returned for the given format
|
|
if ($resultsString =~ /^Nothing found!\n+/i) {
|
|
$resultsString = '';
|
|
}
|
|
|
|
if (($resultsString eq '') || (($format =~ /^(mods|srw(_mods)?)$/i) && ($resultsString !~ /<mods[ >]/i))) {
|
|
print "There are no records that need to be added to file '" . $appendFile . "'.\n\n";
|
|
}
|
|
else { # if the query returned results which aren't yet in '$appendFile':
|
|
&append(0); # append search results to file
|
|
}
|
|
}
|
|
|
|
else { # print results to STDOUT:
|
|
binmode STDOUT;
|
|
print $response->content();
|
|
}
|
|
|
|
# --------------------------------------------------------------------------------
|
|
|
|
# Login with login credentials given in '%loginParams':
|
|
sub login
|
|
{
|
|
local ($status) = @_;
|
|
|
|
# construct URL:
|
|
# (uses URI::URL)
|
|
$loginScript = "user_login.php";
|
|
$loginURL = url($host . $loginScript);
|
|
|
|
# send POST request:
|
|
# (uses HTTP::Request::Common & HTTP::Response)
|
|
$loginRequest = POST $loginURL, \%loginParams;
|
|
$loginResponse = $userAgent->request($loginRequest);
|
|
|
|
if ($loginResponse->is_error()) {
|
|
print STDERR $loginResponse->status_line, "\n";
|
|
exit $status;
|
|
}
|
|
else {
|
|
$location = $loginResponse->header('Location');
|
|
|
|
# upon successful login, refbase will redirect to 'index.php'
|
|
if ($location =~ /index.php/) {
|
|
return 1; # login successful
|
|
}
|
|
else {
|
|
return 0; # login NOT successful
|
|
}
|
|
}
|
|
}
|
|
|
|
# --------------------------------------------------------------------------------
|
|
|
|
# Append search results to file:
|
|
sub append
|
|
{
|
|
local ($status) = @_;
|
|
local @newAppendFileData = ();
|
|
$whereAppend = "";
|
|
|
|
# TODO: In order to enable sorting of all records for MODS + SRW, we should remove the
|
|
# XML file header & footer from the results (and store them in a variable). Then
|
|
# merge existing & new records, split, sort, join again, and finally put the XML
|
|
# header & footer back.
|
|
if ($format =~ /^(mods|srw(_mods)?)$/i) {
|
|
# if the '$appendFile' contains MODS XML data:
|
|
if (($format =~ /^mods$/i) && ($appendFileString =~ /<modsCollection/i)) {
|
|
# remove XML file header and '<modsCollection>' opening tag from results:
|
|
$resultsString =~ s/^<\?xml.+?<modsCollection[^>\n]*?>\n//ims;
|
|
# remove '</modsCollection>' closing tag from existing records in '$appendFile':
|
|
$appendFileString =~ s/^<\/modsCollection>//ims;
|
|
}
|
|
# if the '$appendFile' contains SRW_MODS XML data:
|
|
elsif (($format =~ /^srw(_mods)?$/i) && ($appendFileString =~ /<srw:records/i)) {
|
|
# remove XML file header and opening tags from results:
|
|
$resultsString =~ s/^<\?xml.+?<srw:records[^>\n]*?>\n//ims;
|
|
# remove closing tags from existing records in '$appendFile':
|
|
$appendFileString =~ s/^\s*<\/srw:records>.*?<\/srw:searchRetrieveResponse>//ims;
|
|
|
|
# TODO: update values in '<srw:numberOfRecords>' and '<srw:recordPosition>'
|
|
}
|
|
}
|
|
|
|
# append search results to the '$appendFile' contents:
|
|
$newAppendFileString = $appendFileString;
|
|
if (!($sortAppendFileData) && ($format =~ /^bibtex$/i) && ($appendFileString ne '') && ($resultsString ne '')) {
|
|
$newAppendFileString .= "\n";
|
|
}
|
|
$newAppendFileString .= $resultsString;
|
|
|
|
# sort all records by cite key:
|
|
if ($sortAppendFileData) {
|
|
# remove any newlines from end of string:
|
|
$newAppendFileString =~ s/[\n\r]+$//;
|
|
|
|
# split '$appendFile' contents & search results on (format-specific) record delimiters:
|
|
@newAppendFileData = &splitRecs($newAppendFileString);
|
|
|
|
# sort array of records by cite key:
|
|
@newAppendFileData = &sortRecs(@newAppendFileData);
|
|
|
|
# merge again records into a string:
|
|
if ($format =~ /^bibtex$/i) {
|
|
$recDelim = "\n\n";
|
|
}
|
|
else {
|
|
$recDelim = "\n";
|
|
}
|
|
$newAppendFileString = join($recDelim, @newAppendFileData) . "\n";
|
|
}
|
|
|
|
# open '$appendFile' in write mode (creates new file if it doesn't exist):
|
|
open(FILEADD, ">", $appendFile) || die "Can't open file '" . $appendFile . "': $!\n";
|
|
|
|
# write existing contents & new results back to '$appendFile':
|
|
print FILEADD $newAppendFileString;
|
|
|
|
# close '$appendFile':
|
|
close(FILEADD) || die "Can't close file: $!\n";
|
|
|
|
# to give some feedback, we output all appended records as citations to STDOUT:
|
|
# TODO: move into a dedicated function if possible (compare with 'update' subroutine)
|
|
if ($reportResults) {
|
|
$params{'submit'} = "Cite";
|
|
$params{'citeType'} = "ascii";
|
|
$params{'showRows'} = "99999";
|
|
$params{'headerMsg'} = "Added records:";
|
|
|
|
if ($where ne '') { $whereAppend = $where . " AND "; }
|
|
|
|
if (($appendFileString ne '') && (@appendFileSerials)) { # '$appendFile' contains some records
|
|
# add query clause to exclude existing records from search results:
|
|
$whereAppend .= 'serial NOT RLIKE "^(' . join('|', @appendFileSerials) . ')$"';
|
|
}
|
|
else { # '$appendFile' didn't exist or was empty
|
|
# extract all refbase serial numbers from '$resultsString' into an array:
|
|
while ($resultsString =~ /(?<=show\.php\?record=)(\d+)/g) {
|
|
push(@appendFileSerials, $1);
|
|
}
|
|
# add query clause to display all records from the current search results:
|
|
$whereAppend .= 'serial RLIKE "^(' . join('|', @appendFileSerials) . ')$"';
|
|
}
|
|
|
|
$params{'where'} = $whereAppend;
|
|
|
|
# construct URL:
|
|
# (uses URI::URL)
|
|
$appendFeedbackURL = url($host . $script);
|
|
|
|
# send POST request:
|
|
# (uses HTTP::Request::Common & HTTP::Response)
|
|
$appendFeedbackRequest = POST $appendFeedbackURL, \%params;
|
|
$appendFeedbackResponse = $userAgent->request($appendFeedbackRequest);
|
|
|
|
print $appendFeedbackResponse->content();
|
|
}
|
|
}
|
|
|
|
# --------------------------------------------------------------------------------
|
|
|
|
# Update existing records (given in '$appendFile') with found results:
|
|
sub update
|
|
{
|
|
local ($status) = @_;
|
|
local @appendFileData = ();
|
|
local @newAppendFileData = ();
|
|
@updatedSerials = ();
|
|
$whereUpdate = "";
|
|
|
|
# add query clause to restrict search results to records existing in '$appendFile':
|
|
if ($where ne '') { $whereUpdate = $where . " AND "; }
|
|
$whereUpdate .= 'serial RLIKE "^(' . join('|', @appendFileSerials) . ')$"';
|
|
$params{'where'} = $whereUpdate;
|
|
|
|
# fetch all records that match the given query AND which exist in '$appendFile':
|
|
|
|
# construct URL:
|
|
# (uses URI::URL)
|
|
$updateURL = url($host . $script);
|
|
|
|
# send POST request:
|
|
# (uses HTTP::Request::Common & HTTP::Response)
|
|
$updateRequest = POST $updateURL, \%params;
|
|
$updateResponse = $userAgent->request($updateRequest);
|
|
|
|
$updateResultsString = $updateResponse->content();
|
|
|
|
# if the '$appendFile' contains MODS XML data:
|
|
if (($format =~ /^mods$/i) && ($appendFileString =~ /<modsCollection/i)) {
|
|
# remove XML file header and '<modsCollection>' opening tag from results:
|
|
$updateResultsString =~ s/^<\?xml.+?<modsCollection[^>\n]*?>\n//ims;
|
|
# remove '</modsCollection>' closing tag from results:
|
|
$updateResultsString =~ s/^<\/modsCollection>//ims;
|
|
}
|
|
# if the '$appendFile' contains SRW_MODS XML data:
|
|
elsif (($format =~ /^srw(_mods)?$/i) && ($appendFileString =~ /<srw:records/i)) {
|
|
# remove XML file header and opening tags from results:
|
|
$updateResultsString =~ s/^<\?xml.+?<srw:records[^>\n]*?>\n//ims;
|
|
# remove closing tags from results:
|
|
$updateResultsString =~ s/^\s*<\/srw:records>.*?<\/srw:searchRetrieveResponse>//ims;
|
|
|
|
# TODO: update values in '<srw:numberOfRecords>' and '<srw:recordPosition>'
|
|
}
|
|
|
|
# split search results on (format-specific) record delimiters:
|
|
@updateResultsData = &splitRecs($updateResultsString);
|
|
|
|
# extract refbase serial number & UNIX time stamp from returned records:
|
|
%updateResultsRecords = &parseRecs(@updateResultsData);
|
|
|
|
# split '$appendFile' contents on (format-specific) record delimiters:
|
|
@appendFileData = &splitRecs($appendFileString);
|
|
|
|
# replace existing records with new ones:
|
|
foreach $record (@appendFileData) { # for each of the records existing in '$appendFile'
|
|
# NOTE: instead of looping over all existing records, it would probably be more effective
|
|
# to loop over each of the newly fetched (updated) records instead, and directly replace
|
|
# all records in '$appendFileString' that have a matching serial number, but I couldn't
|
|
# get this working correctly...
|
|
|
|
# if this record contains a refbase serial number & UNIX time stamp:
|
|
if ($record =~ /(?<=show\.php\?record=)(\d+)[^\d\n]+(\d{2}) ([[:alpha:]]{3}) (\d{4}) (\d{2}):(\d{2}):(\d{2})/i) {
|
|
$serial = $1;
|
|
|
|
if (exists($updateResultsRecords{$serial})) { # if one of the newly fetched (updated) records has an identical serial number
|
|
# extract time stamp from existing record:
|
|
$monthday = $2;
|
|
$month = $months{$3}; # 0 == January
|
|
$year = $4 - 1900; # by default, Perl counts years from 1900
|
|
$hour = $5;
|
|
$min = $6;
|
|
$sec = $7;
|
|
|
|
# convert existing record's time stamp to epoch seconds:
|
|
$modifiedDateExisting = timelocal($sec, $min, $hour, $monthday, $month, $year); # uses Time::Local
|
|
|
|
# extract source data & time stamp from the matching updated record:
|
|
$updatedRecord = @{$updateResultsRecords{$serial}}[0];
|
|
$modifiedDateUpdated = @{$updateResultsRecords{$serial}}[1];
|
|
|
|
if ($modifiedDateUpdated > $modifiedDateExisting) { # if the updated record has a more recent time stamp
|
|
# replace existing record with updated record:
|
|
# (variables '$recStart' and '$recEnd' get defined in subroutine 'splitRecs')
|
|
$record =~ s/^$recStart.+?exported from refbase.+?show\.php\?record=$serial.+?$recEnd$/$updatedRecord/ims;
|
|
|
|
push(@updatedSerials, $serial);
|
|
}
|
|
}
|
|
}
|
|
|
|
push(@newAppendFileData, $record);
|
|
}
|
|
|
|
if (! @updatedSerials) {
|
|
print "There are no records that need to be updated in file '" . $appendFile . "'.\n\n";
|
|
}
|
|
else {
|
|
# update existing records in variable '$appendFileString':
|
|
if ($format =~ /^bibtex$/i) {
|
|
$recDelim = "\n\n";
|
|
}
|
|
else {
|
|
$recDelim = "\n";
|
|
}
|
|
$appendFileString = join($recDelim, @newAppendFileData);
|
|
|
|
# if the initial query did not return results which aren't yet in '$appendFile':
|
|
# (i.e. if the 'append' subroutine won't get triggered)
|
|
if (($resultsString eq '') || (($format =~ /^(mods|srw(_mods)?)$/i) && ($resultsString !~ /<mods[ >]/i))) {
|
|
# open '$appendFile' in write mode:
|
|
open(FILEOUT, ">", $appendFile) || die "Can't open file '" . $appendFile . "': $!\n";
|
|
|
|
# write back updated file:
|
|
print FILEOUT $appendFileString;
|
|
|
|
# close '$appendFile':
|
|
close(FILEOUT) || die "Can't close file: $!\n";
|
|
}
|
|
# otherwise, the 'append' subroutine will write contents of '$appendFileString' back to '$appendFile'
|
|
|
|
# to give some feedback, we output all updated records as citations to STDOUT:
|
|
# TODO: move into a dedicated function if possible (compare with 'append' subroutine)
|
|
if ($reportResults) {
|
|
$params{'submit'} = "Cite";
|
|
$params{'citeType'} = "ascii";
|
|
$params{'showRows'} = "99999";
|
|
$params{'headerMsg'} = "Updated records:";
|
|
$whereUpdate = "";
|
|
|
|
# add query clause to restrict search results to updated records:
|
|
if ($where ne '') { $whereUpdate = $where . " AND "; }
|
|
$whereUpdate .= 'serial RLIKE "^(' . join('|', @updatedSerials) . ')$"';
|
|
$params{'where'} = $whereUpdate;
|
|
|
|
# construct URL:
|
|
# (uses URI::URL)
|
|
$updateFeedbackURL = url($host . $script);
|
|
|
|
# send POST request:
|
|
# (uses HTTP::Request::Common & HTTP::Response)
|
|
$updateFeedbackRequest = POST $updateFeedbackURL, \%params;
|
|
$updateFeedbackResponse = $userAgent->request($updateFeedbackRequest);
|
|
|
|
print $updateFeedbackResponse->content();
|
|
}
|
|
}
|
|
}
|
|
|
|
# --------------------------------------------------------------------------------
|
|
|
|
# Split '$sourceText' on format-specific record delimiters:
|
|
# (note that, currently, only formats 'bibtex', 'mods' and 'srw_mods' are supported)
|
|
sub splitRecs
|
|
{
|
|
local ($sourceText) = @_;
|
|
local (@records) = ();
|
|
|
|
if ($format =~ /^(bibtex|mods|srw(_mods)?)$/i) {
|
|
# define format-specific strings that open/close a record:
|
|
# (note that '...' must be used here instead of "...", see Friedl regex book, 1st ed., p.300+)
|
|
if ($format =~ /^bibtex$/i) {
|
|
$recStart = '@';
|
|
$recEnd = '\}';
|
|
}
|
|
elsif ($format =~ /^mods$/i) {
|
|
$recStart = '\s*<mods[ >]';
|
|
$recEnd = 'mods>';
|
|
}
|
|
elsif ($format =~ /^srw(_mods)?$/i) {
|
|
$recStart = '\s*<srw:record[ >]';
|
|
$recEnd = 'srw:record>';
|
|
}
|
|
|
|
@records = split(/(?<=$recEnd)\s*\n(?=$recStart)/m, $sourceText);
|
|
}
|
|
|
|
return @records;
|
|
}
|
|
|
|
# --------------------------------------------------------------------------------
|
|
|
|
# Extract records containing a refbase serial number & UNIX time stamp from '@records':
|
|
# Returns a hash of records where each hash element
|
|
# - is keyed by the record's serial number
|
|
# - contains a reference to an unnamed array which holds two array elements:
|
|
# - the record's source data
|
|
# - the modified date/time stamp converted to epoch seconds
|
|
sub parseRecs
|
|
{
|
|
local (@records) = @_;
|
|
%refbaseRecords = ();
|
|
|
|
foreach $record (@records) {
|
|
# extract refbase serial number & UNIX time stamp from this record:
|
|
if ($record =~ /(?<=show\.php\?record=)(\d+)[^\d\n]+(\d{2}) ([[:alpha:]]{3}) (\d{4}) (\d{2}):(\d{2}):(\d{2})/i) {
|
|
$serial = $1;
|
|
$monthday = $2;
|
|
$month = $months{$3}; # 0 == January
|
|
$year = $4 - 1900; # by default, Perl counts years from 1900
|
|
$hour = $5;
|
|
$min = $6;
|
|
$sec = $7;
|
|
|
|
# add modified date to array (after converting to epoch seconds):
|
|
$modifiedDate = timelocal($sec, $min, $hour, $monthday, $month, $year); # uses Time::Local
|
|
|
|
$record =~ s/\s+$//; # remove any trailing whitespace
|
|
|
|
# note that if '@records' contains several records with the same refbase
|
|
# serial number, only the last one will be included in '%refbaseRecords'
|
|
# (and thus only the last one will get updated by the 'update' subroutine)
|
|
push(@{$refbaseRecords{$serial}}, $record);
|
|
push(@{$refbaseRecords{$serial}}, $modifiedDate);
|
|
# NOTE: by storing a reference to an array we can add multiple values per hash key (see Perl Cookbook 5.7)
|
|
}
|
|
}
|
|
|
|
return %refbaseRecords;
|
|
}
|
|
|
|
# --------------------------------------------------------------------------------
|
|
|
|
# Sort array of records by cite key:
|
|
# (note that, currently, only formats 'bibtex', 'endnote', 'ris' 'mods' and 'srw_mods' are supported)
|
|
sub sortRecs
|
|
{
|
|
local (@records) = @_;
|
|
%keyedRecordData = ();
|
|
@sortedRecordData = ();
|
|
$i = 1;
|
|
|
|
$fileExtension = "default"; # triggers default regex patterns for extraction of cite IDs
|
|
# use file-specific regex patterns for extraction of cite IDs:
|
|
if ($format =~ /^(bibtex|endnote|ris|mods|srw(_mods)?)$/i) {
|
|
if ($format =~ /^bibtex$/i) {
|
|
$fileExtension = "bib";
|
|
}
|
|
elsif ($format =~ /^endnote$/i) {
|
|
$fileExtension = "enw";
|
|
}
|
|
elsif ($format =~ /^ris$/i) {
|
|
$fileExtension = "ris";
|
|
}
|
|
elsif ($format =~ /^(mods|srw(_mods)?)$/i) {
|
|
$fileExtension = "xml";
|
|
}
|
|
}
|
|
|
|
$citeIDRegex = @{$citeIDPatterns{$fileExtension}}[0]; # get regex pattern that matches the cite IDs in the records
|
|
$citeIDNum = @{$citeIDPatterns{$fileExtension}}[1]; # get number of the sub-pattern that captures the cite IDs
|
|
|
|
foreach $record (@records) {
|
|
# extract cite IDs and use them as hash keys:
|
|
# (we always append an incrementing number to ensure unique keys; the number
|
|
# is padded with leading zeros in order to allow for correct string sorting)
|
|
if ($record =~ /$citeIDRegex/msg) {
|
|
$citeID = $$citeIDNum . sprintf("-%06d", $i++);
|
|
}
|
|
else { # no cite ID found, so we just use an incrementing number as hash key
|
|
$citeID = sprintf("%06d", $i++);
|
|
}
|
|
$keyedRecordData{$citeID} = $record;
|
|
}
|
|
|
|
@sortedKeys = sort keys %keyedRecordData;
|
|
|
|
foreach $key (@sortedKeys) {
|
|
push(@sortedRecordData, $keyedRecordData{$key});
|
|
}
|
|
|
|
return @sortedRecordData;
|
|
}
|
|
|
|
# --------------------------------------------------------------------------------
|
|
|
|
# Remove any duplicate items from '@array':
|
|
sub uniquify
|
|
{
|
|
local (@array) = @_;
|
|
local (%unique) = ();
|
|
|
|
foreach $item (@array) {
|
|
$unique{$item}++;
|
|
}
|
|
|
|
return (sort keys %unique);
|
|
}
|
|
|
|
# --------------------------------------------------------------------------------
|
|
|
|
# Print usage and exit:
|
|
sub usage
|
|
{
|
|
local ($status) = @_;
|
|
|
|
print "\nrefbase command line client, v" . $version . " by Matthias Steffens, http://cli.refbase.net/\n\n"
|
|
|
|
. "Usage: refbase [OPTIONS]\n\n"
|
|
|
|
. "Notes: - At least one query option must be given and unrecognized options will be ignored.\n"
|
|
. " - If multiple options are given, they will by default be connected with 'AND'. Use\n"
|
|
. " '--query=or' to connect multiple options with 'OR'.\n"
|
|
. " - Options syntax: [OPTION]=[VALUE], e.g. '-a=steffens' or '--author=\"steffens, m\"'.\n"
|
|
. " - Returns up to '--rows' number of records beginning with '--start'. If all given\n"
|
|
. " query options are empty, all database records will be returned.\n"
|
|
. " - Note that '--records' assumes a list of full record serials separated by non-digit\n"
|
|
. " characters while '--serial' allows for partial matches.\n"
|
|
. " - For each option, default values can be specified at the top of the script.\n"
|
|
. " Current defaults are given in parentheses.\n\n"
|
|
|
|
. "General Options: -h, --help - display this help text\n"
|
|
. " -v, --version - display version information\n"
|
|
. " -X, --examples - display usage examples\n\n"
|
|
|
|
. "Query Options: -a, --author - search author field ('" . $params{'author'} . "')\n"
|
|
. " -b, --abstract - search abstract field ('" . $params{'abstract'} . "')\n"
|
|
. " -c, --citekey - search cite_key field, requires '-u, --userid' ('" . $params{'cite_key'} . "')\n"
|
|
. " -d, --date - search by creation date ('" . $params{'date'} . "')\n"
|
|
. " -e, --area - search area field ('" . $params{'area'} . "')\n"
|
|
. " -f, --thesis - search thesis field ('" . $params{'thesis'} . "')\n"
|
|
. " -i, --contribid - search contribution_id field ('" . $params{'contribution_id'} . "')\n"
|
|
. " -j, --journal - search abbrev_journal field ('" . $params{'abbrev_journal'} . "')\n"
|
|
. " -k, --keywords - search keywords field ('" . $params{'keywords'} . "')\n"
|
|
. " -l, --location - search location field ('" . $params{'location'} . "')\n"
|
|
. " -m, --marked - search marked field, requires '-u, --userid' ('" . $params{'ismarked'} . "')\n"
|
|
. " -n, --notes - search notes field ('" . $params{'notes'} . "')\n"
|
|
. " -p, --publication - search publication field ('" . $params{'publication'} . "')\n"
|
|
. " -q, --query - query type, possible values: and, or ('" . $params{'queryType'} . "')\n"
|
|
. " -r, --records - search serial field ('" . $params{'records'} . "')\n"
|
|
. " -s, --selected - search selected field, requires '-u, --userid' ('" . $params{'selected'} . "')\n"
|
|
. " -t, --title - search title field ('" . $params{'title'} . "')\n"
|
|
. " -u, --userid - join with user-specific data from user ID ('" . $params{'userID'} . "')\n"
|
|
. " -w, --where - search by using a raw sql where clause ('" . $params{'where'} . "')\n"
|
|
. " -x, --type - search type field ('" . $params{'type'} . "')\n"
|
|
. " -y, --year - search year field ('" . $params{'year'} . "')\n"
|
|
. " -z, --serial - search serial field (partial matches) ('" . $params{'serial'} . "')\n\n"
|
|
|
|
. "Output Options: -A, --append - file to which returned records are appended ('" . $params{'appendFile'} . "')\n"
|
|
. " requires '-F, --format': bibtex, mods, srw_mods\n"
|
|
. " -B, --update - update existing records in '-A, --append' file ('" . $params{'updateRecords'} . "')\n"
|
|
. " possible values: 0, 1\n"
|
|
. " -C, --style - citation style ('" . $params{'citeStyle'} . "')\n"
|
|
. " -E, --extract - file from which citation IDs are extracted ('" . $params{'extractFile'} . "')\n"
|
|
. " supported file types: " . join(', ', sort keys(%citeIDPatterns)) . "\n"
|
|
. " -F, --format - output format ('" . $params{'format'} . "')\n"
|
|
. " possible values: html, rtf, pdf, latex, latex_bbl, markdown, ascii,\n"
|
|
. " ads, bibtex, endnote, isi, ris, atom, mods, oai_dc,\n"
|
|
. " odf, srw_dc, srw_mods, word\n"
|
|
. " -L, --showlinks - hide/display links column in html output ('" . $params{'showLinks'} . "')\n"
|
|
. " possible values: 0, 1\n"
|
|
. " -O, --order - sort order of returned records ('" . $params{'citeOrder'} . "')\n"
|
|
. " possible values: author, year, type, type-year, creation-date\n"
|
|
. " -Q, --showquery - hide/display SQL query in ASCII output ('" . $params{'showQuery'} . "')\n"
|
|
. " possible values: 0, 1\n"
|
|
. " -R, --rows - number of records to be returned ('" . $params{'showRows'} . "')\n"
|
|
. " -S, --start - number of first record to be returned ('" . $params{'startRecord'} . "')\n"
|
|
. " -V, --view - view type of html output ('" . $params{'viewType'} . "')\n"
|
|
. " possible values: web, print, mobile\n\n"
|
|
|
|
. "Server Options: -H, --host - URL of the refbase database ('" . $host . "')\n"
|
|
. " defined shortcuts: " . join(', ', sort keys(%hosts)) . "\n"
|
|
. " -P, --password - password for given '-U, --user' account";
|
|
|
|
if ($loginParams{'loginPassword'} ne '') {
|
|
print "\n (a default pwd has been defined)\n";
|
|
}
|
|
else {
|
|
print " ('')\n";
|
|
}
|
|
|
|
print " -U, --user - login email address of an existing refbase user\n"
|
|
. " ('" . $loginParams{'loginEmail'} . "')\n\n";
|
|
|
|
exit $status;
|
|
}
|
|
|
|
# --------------------------------------------------------------------------------
|
|
|
|
# Print version number and exit:
|
|
sub version
|
|
{
|
|
local ($status) = @_;
|
|
print "\nrefbase command line client, version " . $version
|
|
. "\ncheck for updates at http://cli.refbase.net/\n\n";
|
|
exit $status;
|
|
}
|
|
|
|
# --------------------------------------------------------------------------------
|
|
|
|
# Print examples and exit:
|
|
sub examples
|
|
{
|
|
local ($status) = @_;
|
|
print <<'END_EXAMPLES';
|
|
|
|
--------------------------------------------------------------------------------
|
|
REFBASE USAGE EXAMPLES:
|
|
--------------------------------------------------------------------------------
|
|
|
|
1) Find all records where the author field contains 'mock' AND the year field
|
|
contains '2005':
|
|
|
|
refbase -a=mock -y=2005
|
|
|
|
--------------------------------------------------------------------------------
|
|
|
|
2) Find all records where the author field contains 'mock' OR the title field
|
|
contains 'photo', and display 10 records starting with the 21st record in the
|
|
result set:
|
|
|
|
refbase -a=mock -t=photo -q=or -R=10 -S=21
|
|
|
|
--------------------------------------------------------------------------------
|
|
|
|
3) Export records with serial numbers '1', '12' and '34' to Endnote format and
|
|
save them to a file named 'export.enw':
|
|
|
|
refbase -r=1,12,34 -F=endnote > export.enw
|
|
|
|
--------------------------------------------------------------------------------
|
|
|
|
4) Return up to 50 records that were selected by a user with a user ID '2' in
|
|
RTF format using citation style "Ann Glaciol" and sorting them first by
|
|
record type, then by year, and save results to a file named 'citations.rtf':
|
|
|
|
refbase -s=yes -u=2 -R=50 -F=rtf -C="Ann Glaciol" -O=type-year > citations.rtf
|
|
|
|
--------------------------------------------------------------------------------
|
|
|
|
5) Find all records which were modified today by a user named "admin" and where
|
|
the location field contains 'msteffens' (note the use of the '-w' option to
|
|
specify a custom WHERE clause):
|
|
|
|
refbase -w='modified_date = CURDATE() AND modified_by RLIKE "admin"' -l=msteffens
|
|
|
|
--------------------------------------------------------------------------------
|
|
|
|
6) Find all records where the cite_key field (of a user with a user ID '2')
|
|
contains 'steffens', and append records in MODS XML format to file 'mods.xml'
|
|
if they don't yet exist in that file:
|
|
|
|
refbase -u=2 -c=steffens -F=mods -A=mods.xml
|
|
|
|
--------------------------------------------------------------------------------
|
|
|
|
7) Find all records where the contribution_id field contains 'AWI' and where
|
|
the keywords field contains 'seaweeds', and append records in BibTeX format
|
|
to file 'paper.bib' if they don't yet exist in that file. In case found
|
|
records already exist in file 'paper.bib', update them if their modification
|
|
date is more recent:
|
|
|
|
refbase -i=AWI -k=seaweeds -F=bibtex -A=paper.bib -B=1
|
|
|
|
--------------------------------------------------------------------------------
|
|
|
|
8) Extract all citation IDs from file 'paper.aux', and append matching records
|
|
(for a user with a user ID '2') in BibTeX format to file 'paper.bib' if they
|
|
don't yet exist in that file. In case found records already exist in file
|
|
'paper.bib', update them if their modification date is more recent:
|
|
|
|
refbase -u=2 -E=paper.aux -F=bibtex -A=paper.bib -B=1
|
|
|
|
--------------------------------------------------------------------------------
|
|
|
|
9) Extract all citation IDs from file 'bibtex.bbl', and save matching records
|
|
(for a user with a user ID '2') in LaTeX bibliography (.bbl) format to file
|
|
'refbase.bbl' using the "APA" citation style (the .bbl file generated by
|
|
refbase can be used as a replacement of the BibTeX-generated .bbl file):
|
|
|
|
refbase -u=2 -E=bibtex.bbl -F=latex_bbl -C=APA > refbase.bbl
|
|
|
|
--------------------------------------------------------------------------------
|
|
|
|
END_EXAMPLES
|
|
exit $status;
|
|
}
|
|
|
|
__END__
|