.*?
') + self.add_html_result(num + ' ' + html + '
', limit) class KISSExternalCollectionResultsParser(ExternalCollectionResultsParser): """Parser for Kiss.""" num_results_regex = re.compile(r'
([0-9]+?) records matched') def __init__(self, host="www-lib.kek.jp", path="cgi-bin/"): super(KISSExternalCollectionResultsParser, self).__init__(host, path) - def parse(self, of=None, req=None): + def parse(self, of=None, req=None, limit=CFG_EXTERNAL_COLLECTION_MAXRESULTS): """Parse buffer to extract records.""" self.buffer_decode_from('Shift_JIS') elements = self.buffer.split("
- ")
if len(elements) <= 1:
return
for element in elements[1:]:
if len(self.results) >= CFG_EXTERNAL_COLLECTION_MAXRESULTS:
return
end_index = element.find('
') + self.add_html_result(element + '
', limit) class KISSBooksExternalCollectionResultsParser(ExternalCollectionResultsParser): """Parser for Kiss books.""" line = re.compile(r'
" else: info_line_match = self.info_line.match(data) if info_line_match: info = info_line_match.group(1) html += info + '
' - self.add_html_result(html) + self.add_html_result(html, limit) class GoogleExternalCollectionResultsParser(ExternalCollectionResultsParser): """Parser for Google""" num_results_regex = re.compile(r'of about ([0-9,]+?)') def __init__(self, host = "www.google.com", path=""): super(GoogleExternalCollectionResultsParser, self).__init__(host, path) - def parse(self, of=None, req=None): + def parse(self, of=None, req=None, limit=CFG_EXTERNAL_COLLECTION_MAXRESULTS): """Parse buffer to extract records.""" elements = self.buffer.split("
")
if len(elements) <= 1:
return
for element in elements[1:]:
end_index = element.find('')
if end_index != -1:
element = element[:end_index + 8]
- self.add_html_result(element)
+ self.add_html_result(element, limit)
class GoogleScholarExternalCollectionResultsParser(GoogleExternalCollectionResultsParser):
"""Parser for Google Scholar."""
def __init__(self, host = "scholar.google.com", path=""):
super(GoogleScholarExternalCollectionResultsParser, self).__init__(host, path)
- def parse(self, of=None, req=None):
+ def parse(self, of=None, req=None, limit=CFG_EXTERNAL_COLLECTION_MAXRESULTS):
"""Parse buffer to extract records."""
elements = self.buffer.split("
')
result_decode = re.compile('[ ]*(.*?)[ ]*.*?
[ ]*(.*?)[ ]*
[ ]*(.*?)[ ]*.*?
[ ]*(.*)[ ]*') cleaning = re.compile('(![]()
||||)')
def __init__(self, host='www.scirus.com', path='srsapp/'):
super(SCIRUSExternalCollectionResultsParser, self).__init__(host, path)
- def parse(self, of=None, req=None):
+ def parse(self, of=None, req=None, limit=CFG_EXTERNAL_COLLECTION_MAXRESULTS):
"""Parse buffer to extract records."""
data = self.buffer.replace('\n', ' ')
for element in self.result_separator.finditer(data):
data = element.group(1)
parsed_line = self.result_decode.match(data)
if parsed_line is not None:
link = parsed_line.group(1)
date = parsed_line.group(2)
comments = parsed_line.group(3)
similar = parsed_line.group(4)
html = "%(link)s - %(date)s
%(comments)s
%(similar)s
" % {'link' : link, 'date' : date, 'comments' : comments, 'similar' : similar} else: html = self.cleaning.sub("", data) + '
' - self.add_html_result(html) + self.add_html_result(html, limit) class CiteSeerExternalCollectionResultsParser(ExternalCollectionResultsParser): """Parser for CiteSeer.""" num_results_regex = re.compile(r'
(?:More than |)([0-9]+)(?: documents found.| results)') result_separator = re.compile(r'.*?', re.DOTALL) def __init__(self, host='', path=''): super(CiteSeerExternalCollectionResultsParser, self).__init__(host, path) - def parse(self, of=None, req=None): + def parse(self, of=None, req=None, limit=CFG_EXTERNAL_COLLECTION_MAXRESULTS): """Parse buffer to extract records.""" for element in self.result_separator.finditer(self.buffer): - self.add_html_result(element.group() + '
') + self.add_html_result(element.group() + '
', limit) class CDSInvenioHTMLExternalCollectionResultsParser(ExternalCollectionResultsParser): """HTML brief (hb) Parser for Invenio""" def __init__(self, params): self.buffer = "" self.results = [] self.clean() for (name, value) in params.iteritems(): setattr(self, name, value) self.num_results_regex = re.compile(self.num_results_regex_str) self.nbrecs_regex = re.compile(self.nbrecs_regex_str, re.IGNORECASE) - def parse(self, of=None, req=None): + def parse(self, of=None, req=None, limit=CFG_EXTERNAL_COLLECTION_MAXRESULTS): """Parse buffer to extract records.""" # the patterns : # level_a : select only the results level_a_pat = re.compile(r']*basket[^>]*?>.*?(.*?)
.*?', re.DOTALL + re.MULTILINE + re.IGNORECASE)
# level_b : purge html from the basket input fields
level_b_pat = re.compile(r']*?/>', re.DOTALL + re.MULTILINE + re.IGNORECASE)
# level_c : separate the results from one another
level_c_pat = re.compile(r'(.*? )', re.DOTALL + re.MULTILINE + re.IGNORECASE)
# the long way :
#level_a_res = level_a_pat.search(self.buffer)
#level_ab_res = level_a_res.group(1)
#level_b_res = level_b_pat.sub('', level_ab_res)
#level_c_res = level_c_pat.finditer(level_b_res)
# the short way :
try:
results = level_c_pat.finditer(level_b_pat.sub('', level_a_pat.search(self.buffer).group(1)))
for result in results:
# each result is placed in each own table since it already has its rows and cells defined
- self.add_html_result('' + result.group(1) + '
')
+ self.add_html_result('' + result.group(1) + '
', limit)
except AttributeError:
# in case there were no results found an Attribute error is raised
pass
class CDSInvenioXMLExternalCollectionResultsParser(ExternalCollectionResultsParser):
"""XML (xm) parser for Invenio"""
def __init__(self, params):
self.buffer = ""
self.results = []
self.clean()
for (name, value) in params.iteritems():
setattr(self, name, value)
self.num_results_regex = re.compile(self.num_results_regex_str)
self.nbrecs_regex = re.compile(self.nbrecs_regex_str, re.IGNORECASE)
- def parse(self, of='hb', req=None):
+ def parse(self, of='hb', req=None, limit=CFG_EXTERNAL_COLLECTION_MAXRESULTS):
"""Parse buffer to extract records. Format the records using the selected output format."""
(recids, records) = self.parse_and_extract_records(of, req)
if req and cgi.parse_qs(req.args).has_key('jrec'):
counter = int(cgi.parse_qs(req.args)['jrec'][0]) - 1
else:
counter = 0
for recid in recids:
counter += 1
if of == 'hb':
html = """
%(counter)s.
%(record)s .*?)', re.DOTALL + re.MULTILINE + re.IGNORECASE)
# extract the recid
recid_pat = re.compile(r'([0-9]+?) ', re.DOTALL + re.MULTILINE + re.IGNORECASE)
if not of:
of='hb'
try:
results = record_pat.finditer(self.buffer)
records = {}
recids = []
for result in results:
xml_record = result.group(1)
recid = recid_pat.search(xml_record).group(1)
recids.append(recid)
if of != 'xm':
records[recid] = format_record(None, of, xml_record=xml_record)
elif of == 'xm':
records[recid] = xml_record
return (recids,records)
except AttributeError:
# in case there were no results found an Attribute error is raised
return ([], {})
diff --git a/modules/websearch/lib/websearch_external_collections_searcher.py b/modules/websearch/lib/websearch_external_collections_searcher.py
index 30e6df527..87d93f07d 100644
--- a/modules/websearch/lib/websearch_external_collections_searcher.py
+++ b/modules/websearch/lib/websearch_external_collections_searcher.py
@@ -1,604 +1,620 @@
# -*- coding: utf-8 -*-
## This file is part of CDS Invenio.
## Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008 CERN.
##
## CDS Invenio is free software; you can redistribute it and/or
## modify it under the terms of the GNU General Public License as
## published by the Free Software Foundation; either version 2 of the
## License, or (at your option) any later version.
##
## CDS Invenio is distributed in the hope that it will be useful, but
## WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
## General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with CDS Invenio; if not, write to the Free Software Foundation, Inc.,
## 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
"""CDS Invenio external search Engines."""
__revision__ = "$Id$"
import sys
import urllib
import cgi
import types
from invenio.config import CFG_SITE_LANG
from invenio.websearch_external_collections_config import CFG_EXTERNAL_COLLECTIONS, CFG_EXTERNAL_COLLECTION_MAXRESULTS
from invenio.websearch_external_collections_parser import CDSIndicoCollectionResutsParser, \
GoogleExternalCollectionResultsParser, \
KISSExternalCollectionResultsParser, GoogleScholarExternalCollectionResultsParser, \
GoogleBooksExternalCollectionResultsParser, KISSBooksExternalCollectionResultsParser, \
SPIRESExternalCollectionResultsParser, SCIRUSExternalCollectionResultsParser, \
CiteSeerExternalCollectionResultsParser
def format_basic(basic):
"""Format a basic query"""
if basic[3] == "w":
return basic[1]
else:
return '"' + basic[1] + '"'
def only_field(basic_search_units, fieldname):
"""Check if in the basic search units, there is only on field representated."""
for search_unit in basic_search_units:
if search_unit[2] != fieldname:
return False
return True
class ExternalSearchEngine(object):
"""Global class for interfaces to external search engines."""
lang_translator = None
def __init__(self, configuration):
self.search_url = ""
self.combiner = " "
self.name = None
self.parser_params = None
self.parser = None
self.fetch_format = ""
self.selected_by_default = False
for (name, value) in configuration.iteritems():
setattr(self, name, value)
if self.parser_params:
setattr(self, 'parser', self.parser_params['parser'](self.parser_params))
if 'fetch_format' in self.parser_params.keys():
self.fetch_format = self.parser_params['fetch_format']
def build_units(self, basic_search_units):
""" Build the research units for basic_search_units provided"""
units = []
for search_unit in basic_search_units:
unit = self.build_search_unit_unit(search_unit)
if unit is not None:
units.append(unit)
return units
def build_search_unit_unit(self, basic):
"""Build a search string from a search unit. This is the base
version that just keep keywords with "+". """
if basic[0] == "+":
return basic[1]
return None
- def build_search_url(self, basic_search_units, req_args=None, lang=CFG_SITE_LANG):
+ def build_search_url(self, basic_search_units, req_args=None, lang=CFG_SITE_LANG, limit=CFG_EXTERNAL_COLLECTION_MAXRESULTS):
"""Build a URL for a specific set of search_units."""
units = self.build_units(basic_search_units)
if len(units) == 0:
return None
request = self.combine_units(units)
url_request = urllib.quote(request)
return self.search_url + url_request
def combine_units(self, units):
"""Combine the units to make a boolean AND query."""
return self.combiner.join(units)
def __repr__(self):
return 'ec:' + self.name
class SortedFieldsSearchEngine(ExternalSearchEngine):
"""Class for search engines that used separate query box for fields."""
def __init__(self, configuration):
self.fields = []
self.fields_content = {}
self.search_url = ""
self.converter = {}
super(SortedFieldsSearchEngine, self).__init__(configuration)
- def build_search_url(self, basic_search_units, req_args=None, lang=CFG_SITE_LANG):
+ def build_search_url(self, basic_search_units, req_args=None, lang=CFG_SITE_LANG, limit=CFG_EXTERNAL_COLLECTION_MAXRESULTS):
"""Build a search URL. Reuse the search pattern found in req only with Invenio-based search engines"""
self.clear_fields()
self.fill_fields(basic_search_units)
def clear_fields(self):
"""Clear fields to be able to build a new URL."""
self.fields_content = {}
for field_name in self.fields:
self.fields_content[field_name] = []
self.fields_content["default"] = []
def fill_fields(self, basic_search_units):
"""Fill fields with the apropriate research terms."""
for search_unit in basic_search_units:
self.add_search_unit(search_unit)
def add_search_unit(self, search_unit):
"""Add a search unit to fields to search."""
if search_unit[0] == "-":
return
search = format_basic(search_unit)
field_name = search_unit[2]
if field_name in self.fields:
self.fields_content[field_name].append(search)
else:
self.fields_content["default"].append(search)
# CERN
class CDSIndicoSearchEngine(ExternalSearchEngine):
"""Global class for CDS Search Engines."""
index_translator = {'title' : 'title', 'author': 'speaker', 'fulltext': 'fulltext'}
lang_translator = {
'ca': 'ca', 'cs': 'cs', 'de': 'de', 'el': 'el', 'en': 'en', 'es': 'es',
'fr': 'fr', 'it': 'it', 'ja': 'ja', 'no': 'no', 'pl': 'pl', 'pt': 'pt',
'ru': 'ru', 'sk': 'sk', 'sv': 'sv', 'uk': 'uk', 'default' : 'en'}
def __init__(self, configuration):
super(CDSIndicoSearchEngine, self).__init__(configuration)
self.base_url = 'http://indicosearch.cern.ch/'
self.search_url = 'http://indicosearchpublic.cern.ch/search?cc=INDICOPUBLIC&p='
self.parser = CDSIndicoCollectionResutsParser()
def build_search_unit_unit(self, basic):
"""Build a search string from a search unit.
This will also translate index name using the index_translator
dictionary."""
operator = basic[0]
pattern = basic[1]
index = basic[2]
search_type = basic[3]
if self.index_translator.has_key(index):
index = self.index_translator[index]
else:
index = None
if index:
return operator + index + ':"' + pattern + '"'
else:
if search_type == 'w':
return operator + pattern
else:
return operator + '"' + pattern + '"'
- def build_search_url(self, basic_search_units, req_args=None, lang=CFG_SITE_LANG):
+ def build_search_url(self, basic_search_units, req_args=None, lang=CFG_SITE_LANG, limit=CFG_EXTERNAL_COLLECTION_MAXRESULTS):
"""Build an URL for a specific set of search_units."""
url = super(CDSIndicoSearchEngine, self).build_search_url(basic_search_units, None, lang)
if not url:
return None
if self.lang_translator.has_key(lang):
dest_lang = self.lang_translator[lang]
else:
dest_lang = self.lang_translator['default']
return url + '&ln=' + dest_lang + '&rg=' + str(CFG_EXTERNAL_COLLECTION_MAXRESULTS)
class CERNEDMSSearchEngine(SortedFieldsSearchEngine):
"""CERN EDMS"""
def __init__(self, configuration):
super(CERNEDMSSearchEngine, self).__init__(configuration)
self.base_url = "http://edms.cern.ch/cedar/plsql/fullsearch.doc_search"
self.search_url = "http://edms.cern.ch/cedar/plsql/fullsearch.doc_search?p_search_type=ADVANCED&"
self.search_url_simple = "http://edms.cern.ch/cedar/plsql/fullsearch.doc_search?p_search_type=BASE&p_free_text="
self.fields = ["author", "keyword", "abstract", "title", "reportnumber"]
- def build_search_url(self, basic_search_units, req_args=None, lang=CFG_SITE_LANG):
+ def build_search_url(self, basic_search_units, req_args=None, lang=CFG_SITE_LANG, limit=CFG_EXTERNAL_COLLECTION_MAXRESULTS):
"""Build an URL for CERN EDMS."""
super(CERNEDMSSearchEngine, self).build_search_url(basic_search_units)
if len(self.fields_content["default"]) > 0:
free_text = self.bind_fields(["author", "keyword", "abstract", "title", "reportnumber", "default"])
return self.search_url_simple + free_text
else:
authors = self.bind_fields(["author"])
title = self.bind_fields(["title", "abstract", "keyword"])
reportnumber = self.bind_fields(["reportnumber"])
url_parts = []
if authors != '':
url_parts.append('p_author=' + authors)
if title != "":
url_parts.append('p_title=' + title)
if reportnumber != "":
url_parts.append('p_document_id=' + reportnumber)
if len(url_parts) == 0:
return None
return self.search_url + "&".join(url_parts)
def bind_fields(self, fieldname_list):
"""Combine some fields together."""
result = []
for key in fieldname_list:
content = self.fields_content[key]
if len(content) > 0:
result.append(" ".join(content))
return urllib.quote(" ".join(result))
class CERNAgendaSearchEngine(ExternalSearchEngine):
"""CERN Agenda"""
def __init__(self, configuration):
super(CERNAgendaSearchEngine, self).__init__(configuration)
self.base_url = "http://agenda.cern.ch"
self.search_url_author = "http://agenda.cern.ch/search.php?field=speaker&search=Search&keywords="
self.search_url_title = "http://agenda.cern.ch/search.php?field=title&search=Search&keywords="
- def build_search_url(self, basic_search_units, req_args=None, lang=CFG_SITE_LANG):
+ def build_search_url(self, basic_search_units, req_args=None, lang=CFG_SITE_LANG, limit=CFG_EXTERNAL_COLLECTION_MAXRESULTS):
"""Build an url for searching on CERN Agenda. This will only work if there is only author
or title tags."""
if only_field(basic_search_units, "author"):
self.search_url = self.search_url_author
elif only_field(basic_search_units, "title"):
self.search_url = self.search_url_title
else:
return None
return super(CERNAgendaSearchEngine, self).build_search_url(basic_search_units)
# Google
class GoogleSearchEngine(ExternalSearchEngine):
"""Search engine class for Google """
def __init__(self, configuration):
super(GoogleSearchEngine, self).__init__(configuration)
self.base_url = "http://www.google.com"
self.search_url = "http://www.google.com/search?q="
self.parser = GoogleExternalCollectionResultsParser()
def build_search_unit_unit(self, search_unit):
"""Build a part of the google query."""
return self.build_search_unit_unit_google(search_unit, "")
def build_search_unit_unit_google(self, search_unit, author_tag):
"""Parse a unit and return it in a google query form."""
sign = search_unit[0].replace("+", "")
if search_unit[2] == "author":
if search_unit[1].find(",") >= 0 and search_unit[3] != "p":
(lastname, firstname) = search_unit[1].split(",", 1)
return sign + author_tag + '"%s %s" OR ' % (lastname, firstname) + \
sign + author_tag + '"%s %s"' % (firstname, lastname)
else:
return sign + author_tag + search_unit[1]
if search_unit[3] == "w":
return sign + search_unit[1]
else:
return sign + '"' + search_unit[1] + '"'
class GoogleBooksSearchEngine(GoogleSearchEngine):
"""Interface for searching on Google Books."""
def __init__(self, configuration):
super(GoogleBooksSearchEngine, self).__init__(configuration)
self.base_url = "http://books.google.com"
self.search_url = "http://books.google.com/books?q="
self.parser = GoogleBooksExternalCollectionResultsParser()
class GoogleScholarSearchEngine(GoogleSearchEngine):
"""Interface for searching on Google Scholar."""
def __init__(self, configuration):
super(GoogleScholarSearchEngine, self).__init__(configuration)
self.base_url = 'http://scholar.google.com'
self.search_url = 'http://scholar.google.com/scholar?q='
self.parser = GoogleScholarExternalCollectionResultsParser()
def build_search_unit_unit(self, search_unit):
"""Build a unit for Google Scholar. Is different from Google one's
because there is an author tag for authors."""
return self.build_search_unit_unit_google(search_unit, "author:")
# Kiss
class KissSearchEngine(SortedFieldsSearchEngine):
"""Search interface for KEK Information Service System.
Not to be used directly but with Kiss*SearchEngine. """
def __init__(self, configuration):
super(KissSearchEngine, self).__init__(configuration)
self.converter = { "author": "AU=", "year": "YR=",
"title": "TI=", "reportnumber": "RP=" }
self.fields = self.converter.keys()
self.parser = KISSExternalCollectionResultsParser()
- def build_search_url(self, basic_search_units, req_args=None, lang=CFG_SITE_LANG):
+ def build_search_url(self, basic_search_units, req_args=None, lang=CFG_SITE_LANG, limit=CFG_EXTERNAL_COLLECTION_MAXRESULTS):
"""Build an URL for a search."""
super(KissSearchEngine, self).build_search_url(basic_search_units)
url_parts = []
for key in self.fields:
if len(self.fields_content[key]) > 0:
field_request = " and ".join(self.fields_content[key])
url_part = self.converter[key] + urllib.quote(field_request)
url_parts.append(url_part)
if len(url_parts) == 0:
return None
return self.search_url + "&".join(url_parts)
def add_search_unit(self, search_unit):
"""Add a search unit to fields to search."""
if search_unit[0] == "+":
search = search_unit[1]
field_name = search_unit[2]
if field_name == "author":
self.add_author(search, search_unit[3])
elif field_name == "year" or field_name == "reportnumber":
self.fields_content[field_name].append(search)
else:
self.fields_content["title"].append("'" + search + "'")
def add_author(self, author_name, unit_type):
"""Handle an author unit. """
if author_name.find(",") >= 0 and unit_type != "p":
(lastname, firstname) = author_name.split(",", 1)
if firstname:
self.fields_content["author"].append("'%s, %c'" % (lastname, firstname[0]))
else:
self.fields_content["author"].append("'%s'" % (lastname))
else:
self.fields_content["author"].append("'" + author_name + "'")
class KissForPreprintsSearchEngine(KissSearchEngine):
"""Interface for seaching on Kiss for Preprints"""
def __init__(self, configuration):
super(KissForPreprintsSearchEngine, self).__init__(configuration)
self.base_url = "http://www-lib.kek.jp/KISS/kiss_prepri.html"
self.search_url = "http://www-lib.kek.jp/cgi-bin/kiss_prepri.v8?"
class KissForBooksAndJournalsSearchEngine(KissSearchEngine):
"""Interface for seaching on Kiss for Books and Journals"""
def __init__(self, configuration):
super(KissForBooksAndJournalsSearchEngine, self).__init__(configuration)
self.base_url = "http://www-lib.kek.jp/KISS/kiss_book.html"
self.search_url = "http://www-lib.kek.jp/cgi-bin/kiss_book.v8?DSP=1&"
self.parser = KISSBooksExternalCollectionResultsParser()
# Scirus
class ScirusSearchEngine(ExternalSearchEngine):
"""Interface for the Scirus search engine."""
def __init__(self, configuration):
super(ScirusSearchEngine, self).__init__(configuration)
self.base_url = "http://www.scirus.com/srsapp/"
self.search_url = "http://www.scirus.com/srsapp/search?q="
self.parser = SCIRUSExternalCollectionResultsParser()
def build_search_unit_unit(self, search_unit):
"""Build a unit for a search unit"""
sign = search_unit[0].replace("+", "")
search = self.normalize_unit(search_unit)
if search_unit[2] == "author":
return sign + "au:" + search
if search_unit[2] == "title":
return sign + "ti:" + search
if search_unit[2] == "keyword":
return sign + "keyword:" + search
if search_unit[3] == "w":
return sign + search
def normalize_unit(self, search_unit):
""" Add double quote if needed. """
if search_unit[3] == "a":
return '"' + search_unit[1] + '"'
else:
return search_unit[1]
# Spires
class SPIRESSearchEngine(ExternalSearchEngine):
"""Interface for the Spires Search engine."""
def __init__(self, configuration):
super(SPIRESSearchEngine, self).__init__(configuration)
self.base_url = "http://www.slac.stanford.edu/spires/hep/"
self.search_url = "http://www.slac.stanford.edu/spires/find/hep/?rawcmd=find+"
self.combiner = " and "
self.parser = SPIRESExternalCollectionResultsParser()
def build_search_unit_unit(self, basic):
"""Build a search string from a search unit. This is the base
version that just keep keywords with "+". """
word = format_basic(basic)
if basic[0] == "-":
sign = "not "
else:
sign = ""
if basic[2] == "author":
return sign + "a " + word
if basic[2] == "title":
return sign + "t " + word
if basic[2] == "keyword":
return sign + "k " + word
if basic[2] == "reportnumber":
return sign + "r " + word
if basic[0] == "+":
return "a " + word + " or t " + word + " or k " + word
else:
return "not a " + word + " and not t " + word + " and not k " + word
class SPIRESBooksSearchEngine(SPIRESSearchEngine):
"""SPIRES Books"""
def __init__(self, configuration):
super(SPIRESBooksSearchEngine, self).__init__(configuration)
self.base_url = "http://www.slac.stanford.edu/library/catalog/"
self.search_url = "http://www.slac.stanford.edu/spires/find/books/?rawcmd=find+"
self.parser = None
class SPIRESJournalsSearchEngine(SPIRESSearchEngine):
"""SPIRES Journals"""
def __init__(self, configuration):
super(SPIRESJournalsSearchEngine, self).__init__(configuration)
self.base_url = "http://www.slac.stanford.edu/spires/find/tserials/"
self.search_url = "http://www.slac.stanford.edu/spires/find/tserials/?rawcmd=find+"
# Misc
class AmazonSearchEngine(ExternalSearchEngine):
"""Interface for searching books on Amazon."""
def __init__(self, configuration):
super(AmazonSearchEngine, self).__init__(configuration)
self.base_url = "http://www.amazon.com"
self.search_url_general = "http://www.amazon.com/exec/obidos/external-search/?tag=cern&keyword="
self.search_url_author = "http://www.amazon.com/exec/obidos/external-search/?tag=cern&field-author="
- def build_search_url(self, basic_search_units, req_args=None, lang=CFG_SITE_LANG):
+ def build_search_url(self, basic_search_units, req_args=None, lang=CFG_SITE_LANG, limit=CFG_EXTERNAL_COLLECTION_MAXRESULTS):
"""Build an URL for Amazon"""
if only_field(basic_search_units, "author"):
self.search_url = self.search_url_author
else:
self.search_url = self.search_url_general
return super(AmazonSearchEngine, self).build_search_url(basic_search_units)
class CiteseerSearchEngine(ExternalSearchEngine):
"""Interface for searching on CiteSeer."""
def __init__(self, configuration):
super(CiteseerSearchEngine, self).__init__(configuration)
self.base_url = "http://citeseer.ist.psu.edu"
self.search_url = "http://citeseer.ist.psu.edu/cs?q="
self.parser = CiteSeerExternalCollectionResultsParser()
class INSPECSearchEngine(ExternalSearchEngine):
"""INSPEC"""
def __init__(self, configuration):
super(INSPECSearchEngine, self).__init__(configuration)
self.base_url = "http://www.datastarweb.com/cern/"
self.search_url = "http://www.datastarweb.com/cern/?dblabel=inzz&query="
self.combiner = " AND "
def build_search_unit_unit(self, basic):
"""Build a search string from a search unit. This is the base
version that just keep keywords with "+". """
word = format_basic(basic)
if basic[0] == "-":
return None
if basic[2] == "author":
return word + ".au."
if basic[2] == "title":
return word + ".ti."
if basic[2] == "abstract":
return word + ".ab."
if basic[2] == "year":
return word + ".yr."
return word + ".ti. OR " + word + ".ab."
class NEBISSearchEngine(ExternalSearchEngine):
"""NEBIS"""
def __init__(self, configuration):
super(NEBISSearchEngine, self).__init__(configuration)
self.base_url = "http://opac.nebis.ch"
self.search_url_general = "http://opac.nebis.ch/F/?func=find-b&find_code=WRD&REQUEST="
self.search_url_author = "http://opac.nebis.ch/F/?func=find-b&find_code=WAU&REQUEST="
self.search_url_title = "http://opac.nebis.ch/F/?func=find-b&find_code=WTI&REQUEST="
- def build_search_url(self, basic_search_units, req_args=None, lang=CFG_SITE_LANG):
+ def build_search_url(self, basic_search_units, req_args=None, lang=CFG_SITE_LANG, limit=CFG_EXTERNAL_COLLECTION_MAXRESULTS):
"""Build an URL for NEBIS"""
if only_field(basic_search_units, "author"):
self.search_url = self.search_url_author
elif only_field(basic_search_units, "title"):
self.search_url = self.search_url_title
else:
self.search_url = self.search_url_general
return super(NEBISSearchEngine, self).build_search_url(basic_search_units)
# Invenio based
class CDSInvenioSearchEngine(ExternalSearchEngine):
"""Generic search engine class for Invenio based sites"""
def __init__(self, configuration):
super(CDSInvenioSearchEngine, self).__init__(configuration)
- def build_search_url(self, basic_search_units, req_args=None, lang=CFG_SITE_LANG):
+ def build_search_url(self, basic_search_units, req_args=None, lang=CFG_SITE_LANG, limit=CFG_EXTERNAL_COLLECTION_MAXRESULTS):
"""Build a URL for an Invenio based site"""
if req_args:
search_url_params = ""
if type(req_args) is list:
# req_args is by definition a string. It is a list
# only when we manually pass it as a list of recids.
conjunction = " or "
search_url_recids = conjunction.join(['recid:%s'] * len(req_args))
params = tuple(req_args)
search_url_recids %= params
req_args = "p=" + search_url_recids
req_args_dict = cgi.parse_qs(req_args)
if req_args_dict.has_key('p'):
search_url_params += urllib.quote(req_args_dict['p'][0])
if req_args_dict.has_key('jrec'):
search_url_params += '&jrec=' + req_args_dict['jrec'][0]
if req_args_dict.has_key('rg'):
search_url_params += '&rg=' + req_args_dict['rg'][0]
+ else:
+ search_url_params += '&rg=' + str(limit)
+ if req_args_dict.has_key('d1d'):
+ search_url_params += '&d1d=' + req_args_dict['d1d'][0]
+ if req_args_dict.has_key('d1m'):
+ search_url_params += '&d1m=' + req_args_dict['d1m'][0]
+ if req_args_dict.has_key('d1y'):
+ search_url_params += '&d1y=' + req_args_dict['d1y'][0]
+ if req_args_dict.has_key('d2d'):
+ search_url_params += '&d2d=' + req_args_dict['d2d'][0]
+ if req_args_dict.has_key('d2m'):
+ search_url_params += '&d2m=' + req_args_dict['d2m'][0]
+ if req_args_dict.has_key('d2y'):
+ search_url_params += '&d2y=' + req_args_dict['d2y'][0]
+ if req_args_dict.has_key('ap'):
+ search_url_params += '&ap=' + req_args_dict['ap'][0]
search_url_params += '&of=' + self.fetch_format
return self.search_url + search_url_params
else:
units = self.build_units(basic_search_units)
if len(units) == 0:
return None
request = self.combine_units(units)
url_request = urllib.quote(request)
- return self.search_url + url_request + '&of=' + self.fetch_format
+ return self.search_url + url_request + '&rg=' + str(limit) + '&of=' + self.fetch_format
def build_search_unit_unit(self, basic):
"""Build a search string from a search unit. Reconstructs original user query"""
# TO DO: correct & improve the print out
# adding the semicolon in case a specific field is chosen
if basic[2] != "": basic[2] = basic[2] + ":"
# adding the single quotes in case a multi word values is searched for
if basic[3] == "a": basic[1] = "'" + basic[1] + "'"
return basic[0] + " " + basic[2] + basic[1]
def build_record_urls(self, recids):
"""Given a list of records this function returns a dictionary with
recid:external_url key:value pairs"""
if type(recids) is not list:
recids = [recids]
recids_urls = []
for recid in recids:
recids_urls.append((recid, self.record_url + recid))
return tuple(recids_urls)
external_collections_dictionary = {}
def build_external_collections_dictionary():
"""Build the dictionary of the external collections."""
for (name, configuration) in CFG_EXTERNAL_COLLECTIONS.iteritems():
engine_name = configuration.pop('engine', 'External') + 'SearchEngine'
configuration['name'] = name
if globals().has_key(engine_name):
external_collections_dictionary[name] = globals()[engine_name](configuration)
else:
sys.stderr.write("Error : not found " + engine_name + "\n")
build_external_collections_dictionary()
diff --git a/modules/websearch/lib/websearch_templates.py b/modules/websearch/lib/websearch_templates.py
index aef98b310..2ece98057 100644
--- a/modules/websearch/lib/websearch_templates.py
+++ b/modules/websearch/lib/websearch_templates.py
@@ -1,4048 +1,4049 @@
# -*- coding: utf-8 -*-
## This file is part of CDS Invenio.
## Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008 CERN.
##
## CDS Invenio is free software; you can redistribute it and/or
## modify it under the terms of the GNU General Public License as
## published by the Free Software Foundation; either version 2 of the
## License, or (at your option) any later version.
##
## CDS Invenio is distributed in the hope that it will be useful, but
## WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
## General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with CDS Invenio; if not, write to the Free Software Foundation, Inc.,
## 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
# pylint: disable-msg=C0301
__revision__ = "$Id$"
import time
import cgi
import gettext
import string
import re
import locale
from urllib import quote, urlencode
from xml.sax.saxutils import escape as xml_escape
from invenio.config import \
CFG_WEBSEARCH_LIGHTSEARCH_PATTERN_BOX_WIDTH, \
CFG_WEBSEARCH_SIMPLESEARCH_PATTERN_BOX_WIDTH, \
CFG_WEBSEARCH_ADVANCEDSEARCH_PATTERN_BOX_WIDTH, \
CFG_WEBSEARCH_AUTHOR_ET_AL_THRESHOLD, \
CFG_WEBSEARCH_USE_ALEPH_SYSNOS, \
CFG_WEBSEARCH_SPLIT_BY_COLLECTION, \
CFG_BIBRANK_SHOW_READING_STATS, \
CFG_BIBRANK_SHOW_DOWNLOAD_STATS, \
CFG_BIBRANK_SHOW_DOWNLOAD_GRAPHS, \
CFG_BIBRANK_SHOW_CITATION_LINKS, \
CFG_BIBRANK_SHOW_CITATION_STATS, \
CFG_BIBRANK_SHOW_CITATION_GRAPHS, \
CFG_WEBSEARCH_INSTANT_BROWSE_RSS, \
CFG_WEBSEARCH_RSS_TTL, \
CFG_SITE_LANG, \
CFG_SITE_NAME, \
CFG_SITE_NAME_INTL, \
CFG_VERSION, \
CFG_SITE_URL, \
CFG_SITE_SUPPORT_EMAIL, \
CFG_SITE_ADMIN_EMAIL, \
CFG_INSPIRE_SITE, \
CFG_WEBSEARCH_DEFAULT_SEARCH_INTERFACE, \
CFG_WEBSEARCH_ENABLED_SEARCH_INTERFACES, \
CFG_WEBSEARCH_MAX_RECORDS_IN_GROUPS, \
CFG_BIBINDEX_CHARS_PUNCTUATION, \
CFG_WEBCOMMENT_ALLOW_COMMENTS, \
CFG_WEBCOMMENT_ALLOW_REVIEWS, \
CFG_WEBSEARCH_SHOW_COMMENT_COUNT, \
CFG_WEBSEARCH_SHOW_REVIEW_COUNT
from invenio.dbquery import run_sql
from invenio.messages import gettext_set_language
#from invenio.search_engine_config import CFG_EXPERIMENTAL_FEATURES
from invenio.urlutils import make_canonical_urlargd, drop_default_urlargd, create_html_link, create_url
from invenio.htmlutils import nmtoken_from_string
from invenio.webinterface_handler import wash_urlargd
from invenio.bibrank_citation_searcher import get_cited_by_count
from invenio.intbitset import intbitset
from invenio.websearch_external_collections import external_collection_get_state, get_external_collection_engine
from invenio.websearch_external_collections_utils import get_collection_id
+from invenio.websearch_external_collections_config import CFG_EXTERNAL_COLLECTION_MAXRESULTS
_RE_PUNCTUATION = re.compile(CFG_BIBINDEX_CHARS_PUNCTUATION)
_RE_SPACES = re.compile(r"\s+")
def get_fieldvalues(recID, tag):
"""Return list of field values for field TAG inside record RECID.
FIXME: should be imported commonly for search_engine too."""
out = []
if tag == "001___":
# we have asked for recID that is not stored in bibXXx tables
out.append(str(recID))
else:
# we are going to look inside bibXXx tables
digit = tag[0:2]
bx = "bib%sx" % digit
bibx = "bibrec_bib%sx" % digit
query = "SELECT bx.value FROM %s AS bx, %s AS bibx WHERE bibx.id_bibrec='%s' AND bx.id=bibx.id_bibxxx AND bx.tag LIKE '%s'" \
"ORDER BY bibx.field_number, bx.tag ASC" % (bx, bibx, recID, tag)
res = run_sql(query)
for row in res:
out.append(row[0])
return out
class Template:
# This dictionary maps CDS Invenio language code to locale codes (ISO 639)
tmpl_localemap = {
'bg': 'bg_BG',
'ca': 'ca_ES',
'de': 'de_DE',
'el': 'el_GR',
'en': 'en_US',
'es': 'es_ES',
'pt': 'pt_BR',
'fr': 'fr_FR',
'it': 'it_IT',
'ro': 'ro_RO',
'ru': 'ru_RU',
'rw': 'rw_RW',
'sk': 'sk_SK',
'cs': 'cs_CZ',
'no': 'no_NO',
'sv': 'sv_SE',
'uk': 'uk_UA',
'ja': 'ja_JA',
'pl': 'pl_PL',
'hr': 'hr_HR',
'zh_CN': 'zh_CN',
'zh_TW': 'zh_TW',
'hu': 'hu_HU',
'af': 'af_ZA',
'gl': 'gl_ES'
}
tmpl_default_locale = "en_US" # which locale to use by default, useful in case of failure
# Type of the allowed parameters for the web interface for search results
search_results_default_urlargd = {
'cc': (str, CFG_SITE_NAME),
'c': (list, []),
'p': (str, ""), 'f': (str, ""),
'rg': (int, 10),
'sf': (str, ""),
'so': (str, "d"),
'sp': (str, ""),
'rm': (str, ""),
'of': (str, "hb"),
'ot': (list, []),
'aas': (int, CFG_WEBSEARCH_DEFAULT_SEARCH_INTERFACE),
'as': (int, CFG_WEBSEARCH_DEFAULT_SEARCH_INTERFACE),
'p1': (str, ""), 'f1': (str, ""), 'm1': (str, ""), 'op1':(str, ""),
'p2': (str, ""), 'f2': (str, ""), 'm2': (str, ""), 'op2':(str, ""),
'p3': (str, ""), 'f3': (str, ""), 'm3': (str, ""),
'sc': (int, 0),
'jrec': (int, 0),
'recid': (int, -1), 'recidb': (int, -1), 'sysno': (str, ""),
'id': (int, -1), 'idb': (int, -1), 'sysnb': (str, ""),
'action': (str, "search"),
'action_search': (str, ""),
'action_browse': (str, ""),
'd1': (str, ""),
'd1y': (int, 0), 'd1m': (int, 0), 'd1d': (int, 0),
'd2': (str, ""),
'd2y': (int, 0), 'd2m': (int, 0), 'd2d': (int, 0),
'dt': (str, ""),
'ap': (int, 1),
'verbose': (int, 0),
'ec': (list, []),
}
# ...and for search interfaces
search_interface_default_urlargd = {
'aas': (int, CFG_WEBSEARCH_DEFAULT_SEARCH_INTERFACE),
'as': (int, CFG_WEBSEARCH_DEFAULT_SEARCH_INTERFACE),
'verbose': (int, 0)}
# ...and for RSS feeds
rss_default_urlargd = {'c' : (list, []),
'cc' : (str, ""),
'p' : (str, ""),
'f' : (str, ""),
'p1' : (str, ""),
'f1' : (str, ""),
'm1' : (str, ""),
'op1': (str, ""),
'p2' : (str, ""),
'f2' : (str, ""),
'm2' : (str, ""),
'op2': (str, ""),
'p3' : (str, ""),
'f3' : (str, ""),
'm3' : (str, "")}
tmpl_openurl_accepted_args = {
'id' : (list, []),
'genre' : (str, ''),
'aulast' : (str, ''),
'aufirst' : (str, ''),
'auinit' : (str, ''),
'auinit1' : (str, ''),
'auinitm' : (str, ''),
'issn' : (str, ''),
'eissn' : (str, ''),
'coden' : (str, ''),
'isbn' : (str, ''),
'sici' : (str, ''),
'bici' : (str, ''),
'title' : (str, ''),
'stitle' : (str, ''),
'atitle' : (str, ''),
'volume' : (str, ''),
'part' : (str, ''),
'issue' : (str, ''),
'spage' : (str, ''),
'epage' : (str, ''),
'pages' : (str, ''),
'artnum' : (str, ''),
'date' : (str, ''),
'ssn' : (str, ''),
'quarter' : (str, ''),
'url_ver' : (str, ''),
'ctx_ver' : (str, ''),
'rft_val_fmt' : (str, ''),
'rft_id' : (list, []),
'rft.atitle' : (str, ''),
'rft.title' : (str, ''),
'rft.jtitle' : (str, ''),
'rft.stitle' : (str, ''),
'rft.date' : (str, ''),
'rft.volume' : (str, ''),
'rft.issue' : (str, ''),
'rft.spage' : (str, ''),
'rft.epage' : (str, ''),
'rft.pages' : (str, ''),
'rft.artnumber' : (str, ''),
'rft.issn' : (str, ''),
'rft.eissn' : (str, ''),
'rft.aulast' : (str, ''),
'rft.aufirst' : (str, ''),
'rft.auinit' : (str, ''),
'rft.auinit1' : (str, ''),
'rft.auinitm' : (str, ''),
'rft.ausuffix' : (str, ''),
'rft.au' : (list, []),
'rft.aucorp' : (str, ''),
'rft.isbn' : (str, ''),
'rft.coden' : (str, ''),
'rft.sici' : (str, ''),
'rft.genre' : (str, 'unknown'),
'rft.chron' : (str, ''),
'rft.ssn' : (str, ''),
'rft.quarter' : (int, ''),
'rft.part' : (str, ''),
'rft.btitle' : (str, ''),
'rft.isbn' : (str, ''),
'rft.atitle' : (str, ''),
'rft.place' : (str, ''),
'rft.pub' : (str, ''),
'rft.edition' : (str, ''),
'rft.tpages' : (str, ''),
'rft.series' : (str, ''),
}
tmpl_opensearch_rss_url_syntax = "%(CFG_SITE_URL)s/rss?p={searchTerms}&jrec={startIndex}&rg={count}&ln={language}&startIndex" % {'CFG_SITE_URL': CFG_SITE_URL}
tmpl_opensearch_html_url_syntax = "%(CFG_SITE_URL)s/search?p={searchTerms}&jrec={startIndex}&rg={count}&ln={language}&startIndex" % {'CFG_SITE_URL': CFG_SITE_URL}
def tmpl_openurl2invenio(self, openurl_data):
""" Return an Invenio url corresponding to a search with the data
included in the openurl form map.
"""
def isbn_to_isbn13_isbn10(isbn):
isbn = isbn.replace(' ', '').replace('-', '')
if len(isbn) == 10 and isbn.isdigit():
## We already have isbn10
return ('', isbn)
if len(isbn) != 13 and isbn.isdigit():
return ('', '')
isbn13, isbn10 = isbn, isbn[3:-1]
checksum = 0
weight = 10
for char in isbn10:
checksum += int(char) * weight
weight -= 1
checksum = 11 - (checksum % 11)
if checksum == 10:
isbn10 += 'X'
if checksum == 11:
isbn10 += '0'
else:
isbn10 += str(checksum)
return (isbn13, isbn10)
from invenio.search_engine import perform_request_search
doi = ''
pmid = ''
bibcode = ''
oai = ''
issn = ''
isbn = ''
for elem in openurl_data['id']:
if elem.startswith('doi:'):
doi = elem[len('doi:'):]
elif elem.startswith('pmid:'):
pmid = elem[len('pmid:'):]
elif elem.startswith('bibcode:'):
bibcode = elem[len('bibcode:'):]
elif elem.startswith('oai:'):
oai = elem[len('oai:'):]
for elem in openurl_data['rft_id']:
if elem.startswith('info:doi/'):
doi = elem[len('info:doi/'):]
elif elem.startswith('info:pmid/'):
pmid = elem[len('info:pmid/'):]
elif elem.startswith('info:bibcode/'):
bibcode = elem[len('info:bibcode/'):]
elif elem.startswith('info:oai/'):
oai = elem[len('info:oai/')]
elif elem.startswith('urn:ISBN:'):
isbn = elem[len('urn:ISBN:'):]
elif elem.startswith('urn:ISSN:'):
issn = elem[len('urn:ISSN:'):]
## Building author query
aulast = openurl_data['rft.aulast'] or openurl_data['aulast']
aufirst = openurl_data['rft.aufirst'] or openurl_data['aufirst']
auinit = openurl_data['rft.auinit'] or \
openurl_data['auinit'] or \
openurl_data['rft.auinit1'] + ' ' + openurl_data['rft.auinitm'] or \
openurl_data['auinit1'] + ' ' + openurl_data['auinitm'] or aufirst[:1]
auinit = auinit.upper()
if aulast and aufirst:
author_query = 'author:"%s, %s" or author:"%s, %s"' % (aulast, aufirst, aulast, auinit)
elif aulast and auinit:
author_query = 'author:"%s, %s"' % (aulast, auinit)
else:
author_query = ''
## Building title query
title = openurl_data['rft.atitle'] or \
openurl_data['atitle'] or \
openurl_data['rft.btitle'] or \
openurl_data['rft.title'] or \
openurl_data['title']
if title:
title_query = 'title:"%s"' % title
title_query_cleaned = 'title:"%s"' % _RE_SPACES.sub(' ', _RE_PUNCTUATION.sub(' ', title))
else:
title_query = ''
## Building journal query
jtitle = openurl_data['rft.stitle'] or \
openurl_data['stitle'] or \
openurl_data['rft.jtitle'] or \
openurl_data['title']
if jtitle:
journal_query = 'journal:"%s"' % jtitle
else:
journal_query = ''
## Building isbn query
isbn = isbn or openurl_data['rft.isbn'] or \
openurl_data['isbn']
isbn13, isbn10 = isbn_to_isbn13_isbn10(isbn)
if isbn13:
isbn_query = 'isbn:"%s" or isbn:"%s"' % (isbn13, isbn10)
elif isbn10:
isbn_query = 'isbn:"%s"' % isbn10
else:
isbn_query = ''
## Building issn query
issn = issn or openurl_data['rft.eissn'] or \
openurl_data['eissn'] or \
openurl_data['rft.issn'] or \
openurl_data['issn']
if issn:
issn_query = 'issn:"%s"' % issn
else:
issn_query = ''
## Building coden query
coden = openurl_data['rft.coden'] or openurl_data['coden']
if coden:
coden_query = 'coden:"%s"' % coden
else:
coden_query = ''
## Building doi query
if False: #doi: #FIXME Temporaly disabled until doi field is properly setup
doi_query = 'doi:"%s"' % doi
else:
doi_query = ''
## Trying possible searches
if doi_query:
if perform_request_search(p=doi_query):
return '%s/search?%s' % (CFG_SITE_URL, urlencode({
'p' : doi_query,
'sc' : CFG_WEBSEARCH_SPLIT_BY_COLLECTION,
'of' : 'hd'}))
if isbn_query:
if perform_request_search(p=isbn_query):
return '%s/search?%s' % (CFG_SITE_URL, urlencode({
'p' : isbn_query,
'sc' : CFG_WEBSEARCH_SPLIT_BY_COLLECTION,
'of' : 'hd'}))
if coden_query:
if perform_request_search(p=coden_query):
return '%s/search?%s' % (CFG_SITE_URL, urlencode({
'p' : coden_query,
'sc' : CFG_WEBSEARCH_SPLIT_BY_COLLECTION,
'of' : 'hd'}))
if author_query and title_query:
if perform_request_search(p='%s and %s' % (title_query, author_query)):
return '%s/search?%s' % (CFG_SITE_URL, urlencode({
'p' : '%s and %s' % (title_query, author_query),
'sc' : CFG_WEBSEARCH_SPLIT_BY_COLLECTION,
'of' : 'hd'}))
if title_query:
result = len(perform_request_search(p=title_query))
if result == 1:
return '%s/search?%s' % (CFG_SITE_URL, urlencode({
'p' : title_query,
'sc' : CFG_WEBSEARCH_SPLIT_BY_COLLECTION,
'of' : 'hd'}))
elif result > 1:
return '%s/search?%s' % (CFG_SITE_URL, urlencode({
'p' : title_query,
'sc' : CFG_WEBSEARCH_SPLIT_BY_COLLECTION,
'of' : 'hb'}))
## Nothing worked, let's return a search that the user can improve
if author_query and title_query:
return '%s/search%s' % (CFG_SITE_URL, make_canonical_urlargd({
'p' : '%s and %s' % (title_query_cleaned, author_query),
'sc' : CFG_WEBSEARCH_SPLIT_BY_COLLECTION,
'of' : 'hb'}, {}))
elif title_query:
return '%s/search%s' % (CFG_SITE_URL, make_canonical_urlargd({
'p' : title_query_cleaned,
'sc' : CFG_WEBSEARCH_SPLIT_BY_COLLECTION,
'of' : 'hb'}, {}))
else:
## Mmh. Too few information provided.
return '%s/search%s' % (CFG_SITE_URL, make_canonical_urlargd({
'p' : 'recid:-1',
'sc' : CFG_WEBSEARCH_SPLIT_BY_COLLECTION,
'of' : 'hb'}, {}))
def tmpl_opensearch_description(self, ln):
""" Returns the OpenSearch description file of this site.
"""
_ = gettext_set_language(ln)
return """
%(short_name)s
%(long_name)s
%(description)s
UTF-8
UTF-8
*
%(CFG_SITE_ADMIN_EMAIL)s
Powered by CDS Invenio
%(CFG_SITE_URL)s
""" % \
{'CFG_SITE_URL': CFG_SITE_URL,
'short_name': CFG_SITE_NAME_INTL.get(ln, CFG_SITE_NAME)[:16],
'long_name': CFG_SITE_NAME_INTL.get(ln, CFG_SITE_NAME),
'description': (_("Search on %(x_CFG_SITE_NAME_INTL)s") % \
{'x_CFG_SITE_NAME_INTL': CFG_SITE_NAME_INTL.get(ln, CFG_SITE_NAME)})[:1024],
'CFG_SITE_ADMIN_EMAIL': CFG_SITE_ADMIN_EMAIL,
'rss_search_syntax': self.tmpl_opensearch_rss_url_syntax,
'html_search_syntax': self.tmpl_opensearch_html_url_syntax
}
def build_search_url(self, known_parameters={}, **kargs):
""" Helper for generating a canonical search
url. 'known_parameters' is the list of query parameters you
inherit from your current query. You can then pass keyword
arguments to modify this query.
build_search_url(known_parameters, of="xm")
The generated URL is absolute.
"""
parameters = {}
parameters.update(known_parameters)
parameters.update(kargs)
# Now, we only have the arguments which have _not_ their default value
parameters = drop_default_urlargd(parameters, self.search_results_default_urlargd)
# Treat `as' argument specially:
if parameters.has_key('aas'):
parameters['as'] = parameters['aas']
del parameters['aas']
# Asking for a recid? Return a /record/ URL
if 'recid' in parameters:
target = "%s/record/%s" % (CFG_SITE_URL, parameters['recid'])
del parameters['recid']
target += make_canonical_urlargd(parameters, self.search_results_default_urlargd)
return target
return "%s/search%s" % (CFG_SITE_URL, make_canonical_urlargd(parameters, self.search_results_default_urlargd))
def build_search_interface_url(self, known_parameters={}, **kargs):
""" Helper for generating a canonical search interface URL."""
parameters = {}
parameters.update(known_parameters)
parameters.update(kargs)
c = parameters['c']
del parameters['c']
# Now, we only have the arguments which have _not_ their default value
parameters = drop_default_urlargd(parameters, self.search_results_default_urlargd)
# Treat `as' argument specially:
if parameters.has_key('aas'):
parameters['as'] = parameters['aas']
del parameters['aas']
if c and c != CFG_SITE_NAME:
base = CFG_SITE_URL + '/collection/' + quote(c)
else:
base = CFG_SITE_URL
return create_url(base, parameters)
def build_rss_url(self, known_parameters, **kargs):
"""Helper for generating a canonical RSS URL"""
parameters = {}
parameters.update(known_parameters)
parameters.update(kargs)
# Keep only interesting parameters
argd = wash_urlargd(parameters, self.rss_default_urlargd)
if argd:
# Handle 'c' differently since it is a list
c = argd.get('c', [])
del argd['c']
# Create query, and drop empty params
args = make_canonical_urlargd(argd, self.rss_default_urlargd)
if c != []:
# Add collections
c = [quote(coll) for coll in c]
if args == '':
args += '?'
else:
args += '&'
args += 'c=' + '&c='.join(c)
return CFG_SITE_URL + '/rss' + args
def tmpl_record_page_header_content(self, req, recid, ln):
""" Provide extra information in the header of /record pages """
_ = gettext_set_language(ln)
title = get_fieldvalues(recid, "245__a")
if title:
title = cgi.escape(title[0])
else:
title = _("Record") + ' #%d' % recid
keywords = ', '.join(get_fieldvalues(recid, "6531_a"))
description = ' '.join(get_fieldvalues(recid, "520__a"))
description += "\n"
description += '; '.join(get_fieldvalues(recid, "100__a") + get_fieldvalues(recid, "700__a"))
return [cgi.escape(x, True) for x in (title, description, keywords)]
def tmpl_navtrail_links(self, aas, ln, dads):
"""
Creates the navigation bar at top of each search page (*Home > Root collection > subcollection > ...*)
Parameters:
- 'aas' *int* - Should we display an advanced search box?
- 'ln' *string* - The language to display
- 'separator' *string* - The separator between two consecutive collections
- 'dads' *list* - A list of parent links, eachone being a dictionary of ('name', 'longname')
"""
out = []
for url, name in dads:
args = {'c': url, 'as': aas, 'ln': ln}
out.append(create_html_link(self.build_search_interface_url(**args), {}, cgi.escape(name), {'class': 'navtrail'}))
return ' > '.join(out)
def tmpl_webcoll_body(self, ln, collection, te_portalbox,
searchfor, np_portalbox, narrowsearch,
focuson, instantbrowse, ne_portalbox):
""" Creates the body of the main search page.
Parameters:
- 'ln' *string* - language of the page being generated
- 'collection' - collection id of the page being generated
- 'te_portalbox' *string* - The HTML code for the portalbox on top of search
- 'searchfor' *string* - The HTML code for the search for box
- 'np_portalbox' *string* - The HTML code for the portalbox on bottom of search
- 'narrowsearch' *string* - The HTML code for the search categories (left bottom of page)
- 'focuson' *string* - The HTML code for the "focuson" categories (right bottom of page)
- 'ne_portalbox' *string* - The HTML code for the bottom of the page
"""
if not narrowsearch:
narrowsearch = instantbrowse
body = '''
""" % {'ne_portalbox' : ne_portalbox}
return body
def tmpl_portalbox(self, title, body):
"""Creates portalboxes based on the parameters
Parameters:
- 'title' *string* - The title of the box
- 'body' *string* - The HTML code for the body of the box
"""
out = """
""" % {'title' : cgi.escape(title), 'body' : body}
return out
def tmpl_searchfor_light(self, ln, collection_id, collection_name, record_count,
example_search_queries): # EXPERIMENTAL
"""Produces light *Search for* box for the current collection.
Parameters:
- 'ln' *string* - *str* The language to display
- 'collection_id' - *str* The collection id
- 'collection_name' - *str* The collection name in current language
- 'example_search_queries' - *list* List of search queries given as example for this collection
"""
# load the right message language
_ = gettext_set_language(ln)
out = '''
'''
argd = drop_default_urlargd({'ln': ln, 'sc': CFG_WEBSEARCH_SPLIT_BY_COLLECTION},
self.search_results_default_urlargd)
# Only add non-default hidden values
for field, value in argd.items():
out += self.tmpl_input_hidden(field, value)
header = _("Search %s records for:") % \
self.tmpl_nbrecs_info(record_count, "", "")
asearchurl = self.build_search_interface_url(c=collection_id,
aas=max(CFG_WEBSEARCH_ENABLED_SEARCH_INTERFACES),
ln=ln)
# Build example of queries for this collection
example_search_queries_links = [create_html_link(self.build_search_url(p=example_query,
ln=ln,
aas=-1,
c=collection_id),
{},
cgi.escape(example_query),
{'class': 'examplequery'}) \
for example_query in example_search_queries]
example_query_html = ''
if len(example_search_queries) > 0:
example_query_link = example_search_queries_links[0]
# offers more examples if possible
more = ''
if len(example_search_queries_links) > 1:
more = '''
''' % {'more_example_queries': '
'.join(example_search_queries_links[1:]), 'show_less':_("less"), 'show_more':_("more")} example_query_html += '''
%(search_in)s
''' % {'ln' : ln,
'sizepattern' : CFG_WEBSEARCH_LIGHTSEARCH_PATTERN_BOX_WIDTH,
'langlink': ln != CFG_SITE_LANG and '?ln=' + ln or '',
'siteurl' : CFG_SITE_URL,
'asearch' : create_html_link(asearchurl, {}, _('Advanced Search')),
'header' : header,
'msg_search' : _('Search'),
'msg_browse' : _('Browse'),
'msg_search_tips' : _('Search Tips'),
'search_in': search_in,
'example_query_html': example_query_html}
return out
def tmpl_searchfor_simple(self, ln, collection_id, collection_name, record_count, middle_option):
"""Produces simple *Search for* box for the current collection.
Parameters:
- 'ln' *string* - *str* The language to display
- 'collection_id' - *str* The collection id
- 'collection_name' - *str* The collection name in current language
- 'record_count' - *str* Number of records in this collection
- 'middle_option' *string* - HTML code for the options (any field, specific fields ...)
"""
# load the right message language
_ = gettext_set_language(ln)
out = '''
'''
argd = drop_default_urlargd({'ln': ln, 'cc': collection_id, 'sc': CFG_WEBSEARCH_SPLIT_BY_COLLECTION},
self.search_results_default_urlargd)
# Only add non-default hidden values
for field, value in argd.items():
out += self.tmpl_input_hidden(field, value)
header = _("Search %s records for:") % \
self.tmpl_nbrecs_info(record_count, "", "")
asearchurl = self.build_search_interface_url(c=collection_id,
aas=max(CFG_WEBSEARCH_ENABLED_SEARCH_INTERFACES),
ln=ln)
# print commentary start:
out += '''
''' % {'ln' : ln,
'sizepattern' : CFG_WEBSEARCH_SIMPLESEARCH_PATTERN_BOX_WIDTH,
'langlink': ln != CFG_SITE_LANG and '?ln=' + ln or '',
'siteurl' : CFG_SITE_URL,
'asearch' : create_html_link(asearchurl, {}, _('Advanced Search')),
'header' : header,
'middle_option' : middle_option,
'msg_search' : _('Search'),
'msg_browse' : _('Browse'),
'msg_search_tips' : _('Search Tips')}
return out
def tmpl_searchfor_advanced(self,
ln, # current language
collection_id,
collection_name,
record_count,
middle_option_1, middle_option_2, middle_option_3,
searchoptions,
sortoptions,
rankoptions,
displayoptions,
formatoptions
):
"""
Produces advanced *Search for* box for the current collection.
Parameters:
- 'ln' *string* - The language to display
- 'middle_option_1' *string* - HTML code for the first row of options (any field, specific fields ...)
- 'middle_option_2' *string* - HTML code for the second row of options (any field, specific fields ...)
- 'middle_option_3' *string* - HTML code for the third row of options (any field, specific fields ...)
- 'searchoptions' *string* - HTML code for the search options
- 'sortoptions' *string* - HTML code for the sort options
- 'rankoptions' *string* - HTML code for the rank options
- 'displayoptions' *string* - HTML code for the display options
- 'formatoptions' *string* - HTML code for the format options
"""
# load the right message language
_ = gettext_set_language(ln)
out = '''
'''
argd = drop_default_urlargd({'ln': ln, 'aas': 1, 'cc': collection_id, 'sc': CFG_WEBSEARCH_SPLIT_BY_COLLECTION},
self.search_results_default_urlargd)
# Only add non-default hidden values
for field, value in argd.items():
out += self.tmpl_input_hidden(field, value)
header = _("Search %s records for") % \
self.tmpl_nbrecs_info(record_count, "", "")
header += ':'
ssearchurl = self.build_search_interface_url(c=collection_id, aas=min(CFG_WEBSEARCH_ENABLED_SEARCH_INTERFACES), ln=ln)
out += '''
''' % {'ln' : ln,
'sizepattern' : CFG_WEBSEARCH_ADVANCEDSEARCH_PATTERN_BOX_WIDTH,
'langlink': ln != CFG_SITE_LANG and '?ln=' + ln or '',
'siteurl' : CFG_SITE_URL,
'ssearch' : create_html_link(ssearchurl, {}, _("Simple Search")),
'header' : header,
'matchbox_m1' : self.tmpl_matchtype_box('m1', ln=ln),
'middle_option_1' : middle_option_1,
'andornot_op1' : self.tmpl_andornot_box('op1', ln=ln),
'matchbox_m2' : self.tmpl_matchtype_box('m2', ln=ln),
'middle_option_2' : middle_option_2,
'andornot_op2' : self.tmpl_andornot_box('op2', ln=ln),
'matchbox_m3' : self.tmpl_matchtype_box('m3', ln=ln),
'middle_option_3' : middle_option_3,
'msg_search' : _("Search"),
'msg_browse' : _("Browse"),
'msg_search_tips' : _("Search Tips")}
if (searchoptions):
out += """
""" % {
'searchheader' : _("Search options:"),
'searchoptions' : searchoptions
}
out += """
""" % {
'added' : _("Added/modified since:"),
'until' : _("until:"),
'added_or_modified': self.tmpl_inputdatetype(ln=ln),
'date_added' : self.tmpl_inputdate("d1", ln=ln),
'date_until' : self.tmpl_inputdate("d2", ln=ln),
'msg_sort' : _("Sort by:"),
'msg_display' : _("Display results:"),
'msg_format' : _("Output format:"),
'sortoptions' : sortoptions,
'rankoptions' : rankoptions,
'displayoptions' : displayoptions,
'formatoptions' : formatoptions
}
return out
def tmpl_matchtype_box(self, name='m', value='', ln='en'):
"""Returns HTML code for the 'match type' selection box.
Parameters:
- 'name' *string* - The name of the produced select
- 'value' *string* - The selected value (if any value is already selected)
- 'ln' *string* - the language to display
"""
# load the right message language
_ = gettext_set_language(ln)
out = """
""" % {'name' : name,
'sela' : self.tmpl_is_selected('a', value),
'opta' : _("All of the words:"),
'selo' : self.tmpl_is_selected('o', value),
'opto' : _("Any of the words:"),
'sele' : self.tmpl_is_selected('e', value),
'opte' : _("Exact phrase:"),
'selp' : self.tmpl_is_selected('p', value),
'optp' : _("Partial phrase:"),
'selr' : self.tmpl_is_selected('r', value),
'optr' : _("Regular expression:")
}
return out
def tmpl_is_selected(self, var, fld):
"""
Checks if *var* and *fld* are equal, and if yes, returns ' selected="selected"'. Useful for select boxes.
Parameters:
- 'var' *string* - First value to compare
- 'fld' *string* - Second value to compare
"""
if var == fld:
return ' selected="selected"'
else:
return ""
def tmpl_andornot_box(self, name='op', value='', ln='en'):
"""
Returns HTML code for the AND/OR/NOT selection box.
Parameters:
- 'name' *string* - The name of the produced select
- 'value' *string* - The selected value (if any value is already selected)
- 'ln' *string* - the language to display
"""
# load the right message language
_ = gettext_set_language(ln)
out = """
""" % {'name' : name,
'sela' : self.tmpl_is_selected('a', value), 'opta' : _("AND"),
'selo' : self.tmpl_is_selected('o', value), 'opto' : _("OR"),
'seln' : self.tmpl_is_selected('n', value), 'optn' : _("AND NOT")
}
return out
def tmpl_inputdate(self, name, ln, sy = 0, sm = 0, sd = 0):
"""
Produces *From Date*, *Until Date* kind of selection box. Suitable for search options.
Parameters:
- 'name' *string* - The base name of the produced selects
- 'ln' *string* - the language to display
"""
# load the right message language
_ = gettext_set_language(ln)
box = """
"""
# month
box += """
"""
# year
box += """
"""
return box
def tmpl_inputdatetype(self, dt='', ln=CFG_SITE_LANG):
"""
Produces input date type selection box to choose
added-or-modified date search option.
Parameters:
- 'dt' *string - date type (c=created, m=modified)
- 'ln' *string* - the language to display
"""
# load the right message language
_ = gettext_set_language(ln)
box = """
""" % { 'added': _("Added since:"),
'modified': _("Modified since:"),
'sel': self.tmpl_is_selected(dt, 'm'),
}
return box
def tmpl_narrowsearch(self, aas, ln, type, father,
has_grandchildren, sons, display_grandsons,
grandsons):
"""
Creates list of collection descendants of type *type* under title *title*.
If aas==1, then links to Advanced Search interfaces; otherwise Simple Search.
Suitable for 'Narrow search' and 'Focus on' boxes.
Parameters:
- 'aas' *bool* - Should we display an advanced search box?
- 'ln' *string* - The language to display
- 'type' *string* - The type of the produced box (virtual collections or normal collections)
- 'father' *collection* - The current collection
- 'has_grandchildren' *bool* - If the current collection has grand children
- 'sons' *list* - The list of the sub-collections (first level)
- 'display_grandsons' *bool* - If the grand children collections should be displayed (2 level deep display)
- 'grandsons' *list* - The list of sub-collections (second level)
"""
# load the right message language
_ = gettext_set_language(ln)
title = {'r': _("Narrow by collection:"),
'v': _("Focus on:")}[type]
if has_grandchildren:
style_prolog = ""
style_epilog = ""
else:
style_prolog = ""
style_epilog = ""
out = """
"
return out
def tmpl_searchalso(self, ln, engines_list, collection_id):
_ = gettext_set_language(ln)
box_name = _("Search also:")
html = """
"""
return html
def tmpl_nbrecs_info(self, number, prolog=None, epilog=None, ln=CFG_SITE_LANG):
"""
Return information on the number of records.
Parameters:
- 'number' *string* - The number of records
- 'prolog' *string* (optional) - An HTML code to prefix the number (if **None**, will be
'(')
- 'epilog' *string* (optional) - An HTML code to append to the number (if **None**, will be
')')
"""
if number is None:
number = 0
if prolog is None:
prolog = ''' ('''
if epilog is None:
epilog = ''')'''
return prolog + self.tmpl_nice_number(number, ln) + epilog
def tmpl_box_restricted_content(self, ln):
"""
Displays a box containing a *restricted content* message
Parameters:
- 'ln' *string* - The language to display
"""
# load the right message language
_ = gettext_set_language(ln)
return _("This collection is restricted. If you are authorized to access it, please click on the Search button.")
def tmpl_box_hosted_collection(self, ln):
"""
Displays a box containing a *hosted collection* message
Parameters:
- 'ln' *string* - The language to display
"""
# load the right message language
_ = gettext_set_language(ln)
return _("This is a hosted external collection. Please click on the Search button to see its latest additions.")
def tmpl_box_no_records(self, ln):
"""
Displays a box containing a *no content* message
Parameters:
- 'ln' *string* - The language to display
"""
# load the right message language
_ = gettext_set_language(ln)
return _("This collection does not contain any document yet.")
def tmpl_instant_browse(self, aas, ln, recids, more_link = None):
"""
Formats a list of records (given in the recids list) from the database.
Parameters:
- 'aas' *int* - Advanced Search interface or not (0 or 1)
- 'ln' *string* - The language to display
- 'recids' *list* - the list of records from the database
- 'more_link' *string* - the "More..." link for the record. If not given, will not be displayed
"""
# load the right message language
_ = gettext_set_language(ln)
body = ''''''
for recid in recids:
body += '''
"
if more_link:
body += '
''' % {'header' : _("Latest additions:"),
'body' : body,
}
def tmpl_searchwithin_select(self, ln, fieldname, selected, values):
"""
Produces 'search within' selection box for the current collection.
Parameters:
- 'ln' *string* - The language to display
- 'fieldname' *string* - the name of the select box produced
- 'selected' *string* - which of the values is selected
- 'values' *list* - the list of values in the select
"""
out = '"""
return out
def tmpl_select(self, fieldname, values, selected=None, css_class=''):
"""
Produces a generic select box
Parameters:
- 'css_class' *string* - optional, a css class to display this select with
- 'fieldname' *list* - the name of the select box produced
- 'selected' *string* - which of the values is selected
- 'values' *list* - the list of values in the select
"""
if css_class != '':
class_field = ' class="%s"' % css_class
else:
class_field = ''
out = '"""
return out
def tmpl_record_links(self, recid, ln):
"""
Displays the *More info* and *Find similar* links for a record
Parameters:
- 'ln' *string* - The language to display
- 'recid' *string* - the id of the displayed record
"""
# load the right message language
_ = gettext_set_language(ln)
out = '''
%(detailed)s - %(similar)s''' % { 'detailed': create_html_link(self.build_search_url(recid=recid, ln=ln), {}, _("Detailed record"), {'class': "moreinfo"}), 'similar': create_html_link(self.build_search_url(p="recid:%d" % recid, rm='wrd', ln=ln), {}, _("Similar records"), {'class': "moreinfo"})} if CFG_BIBRANK_SHOW_CITATION_LINKS: num_timescited = get_cited_by_count(recid) if num_timescited: out += ''' - %s ''' % \ create_html_link(self.build_search_url(p='recid:%d' % recid, rm='citation', ln=ln), {}, _("Cited by %i records") % num_timescited, {'class': "moreinfo"}) return out def tmpl_record_body(self, titles, authors, dates, rns, abstracts, urls_u, urls_z, ln): """ Displays the "HTML basic" format of a record Parameters: - 'authors' *list* - the authors (as strings) - 'dates' *list* - the dates of publication - 'rns' *list* - the quicknotes for the record - 'abstracts' *list* - the abstracts for the record - 'urls_u' *list* - URLs to the original versions of the record - 'urls_z' *list* - Not used """ out = "" for title in titles: out += "%(title)s " % { 'title' : cgi.escape(title) } if authors: out += " / " for author in authors[:CFG_WEBSEARCH_AUTHOR_ET_AL_THRESHOLD]: out += '%s; ' % \ create_html_link(self.build_search_url(p=author, f='author', ln=ln), {}, cgi.escape(author)) if len(authors) > CFG_WEBSEARCH_AUTHOR_ET_AL_THRESHOLD: out += "et al" for date in dates: out += " %s." % cgi.escape(date) for rn in rns: out += """ [%(rn)s]""" % {'rn' : cgi.escape(rn)} for abstract in abstracts: out += "
%(abstract)s [...]" % {'abstract' : cgi.escape(abstract[:1+string.find(abstract, '.')]) } for idx in range(0, len(urls_u)): out += """
%(name)s""" % { 'url' : urls_u[idx], 'name' : urls_u[idx] } return out def tmpl_search_in_bibwords(self, p, f, ln, nearest_box): """ Displays the *Words like current ones* links for a search Parameters: - 'p' *string* - Current search words - 'f' *string* - the fields in which the search was done - 'nearest_box' *string* - the HTML code for the "nearest_terms" box - most probably from a create_nearest_terms_box call """ # load the right message language _ = gettext_set_language(ln) out = ''''
for term, hits, argd in terminfo:
if hits:
hitsinfo = str(hits)
else:
hitsinfo = '-'
term = cgi.escape(term)
if term == p: # print search word for orientation:
nearesttermsboxbody_class = "nearesttermsboxbodyselected"
if hits > 0:
term = create_html_link(self.build_search_url(argd), {},
term, {'class': "nearesttermsselected"})
else:
nearesttermsboxbody_class = "nearesttermsboxbody"
term = create_html_link(self.build_search_url(argd), {},
term, {'class': "nearestterms"})
out += '''\
"
return intro + "
"""
return out
def tmpl_search_box(self, ln, aas, cc, cc_intl, ot, sp,
action, fieldslist, f1, f2, f3, m1, m2, m3,
p1, p2, p3, op1, op2, rm, p, f, coll_selects,
d1y, d2y, d1m, d2m, d1d, d2d, dt, sort_fields,
sf, so, ranks, sc, rg, formats, of, pl, jrec, ec,
show_colls=True, show_title=True):
"""
Displays the *Nearest search terms* box
Parameters:
- 'ln' *string* - The language to display
- 'aas' *bool* - Should we display an advanced search box? -1 -> 1, from simpler to more advanced
- 'cc_intl' *string* - the i18nized current collection name, used for display
- 'cc' *string* - the internal current collection name
- 'ot', 'sp' *string* - hidden values
- 'action' *string* - the action demanded by the user
- 'fieldslist' *list* - the list of all fields available, for use in select within boxes in advanced search
- 'p, f, f1, f2, f3, m1, m2, m3, p1, p2, p3, op1, op2, op3, rm' *strings* - the search parameters
- 'coll_selects' *array* - a list of lists, each containing the collections selects to display
- 'd1y, d2y, d1m, d2m, d1d, d2d' *int* - the search between dates
- 'dt' *string* - the dates' types (creation dates, modification dates)
- 'sort_fields' *array* - the select information for the sort fields
- 'sf' *string* - the currently selected sort field
- 'so' *string* - the currently selected sort order ("a" or "d")
- 'ranks' *array* - ranking methods
- 'rm' *string* - selected ranking method
- 'sc' *string* - split by collection or not
- 'rg' *string* - selected results/page
- 'formats' *array* - available output formats
- 'of' *string* - the selected output format
- 'pl' *string* - `limit to' search pattern
- show_colls *bool* - propose coll selection box?
- show_title *bool* show cc_intl in page title?
"""
# load the right message language
_ = gettext_set_language(ln)
# These are hidden fields the user does not manipulate
# directly
if aas == -1:
argd = drop_default_urlargd({
'ln': ln, 'aas': aas,
'ot': ot, 'sp': sp, 'ec': ec,
}, self.search_results_default_urlargd)
else:
argd = drop_default_urlargd({
'cc': cc, 'ln': ln, 'aas': aas,
'ot': ot, 'sp': sp, 'ec': ec,
}, self.search_results_default_urlargd)
out = ""
if show_title:
# display cc name if asked for
out += '''
"""
def tmpl_print_warning(self, msg, type, prologue, epilogue):
"""Prints warning message and flushes output.
Parameters:
- 'msg' *string* - The message string
- 'type' *string* - the warning type
- 'prologue' *string* - HTML code to display before the warning
- 'epilogue' *string* - HTML code to display after the warning
"""
out = '\n%s' % (prologue)
if type:
out += '%s: ' % type
out += '%s%s' % (msg, epilogue)
return out
def tmpl_print_search_info(self, ln, middle_only,
collection, collection_name, collection_id,
aas, sf, so, rm, rg, nb_found, of, ot, p, f, f1,
f2, f3, m1, m2, m3, op1, op2, p1, p2,
p3, d1y, d1m, d1d, d2y, d2m, d2d, dt,
all_fieldcodes, cpu_time, pl_in_url,
jrec, sc, sp):
"""Prints stripe with the information on 'collection' and 'nb_found' results and CPU time.
Also, prints navigation links (beg/next/prev/end) inside the results set.
If middle_only is set to 1, it will only print the middle box information (beg/netx/prev/end/etc) links.
This is suitable for displaying navigation links at the bottom of the search results page.
Parameters:
- 'ln' *string* - The language to display
- 'middle_only' *bool* - Only display parts of the interface
- 'collection' *string* - the collection name
- 'collection_name' *string* - the i18nized current collection name
- 'aas' *bool* - if we display the advanced search interface
- 'sf' *string* - the currently selected sort format
- 'so' *string* - the currently selected sort order ("a" or "d")
- 'rm' *string* - selected ranking method
- 'rg' *int* - selected results/page
- 'nb_found' *int* - number of results found
- 'of' *string* - the selected output format
- 'ot' *string* - hidden values
- 'p' *string* - Current search words
- 'f' *string* - the fields in which the search was done
- 'f1, f2, f3, m1, m2, m3, p1, p2, p3, op1, op2' *strings* - the search parameters
- 'jrec' *int* - number of first record on this page
- 'd1y, d2y, d1m, d2m, d1d, d2d' *int* - the search between dates
- 'dt' *string* the dates' type (creation date, modification date)
- 'all_fieldcodes' *array* - all the available fields
- 'cpu_time' *float* - the time of the query in seconds
"""
# load the right message language
_ = gettext_set_language(ln)
out = ""
# left table cells: print collection name
if not middle_only:
out += '''
"
return out
def tmpl_print_hosted_search_info(self, ln, middle_only,
collection, collection_name, collection_id,
aas, sf, so, rm, rg, nb_found, of, ot, p, f, f1,
f2, f3, m1, m2, m3, op1, op2, p1, p2,
p3, d1y, d1m, d1d, d2y, d2m, d2d, dt,
all_fieldcodes, cpu_time, pl_in_url,
jrec, sc, sp):
"""Prints stripe with the information on 'collection' and 'nb_found' results and CPU time.
Also, prints navigation links (beg/next/prev/end) inside the results set.
If middle_only is set to 1, it will only print the middle box information (beg/netx/prev/end/etc) links.
This is suitable for displaying navigation links at the bottom of the search results page.
Parameters:
- 'ln' *string* - The language to display
- 'middle_only' *bool* - Only display parts of the interface
- 'collection' *string* - the collection name
- 'collection_name' *string* - the i18nized current collection name
- 'aas' *bool* - if we display the advanced search interface
- 'sf' *string* - the currently selected sort format
- 'so' *string* - the currently selected sort order ("a" or "d")
- 'rm' *string* - selected ranking method
- 'rg' *int* - selected results/page
- 'nb_found' *int* - number of results found
- 'of' *string* - the selected output format
- 'ot' *string* - hidden values
- 'p' *string* - Current search words
- 'f' *string* - the fields in which the search was done
- 'f1, f2, f3, m1, m2, m3, p1, p2, p3, op1, op2' *strings* - the search parameters
- 'jrec' *int* - number of first record on this page
- 'd1y, d2y, d1m, d2m, d1d, d2d' *int* - the search between dates
- 'dt' *string* the dates' type (creation date, modification date)
- 'all_fieldcodes' *array* - all the available fields
- 'cpu_time' *float* - the time of the query in seconds
"""
# load the right message language
_ = gettext_set_language(ln)
out = ""
# left table cells: print collection name
if not middle_only:
out += '''
"
return out
def tmpl_nice_number(self, number, ln=CFG_SITE_LANG, thousands_separator=',', max_ndigits_after_dot=None):
"""
Return nicely printed number NUMBER in language LN using
given THOUSANDS_SEPARATOR character.
If max_ndigits_after_dot is specified and the number is float, the
number is rounded by taking in consideration up to max_ndigits_after_dot
digit after the dot.
This version does not pay attention to locale. See
tmpl_nice_number_via_locale().
"""
if type(number) is float:
if max_ndigits_after_dot is not None:
number = round(number, max_ndigits_after_dot)
int_part, frac_part = str(number).split('.')
return '%s.%s' % (self.tmpl_nice_number(int(int_part), ln, thousands_separator), frac_part)
else:
chars_in = list(str(number))
number = len(chars_in)
chars_out = []
for i in range(0, number):
if i % 3 == 0 and i != 0:
chars_out.append(thousands_separator)
chars_out.append(chars_in[number-i-1])
chars_out.reverse()
return ''.join(chars_out)
def tmpl_nice_number_via_locale(self, number, ln=CFG_SITE_LANG):
"""
Return nicely printed number NUM in language LN using the locale.
See also version tmpl_nice_number().
"""
if number is None:
return None
# Temporarily switch the numeric locale to the requested one, and format the number
# In case the system has no locale definition, use the vanilla form
ol = locale.getlocale(locale.LC_NUMERIC)
try:
locale.setlocale(locale.LC_NUMERIC, self.tmpl_localemap.get(ln, self.tmpl_default_locale))
except locale.Error:
return str(number)
try:
number = locale.format('%d', number, True)
except TypeError:
return str(number)
locale.setlocale(locale.LC_NUMERIC, ol)
return number
def tmpl_record_format_htmlbrief_header(self, ln):
"""Returns the header of the search results list when output
is html brief. Note that this function is called for each collection
results when 'split by collection' is enabled.
See also: tmpl_record_format_htmlbrief_footer(..),
tmpl_record_format_htmlbrief_body(..)
Parameters:
- 'ln' *string* - The language to display
"""
# load the right message language
_ = gettext_set_language(ln)
out = """
""" % {
'basket' : _("ADD TO BASKET")
}
return out
def tmpl_record_format_htmlbrief_body(self, ln, recid,
row_number, relevance,
record, relevances_prologue,
relevances_epilogue):
"""Returns the html brief format of one record. Used in the
search results list for each record.
See also: tmpl_record_format_htmlbrief_header(..),
tmpl_record_format_htmlbrief_footer(..)
Parameters:
- 'ln' *string* - The language to display
- 'row_number' *int* - The position of this record in the list
- 'recid' *int* - The recID
- 'relevance' *string* - The relevance of the record
- 'record' *string* - The formatted record
- 'relevances_prologue' *string* - HTML code to prepend the relevance indicator
- 'relevances_epilogue' *string* - HTML code to append to the relevance indicator (used mostly for formatting)
"""
# load the right message language
_ = gettext_set_language(ln)
out = """
%(number)s.
""" % {'recid': recid,
'number': row_number}
if relevance:
out += """
""" % { 'prologue' : relevances_prologue, 'epilogue' : relevances_epilogue, 'relevance' : relevance } out += """ %s
")
if len(elements) <= 1:
return
for element in elements[1:-1]:
end_index = element.find('')
if end_index != -1:
element = element[:end_index + 8]
- self.add_html_result(element + '
')
+ self.add_html_result(element + '
', limit)
class GoogleBooksExternalCollectionResultsParser(GoogleExternalCollectionResultsParser):
"""Parser for Google Books."""
num_results_regex = re.compile(r' with ([0-9]+?) pages on ')
def __init__(self, host = "books.google.com", path=""):
super(GoogleBooksExternalCollectionResultsParser, self).__init__(host, path)
- def parse(self, of=None, req=None):
+ def parse(self, of=None, req=None, limit=CFG_EXTERNAL_COLLECTION_MAXRESULTS):
"""Parse buffer to extract records."""
elements = self.buffer.split('
| ')
if len(elements) <= 1:
return
for element in elements[1:-1]:
- self.add_html_result(element)
+ self.add_html_result(element, limit)
class SPIRESExternalCollectionResultsParser(ExternalCollectionResultsParser):
"""Parser for SPIRES."""
num_results_regex = re.compile(r'Paper [0-9]+ to [0-9]+ of ([0-9]+)')
def __init__(self, host="www.slac.stanford.edu", path="spires/find/hep/"):
super(SPIRESExternalCollectionResultsParser, self).__init__(host, path)
- def parse(self, of=None, req=None):
+ def parse(self, of=None, req=None, limit=CFG_EXTERNAL_COLLECTION_MAXRESULTS):
"""Parse buffer to extract records."""
elements = self.buffer.split(' ') if len(elements) <= 2: return for element in elements[1:-1]: - self.add_html_result(element) + self.add_html_result(element, limit) class SCIRUSExternalCollectionResultsParser(ExternalCollectionResultsParser): """Parser for SCIRUS.""" num_results_regex = re.compile(r'([0-9,]+) total ') result_separator = re.compile(r' | [ ]*(.*?) | [ ]*|
[ ]*(.*?)[ ]*
[ ]*(.*?)[ ]*.*?
[ ]*(.*)[ ]*') cleaning = re.compile('(
%(comments)s
%(similar)s
" % {'link' : link, 'date' : date, 'comments' : comments, 'similar' : similar} else: html = self.cleaning.sub("", data) + '
' - self.add_html_result(html) + self.add_html_result(html, limit) class CiteSeerExternalCollectionResultsParser(ExternalCollectionResultsParser): """Parser for CiteSeer.""" num_results_regex = re.compile(r'
(?:More than |)([0-9]+)(?: documents found.| results)') result_separator = re.compile(r'.*?', re.DOTALL) def __init__(self, host='', path=''): super(CiteSeerExternalCollectionResultsParser, self).__init__(host, path) - def parse(self, of=None, req=None): + def parse(self, of=None, req=None, limit=CFG_EXTERNAL_COLLECTION_MAXRESULTS): """Parse buffer to extract records.""" for element in self.result_separator.finditer(self.buffer): - self.add_html_result(element.group() + '
') + self.add_html_result(element.group() + '
', limit) class CDSInvenioHTMLExternalCollectionResultsParser(ExternalCollectionResultsParser): """HTML brief (hb) Parser for Invenio""" def __init__(self, params): self.buffer = "" self.results = [] self.clean() for (name, value) in params.iteritems(): setattr(self, name, value) self.num_results_regex = re.compile(self.num_results_regex_str) self.nbrecs_regex = re.compile(self.nbrecs_regex_str, re.IGNORECASE) - def parse(self, of=None, req=None): + def parse(self, of=None, req=None, limit=CFG_EXTERNAL_COLLECTION_MAXRESULTS): """Parse buffer to extract records.""" # the patterns : # level_a : select only the results level_a_pat = re.compile(r'
%(title)s
%(body)s
'.join(example_search_queries_links[1:]), 'show_less':_("less"), 'show_more':_("more")} example_query_html += '''
%(example)s%(more)s
''' % {'example': _("Example: %(x_sample_search_query)s") % \ {'x_sample_search_query': example_query_link}, 'more': more} # display options to search in current collection or everywhere search_in = '' if collection_name != CFG_SITE_NAME_INTL.get(ln, CFG_SITE_NAME): search_in += ''' ''' % {'search_in_collection_name': _("Search in %(x_collection_name)s") % \ {'x_collection_name': collection_name}, 'collection_id': collection_id, 'root_collection_name': CFG_SITE_NAME, 'search_everywhere': _("Search everywhere")} # print commentary start: out += '''%(example_query_html)s |
%(msg_search_tips)s %(asearch)s |
| %(header)s | ||
|---|---|---|
| %(middle_option)s | ||
| %(msg_search_tips)s :: %(asearch)s | ||
| %(header)s | ||
|---|---|---|
| %(matchbox_m1)s | %(middle_option_1)s | %(andornot_op1)s |
| %(matchbox_m2)s | %(middle_option_2)s | %(andornot_op2)s |
| %(matchbox_m3)s | %(middle_option_3)s | |
| %(msg_search_tips)s :: %(ssearch)s | ||
| %(searchheader)s |
|---|
| %(searchoptions)s |
| %(added)s | %(until)s |
|---|---|
| %(added_or_modified)s %(date_added)s | %(date_until)s |
| %(msg_sort)s | %(msg_display)s | %(msg_format)s |
|---|---|---|
| %(sortoptions)s %(rankoptions)s | %(displayoptions)s | %(formatoptions)s |
| %(title)s | |
|---|---|
| """ % \ { 'narrowsearchbox': {'r': 'narrowsearchbox', 'v': 'focusonsearchbox'}[type]} if type == 'r': if son.restricted_p() and son.restricted_p() != father.restricted_p(): out += """ | """ % {'name' : cgi.escape(son.name) } # hosted collections are checked by default only when configured so elif str(son.dbquery).startswith("hostedcollection:"): external_collection_engine = get_external_collection_engine(str(son.name)) if external_collection_engine and external_collection_engine.selected_by_default: out += """""" % {'name' : cgi.escape(son.name) } elif external_collection_engine and not external_collection_engine.selected_by_default: out += """""" % {'name' : cgi.escape(son.name) } else: # strangely, the external collection engine was never found. In that case, # why was the hosted collection here in the first place? out += """""" % {'name' : cgi.escape(son.name) } else: out += """""" % {'name' : cgi.escape(son.name) } else: out += '' out += """%(link)s%(recs)s """ % {
'link': create_html_link(self.build_search_interface_url(c=son.name, ln=ln, aas=aas),
{}, style_prolog + cgi.escape(son.get_name(ln)) + style_epilog),
'recs' : self.tmpl_nbrecs_info(son.nbrecs, ln=ln)}
# the following prints the "external collection" arrow just after the name and
# number of records of the hosted collection
# 1) we might want to make the arrow work as an anchor to the hosted collection as well.
# That would probably require a new separate function under invenio.urlutils
# 2) we might want to place the arrow between the name and the number of records of the hosted collection
# That would require to edit/separate the above out += ...
if type == 'r':
if str(son.dbquery).startswith("hostedcollection:"):
out += """s/img/external-icon-light-8x8.gif){kind=icon} """ % \
{ 'siteurl' : CFG_SITE_URL, 'name' : cgi.escape(son.name), }
if son.restricted_p():
out += """ [%(msg)s] """ % { 'msg' : _("restricted") }
if display_grandsons and len(grandsons[i]):
# iterate trough grandsons:
out += """""" for grandson in grandsons[i]: out += """ %(link)s%(nbrec)s """ % { 'link': create_html_link(self.build_search_interface_url(c=grandson.name, ln=ln, aas=aas), {}, cgi.escape(grandson.get_name(ln))), 'nbrec' : self.tmpl_nbrecs_info(grandson.nbrecs, ln=ln)} # the following prints the "external collection" arrow just after the name and # number of records of the hosted collection # Some relatives comments have been made just above if type == 'r': if str(grandson.dbquery).startswith("hostedcollection:"): out += """ """ % \
{ 'siteurl' : CFG_SITE_URL, 'name' : cgi.escape(grandson.name), }
out += """ |
| ||||
| %(date)s | %(body)s |
' + \
create_html_link(more_link, {}, '[>> %s]' % _("more")) + \
'
'
return '''
| %(header)s |
|---|
| %(body)s |
%(detailed)s - %(similar)s''' % { 'detailed': create_html_link(self.build_search_url(recid=recid, ln=ln), {}, _("Detailed record"), {'class': "moreinfo"}), 'similar': create_html_link(self.build_search_url(p="recid:%d" % recid, rm='wrd', ln=ln), {}, _("Similar records"), {'class': "moreinfo"})} if CFG_BIBRANK_SHOW_CITATION_LINKS: num_timescited = get_cited_by_count(recid) if num_timescited: out += ''' - %s ''' % \ create_html_link(self.build_search_url(p='recid:%d' % recid, rm='citation', ln=ln), {}, _("Cited by %i records") % num_timescited, {'class': "moreinfo"}) return out def tmpl_record_body(self, titles, authors, dates, rns, abstracts, urls_u, urls_z, ln): """ Displays the "HTML basic" format of a record Parameters: - 'authors' *list* - the authors (as strings) - 'dates' *list* - the dates of publication - 'rns' *list* - the quicknotes for the record - 'abstracts' *list* - the abstracts for the record - 'urls_u' *list* - URLs to the original versions of the record - 'urls_z' *list* - Not used """ out = "" for title in titles: out += "%(title)s " % { 'title' : cgi.escape(title) } if authors: out += " / " for author in authors[:CFG_WEBSEARCH_AUTHOR_ET_AL_THRESHOLD]: out += '%s; ' % \ create_html_link(self.build_search_url(p=author, f='author', ln=ln), {}, cgi.escape(author)) if len(authors) > CFG_WEBSEARCH_AUTHOR_ET_AL_THRESHOLD: out += "et al" for date in dates: out += " %s." % cgi.escape(date) for rn in rns: out += """ [%(rn)s]""" % {'rn' : cgi.escape(rn)} for abstract in abstracts: out += "
%(abstract)s [...]" % {'abstract' : cgi.escape(abstract[:1+string.find(abstract, '.')]) } for idx in range(0, len(urls_u)): out += """
%(name)s""" % { 'url' : urls_u[idx], 'name' : urls_u[idx] } return out def tmpl_search_in_bibwords(self, p, f, ln, nearest_box): """ Displays the *Words like current ones* links for a search Parameters: - 'p' *string* - Current search words - 'f' *string* - the fields in which the search was done - 'nearest_box' *string* - the HTML code for the "nearest_terms" box - most probably from a create_nearest_terms_box call """ # load the right message language _ = gettext_set_language(ln) out = '
'
if f:
out += _("Words nearest to %(x_word)s inside %(x_field)s in any collection are:") % {'x_word': '' + cgi.escape(p) + '',
'x_field': '' + cgi.escape(f) + ''}
else:
out += _("Words nearest to %(x_word)s in any collection are:") % {'x_word': '' + cgi.escape(p) + ''}
out += '
' + nearest_box + '
| %(hits)s | %(term)s |
" + out + "" def tmpl_browse_pattern(self, f, fn, ln, browsed_phrases_in_colls, colls, rg): """ Displays the *Nearest search terms* box Parameters: - 'f' *string* - field (*not* i18nized) - 'fn' *string* - field name (i18nized) - 'ln' *string* - The language to display - 'browsed_phrases_in_colls' *array* - the phrases to display - 'colls' *array* - the list of collection parameters of the search (c's) - 'rg' *int* - the number of records """ # load the right message language _ = gettext_set_language(ln) out = """
| %(hits)s | %(fn)s | |
|---|---|---|
| %(nbhits)s | %(link)s | |
| %(nbhits)s | %(link)s | |
%(link_previous)s
s/img/sp.gif)
s/img/sn.gif)
%(link_next)s
|
||
%(ccname)s
''' % {'ccname' : cgi.escape(cc_intl),} out += ''' """ return out def tmpl_input_hidden(self, name, value): "Produces the HTML code for a hidden field " if isinstance(value, list): list_input = [self.tmpl_input_hidden(name, val) for val in value] return "\n".join(list_input) # # Treat `as', `aas' arguments specially: if name == 'aas': name = 'as' return """""" % { 'name' : cgi.escape(str(name), 1), 'value' : cgi.escape(str(value), 1), } def _add_mark_to_field(self, value, fields, ln, chars=1): """Adds the current value as a MARC tag in the fields array Useful for advanced search""" # load the right message language _ = gettext_set_language(ln) out = fields if value and str(value[0:chars]).isdigit(): out.append({'value' : value, 'text' : str(value) + " " + _("MARC tag") }) return out def tmpl_search_pagestart(self, ln) : "page start for search page. Will display after the page header" return """"""
def tmpl_search_pageend(self, ln) :
"page end for search page. Will display just before the page footer"
return """
""" % { 'prologue' : relevances_prologue, 'epilogue' : relevances_epilogue, 'relevance' : relevance } out += """
| %(founds)s | ||||
|---|---|---|---|---|
""" % {
'founds' : _("%(x_fmt_open)sResults overview:%(x_fmt_close)s Found %(x_nb_records)s records in %(x_nb_seconds)s seconds.") %\
{'x_fmt_open': '',
'x_fmt_close': '',
'x_nb_records': '' + self.tmpl_nice_number(results_final_nb_total, ln) + '',
'x_nb_seconds': '%.2f' % cpu_time}
}
# if there were (only) hosted_collections that timed out during the pre-search print out a fuzzier message
else:
if results_final_nb_total == 0:
out = """
|