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

'''
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 libs.migration.processor.check.check import moles3Append
from libs.migration.processor.commons import createDQ_Element
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

#molesDB = DbManager(MOLES3_DB_CONNECTION, MOLES3_DB_SCRIPT)

class Moles3EPB(EPB):

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

    @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 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 extractCollectionIdentifierByTitle(self, i_title, session = None):
        """
            Loooks 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 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):
            moles3Append(observationCollection, 'member', 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 addIdentifierToObservation(self, identifier, observation, session = None, commit = False):
        """
            Adds an identifier element to an Observation if still not assigned or not equal.
            @param identifier: 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 identifier in observation.identifier:
            #observation.identifier.append(identifier)
            moles3Append(observation, 'identifier', identifier)
        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)