source: ndgCommon/trunk/ndg/common/src/clients/xmldb/eXist/searchclient.py @ 4923

'''
 Basic search client for eXist XML DBs
 
 @author: C Byrom - Tessella, Feb 09
'''
from ndg.common.src.clients.xmldb.abstractsearchxmldbclient import AbstractSearchXMLDBClient
from ndg.common.src.lib.utilities import loadConfigDetails
from xml.etree import cElementTree as ET
import dbconstants as dc
import logging, os
from xmlrpcclient import XMLRPCClient


class SearchClient(AbstractSearchXMLDBClient):
    
    def __init__(self, dbHostName = 'chinook.badc.rl.ac.uk', 
                 configFileName ='passwords.txt', 
                 clientType = dc.XML_RPC_CLIENT):
        '''
        Set up a search client for eXist DB
        @keyword db: eXist host to use - defaults to 'chinook.badc.rl.ac.uk'
        @keyword configFileName : password file to use - NB, this should
        have contents of format (NB, space delimiter):
        dbName userID password 
        Default is 'passwords.txt'.
        @keyword clientType: Type of client to use for eXist connection.  Currently
        only supported by 'xmlrpc' - which is the default.
        '''
        logging.debug("Initialising SearchClient")
        self.setupDBConnection(dbHostName, configFileName, clientType)
        logging.debug("SearchClient initialised")


    def setupDBConnection(self, dbName, pwFilename, clientType):
        '''
        Establish connection to eXist DB - using the specified DB name and
        password file
        @param dbName: hostname of the eXist DB
        @param pwFilename: name of file with password details - NB, this should
        have contents of format (NB, space delimiter):
        dbName userID password 
        @param clientType: Type of client to use for eXist connection.  Currently
        only supported by 'xmlrpc' - which is the default.
        @raise ValueError: if unrecognised eXist client type specified
        '''
        logging.debug("Initialising connection to eXist DB ('%s')" %dbName)
        userID, password, host = loadConfigDetails(pwFilename, dbName)
        
        if clientType == dc.XML_RPC_CLIENT:
            self.client = XMLRPCClient(dbName, userID, password)
        else:
            raise ValueError("Unrecognised eXist client type: '%s'" %clientType)
        
        logging.debug("Connection set up")


    def getDocs(self, documents, format='original'):
        ''' 
        Return one or more complete document
        @param documents: array of documents to retrieve
        @keyword format: format the retrieved document should be in.  Default, 'original'
        returns documents in their original format. NB, not currently implemented.
        @raise ValueError if the requested document(s) cannot be found
        @return: dictionary with format, {docName: docContents}
        '''
        logging.info("Getting docs, %s, from eXist DB..." %documents)
        results = {}
        for doc in documents:
            # avoid duplicate lookups
            if doc not in results.keys():
                
                # NB, invalid doc paths won't return anything - so ignore these
                res = self.client.getDoc(doc)
                if res:
                    results[doc] = res
        logging.info("Returning dict with docs in")
        return results

        
    def search(self, term, start=1, howmany=20, \
               target=None,scope=None,bbox=None, \
               dateRange=None,geoSearchType=None, \
               providerID=None, atomTypeID=None,
               useChunked = True):
        ''' 
        Provides a search interface that mimics the WSDL search interface, except 
        that the target used is the exist collection name, and scope, bbox and 
        dateRange are ignored, and a python summary object is returned 
        '''

        #select the right query according to the docType requested
        if target == self.ATOM_TARGET:
            xquery = self.__createAtomSearch(providerID, atomTypeID, term)
        else:
            xqName={'ndg_B_metadata':'molesSummary',\
                'NumSim':'numsimSummary'}[target]
            xquery= self.resources.xq[xqName]
            xquery=xquery.replace('SEARCHSTRING',term)
        
        logging.info("Executing xquery search")
        logging.debug(" - query: '%s'" %xquery)

        results = self.client.runQuery(xquery, offset=start - 1, noResults = howmany, 
                                       useChunked = useChunked)
        logging.info("Search complete - processing results")

        self.serverSessionID = ''
        
        self.results = []
        if not results:
            errorMessage = 'No results for [%s]'%term
            logging.info(errorMessage)
            self.hits=0
            self.start=0
            self.howmany=0
            self.error=[errorMessage]
            return self.results
        
        self.hits = len(results)
        self.error = None
        self.start = start
        self.howmany = howmany
        
        for result in results:
            s = ET.fromstring(result)
            t = {'id': s.find('id').text,
                 'name': s.find('name').text,
                 'type': s.find('type').text}

            # add extra stuff for atom search (NB, this could be added to all
            # but am unsure of implications elsewhere atm
            if target == self.ATOM_TARGET:
                for key in ['providerID', 'created', 'href', 'subtype']:
                    t[key] = s.find(key).text

                    # adjust href to point to atom editor instead of atom view
                    if key == 'href' and t[key]:
                        t[key] = t[key].replace('view', 'editAtom')
                        
                    if key == 'subtype':
                        t[key] = t[key]
                
            self.results.append(t)
        return self.results
    

    def __createAtomSearch(self, providerID, atomTypeID, term):
        '''
        Create a valid xquery search for searching atoms
        '''
        logging.debug("Creating xquery for searching atoms")
        logging.debug("providerID: '%s', atomTypeID: '%s', term: '%s'" 
                      %(providerID, atomTypeID, term))
        xquery = "declare namespace moles='http://ndg.nerc.ac.uk/schema/moles2beta';\n" + \
            "declare namespace atom='http://www.w3.org/2005/Atom';\n" + \
            "for $DE in collection('/db/atoms')/atom:entry["

        # only add the required search clauses - NB, these increase the search time
        # significantly, so avoid unless really required
        whereClause = []
        if term:
            whereClause.append(". &= '" + term + "'")
        
        if providerID and providerID != self.DEFAULT_ALL_VAL:
            whereClause.append("moles:entity/moles:molesISO/moles:providerID = '" + providerID + "'")
        
        if atomTypeID and atomTypeID != self.DEFAULT_ALL_VAL:
            whereClause.append("atom:category/@label = '" + atomTypeID + "'")
            
        if not whereClause:
            whereClause.append(".")
        
        for i, clause in enumerate(whereClause):
            if i > 0:
                xquery += " and "
            xquery += clause
            
        xquery += "] return <summary> \
<id>{$DE/atom:id/text()}</id> \
<name>{$DE/atom:title/text()}</name> \
<type>{string($DE/atom:category[@term='ATOM_TYPE']/@scheme)}</type> \
<subtype>{string($DE/atom:category[@term='ATOM_SUBTYPE']/@scheme)}</subtype> \
<href>{string($DE/atom:link[@rel='self']/@href)}</href> \
<providerID>{$DE/moles:entity/moles:molesISO/moles:providerID/text()}</providerID> \
<created>{$DE/moles:entity/moles:molesISO/moles:created/text()}</created> \
</summary>"

        logging.debug("Created xquery: '%s'" %xquery)
        return xquery