source: mauRepo/MolesManager/trunk/src/MolesManager/moles3epb.py @ 8264

'''
Created on 10 Jan 2012

@author: mnagni
'''
from libs.epb import EPB
from libs.migration.exception.exceptions import NoDBManager
from ea_model.ceda_metadatamodel.ceda_observationcollection.ceda_observationcollection import CEDA_ObservationCollection
from ea_model.ceda_metadatamodel.ceda_observation.ceda_observation import CEDA_Observation
from ea_model.iso_19115_2006_metadata_corrigendum.reference_system_information.md_identifier import MD_Identifier
from ea_model.iso_19115_2006_metadata_corrigendum.citation_and_responsible_party_information.ci_citation import CI_Citation
from ea_model.moles3_4.observationcollection.mo_observationcollection import MO_ObservationCollection
from ea_model.moles3_4.observation.mo_observation import MO_Observation
from ea_model.ceda_metadatamodel.ceda_project.ceda_project import CEDA_Project
from sqlalchemy import Table, Column, ForeignKey, Integer, String
from sqlalchemy.orm import mapper
from MolesManager.ceda_guid import CedaGUID


class Moles3EPB(EPB):

    _molesDB = None
   
    @classmethod
    def overrrideDBManager(self, dbManager):
        """
            Sets the MigrationEPB libs.commons_db.DbManager
        """
        Moles3EPB._molesDB = dbManager
        Moles3EPB._initCEDA_Customization()

    @classmethod
    def _initCEDA_Customization(self):
        Moles3EPB._associateCEDA_GUID()
        Moles3EPB._initSearchIndexes()        
        
    @classmethod
    def _associateCEDA_GUID(self):
        guid_table = Table('ceda_guid', Moles3EPB._molesDB.metadata, \
                           Column('id', String, primary_key=True), \
                           Column('ceda_observationcollection', Integer, ForeignKey('ceda_observationcollection.id')), 
                           Column('ceda_observation', Integer, ForeignKey('ceda_observation.id')))
        mapper(CedaGUID, guid_table)
        Moles3EPB._molesDB.metadata.create_all()

    @classmethod
    def _initSearchIndexes(self):
        #To Be Done - CHECK IF THE COLUMN ALREADY EXISTS!
        # We don't want sqlalchemy to know about this column so we add it externally.
        try:
            Moles3EPB._molesDB.engine.execute("alter table md_identifier add column code_search_vector tsvector")                 

            # This indexes the tsvector column

            Moles3EPB._molesDB.engine.execute("create index md_identifier_code_search_index on md_identifier using gin(code_search_vector)")

            # This sets up the trigger that keeps the tsvector column up to date.
            Moles3EPB._molesDB.engine.execute("create trigger md_identifier_code_search_update before update or insert on md_identifier \
                for each row execute procedure tsvector_update_trigger('code_search_vector', 'pg_catalog.english', code)")                        
        except Exception as e:
            pass

    @classmethod        
    def search(self, clazz, inst_id, session = None):
        intSession = Moles3EPB._getSession(session)
        return EPB.search(clazz, inst_id, intSession)

    @classmethod        
    def searchEager(self, clazz, inst_id, session = None):
        intSession = Moles3EPB._getSession(session)
        return EPB.searchEager(clazz, inst_id, intSession)

    @classmethod        
    def addCedaObject(self, ceda_observation, session = None, commit = False):
        """
            Adds and eventually commit a CEDA Object in MOLES3 db
            @param ceda_observation: the CEDA object to persist
            @param session: the external session to use. If None a new session will be open to add and commit the object and then closed at the exit. The object is committed
            @param commit: defines if the object has to be committed immediately or not.
        """
        intSession = Moles3EPB._getSession(session)
        intSession.add(ceda_observation)
        if commit:
            intSession.commit()
        #Moles3EPB._closeSession(session) 

    @classmethod
    def retrieveGUIDFromInstance(self, instance, session = None):
        """
            Returns the CedaGUID object associated with the given instance.
            @param instance: an instance of CEDA_Observation os CEDA_ObservationCollection  
        """
        intSession = Moles3EPB._getSession(session)
        if instance is None:
            return None
        if type(instance) == CEDA_ObservationCollection:
            return intSession.query(CedaGUID).filter(CedaGUID.ceda_observationcollection==instance.id).first()
        elif type(instance) == CEDA_Observation:
            return intSession.query(CedaGUID).filter(CedaGUID.ceda_observation==instance.id).first()
            
    
    @classmethod
    def observationCollectionHasObservation(self, obs_coll_id, obs_id, session = None):
        """
            Checks if a CEDA_Collection contains a given CEDA_Observation.
            @param obs_coll_id: the CEDA_ObservationColleciton id
            @param obs_id: the CEDA_Observation id
            @return: True if the collection contains the given observation, False otherwise  
        """
        intSession = Moles3EPB._getSession(session)
        return intSession.query(CEDA_ObservationCollection, CEDA_Observation).filter(CEDA_ObservationCollection.id==obs_coll_id).filter(CEDA_Observation.id==obs_id).count() > 0

    @classmethod
    def extractObservationByTitleKeywords(self, keywords, session = None):
        """
            Loooks for CEDA_Observation containing a specific title (observation.identifier.code)
            @param keywords: a space separated terms string
            @return: a tuple containing a CEDA_Observation satisfying the queryllection.idenfitier element having the title  
        """                
        intSession = Moles3EPB._getSession(session)
        # search_vector is a ts_vector column. To search for terms, you use the 
        # @@ operator. plainto_tsquery turns a string into a query that can be 
        # used with @@. So this adds a where clause like "WHERE search_vector 
        # @@ plaint_tsquery(<search string>)"
        q = intSession.query(CEDA_Observation). \
            join(MO_Observation).join(MO_ObservationCollection.identifier). \
            filter('md_identifier.code_search_vector @@ to_tsquery(:terms)')
        # This binds the :terms placeholder to the searchterms string. User input 
        # should always be put into queries this way to prevent SQL injection.
        q = q.params(terms=keywords)
        return q


    @classmethod
    def extractCollectionIdentifierByTitle(self, i_title, session = None):
        """
            Searches for an MD_Identifier from a CEDA_ObservationCollection contains a specific title (observation.identifier.code)
            @param i_title: the CEDA_ObservationCollection.identifier.title value to search for
            @return: a tuple containing a CEDA_ObservationCollection and the CEDA_ObservationCollection.idenfitier element having the title  
        """
        intSession = Moles3EPB._getSession(session)
        return intSession.query(CEDA_ObservationCollection, MD_Identifier). \
            join(MO_ObservationCollection).join(MO_ObservationCollection.identifier). \
            join(MD_Identifier.authority).filter(CI_Citation.title.like('%' + i_title + '%'))

    @classmethod
    def extractObservationsForProject(self, project, session = None):
        """
            Searches for the CEDA_Observation associated with a CEDA_Project
            @param project: a CEDA_Project instance
            @return: a tuple containing the associated CEDA_Observation  
        """
        intSession = Moles3EPB._getSession(session)
        return intSession.query(CEDA_Observation). \
            join(CEDA_Observation, MO_Observation.inSupportOf).filter(CEDA_Project.id == project.id)

    @classmethod
    def extractProjectObservationCollections(self, project, session = None):
        """
            Searches for the Observation_Collections associated with a CEDA_Project
            @param project: a CEDA_Project instance
            @return: a tuple containing the associated CEDA_ObservationCollection  
        """
        intSession = Moles3EPB._getSession(session)
        mo_obs = intSession.query(MO_Observation).join(CEDA_Project).filter(CEDA_Project.id == project.id).subquery()      
        obsers = intSession.query(CEDA_Observation).join(mo_obs, CEDA_Observation.id == mo_obs.c.id).one()
        #print "obsers: " + str(intSession.query(CEDA_Observation).join(mo_obs, CEDA_Observation.id == mo_obs.c.id).count())
        
        cos = intSession.query(CEDA_ObservationCollection).all()
        co = intSession.query(MO_ObservationCollection).join(MO_ObservationCollection.member).filter(MO_ObservationCollection.member.contains(obsers))
        print co
        print co.all()
        
        observations = intSession.query(MO_ObservationCollection).join(CEDA_Observation). \
            filter(obsers.any(CEDA_Observation.id==obsers.c.id))
        print "observation:" + str(observations.count())
        return observations

    @classmethod
    def addObservationToObservationCollection(self, observationCollection, observation, session = None, commit = False):
        """
            Adds an Observation instance to an ObservationCollection if still not part of the collection.
            @param observationCollection: the collection to update
            @param observation: the observation to add
            @param session: the session to use for the operation
            @param commit: if True commits at the end (defaul False) 
        """
        intSession = Moles3EPB._getSession(session)
        if not self.observationCollectionHasObservation(observationCollection.id, observation.id, intSession):
            observationCollection.member.append(observation)
            if commit:
                intSession.commit()
    
    @classmethod
    def addDataLineageToObservation(self, data_lineage, observation, session = None, commit = False):
        """
            Adds an data_lineage element to an Observation if still not assigned or not equal.
            @param data_lineage: the quality string to persist
            @param observation: the observation to update
            @param session: the session to use for the operation
            @param commit: if True commits at the end (defaul False) 
        """        
        intSession = Moles3EPB._getSession(session)
        if observation.dataLineage != data_lineage:
            observation.dataLineage = data_lineage
        if commit:
            intSession.commit()                

    @classmethod
    def addDescriptionToObservation(self, description, observation, session = None, commit = False):
        """
            Adds an description element to an Observation if still not assigned or not equal.
            @param description: the description string to persist
            @param observation: the observation to update
            @param session: the session to use for the operation
            @param commit: if True commits at the end (defaul False) 
        """        
        intSession = Moles3EPB._getSession(session)
        if observation.description != description:
            observation.description = description
        if commit:
            intSession.commit()

    @classmethod
    def addRelatedPartyInfoToObservation(self, responsibleParty, observation, session = None, commit = False):
        """
            Adds a relatedParty element to an Observation if still not assigned or not equal.
            @param responsibleParty: the responsibleParty element to persist
            @param observation: the observation to update
            @param session: the session to use for the operation
            @param commit: if True commits at the end (defaul False) 
        """          
        intSession = Moles3EPB._getSession(session)
        if not responsibleParty in observation.relatedParty:
            observation.relatedParty.append(responsibleParty)                           
            #moles3Append(observation, 'relatedParty', responsibleParty)
        if commit:
            intSession.commit()


    @classmethod        
    def getNewMolesSession(self):
            return Moles3EPB._getSession()

    @classmethod
    def executeNative(self, sqlNative, session = None):
        intSession = Moles3EPB._getSession(session)
        return EPB.executeNative(sqlNative, intSession)  

    @classmethod
    def _getSession(self, session = None):
        if Moles3EPB._molesDB is None:
            raise NoDBManager("Moles3EPB")
        return EPB._getSession(Moles3EPB._molesDB, session)