source: mauRepo/MolesManager/trunk/src/libs/migration/MigrationEPB.py @ 8323

'''
Created on 10 Jan 2012

@author: mnagni
'''
from libs.migration.db.classes import DeploymentDataMigration, DataEntityMigration,\
    DeploymentsMigration
from sqlalchemy.sql.expression import asc
from libs.epb import EPB
from libs.migration.exception.exceptions import NoDBManager
from libs.migration.processor.commons import stringToTimestamp
from sqlalchemy.orm.collections import InstrumentedList
from sqlalchemy.orm.util import identity_key


class MigrationEPB(EPB):
    
    _migrationDB = None
    
    @classmethod
    def overrrideDBManager(self, dbManager):
        """
            Sets the MigrationEPB libs.commons_db.DbManager
        """
        MigrationEPB._migrationDB = dbManager         
        
    @classmethod
    def persistInstance(self, instance, session = None):
        """
            Adds a new migration object.
            @param migrationObj: the migration object to add
            @param session: an SQLAlchemy Session object. If None (default) the method creates
            @return an updated, session independent, object instance reflecting the new persisted object 
        """      
        intSession = MigrationEPB._getSession(session)
        EPB.persistInstance(instance, intSession)
        if session is None:
            intSession.close()
        #return ret

    @classmethod
    def getAllDeploymentsMigrationByDataEntitySortedByDate(self, dataEntity, deploymentNames):
        intSession = MigrationEPB._getSession(None)
        res = EPB.getAllObjects(DeploymentsMigration, intSession).filter(DeploymentsMigration.doc_name.in_(deploymentNames)).order_by(asc("doc_creation")).all()
        intSession.close()
        return res
        #return EPB.getAllObjects(DeploymentsMigration, intSession).filter(*[EPB.buildFilter('doc_owner', dataEntity.doc_owner)]).filter(DeploymentsMigration.doc_name.in_(deploymentNames)).order_by(asc("doc_creation"))        
        #return EPB.getAllObjects(DeploymentsMigration, intSession).filter(*[EPB.buildFilter('doc_status', dataEntity.doc_status)]).filter(*[EPB.buildFilter('doc_owner', dataEntity.doc_owner)]).filter(DeploymentsMigration.doc_name.in_(deploymentNames)).order_by(asc("doc_creation"))

    @classmethod
    def _getMigrationObject(self, mo_type, doc_status, doc_owner, doc_name, session = None):
        intSession = MigrationEPB._getSession(session)
        return intSession.query(mo_type).filter(*[EPB.buildFilter('doc_name', doc_name)]).first()
        #return intSession.query(mo_type).filter(*[EPB.buildFilter('doc_owner', doc_owner)]).filter(*[EPB.buildFilter('doc_name', doc_name)]).first()        
        #return intSession.query(mo_type).filter(*[EPB.buildFilter('doc_status', doc_status)]).filter(*[EPB.buildFilter('doc_owner', doc_owner)]).filter(*[EPB.buildFilter('doc_name', doc_name)]).first()

    @classmethod
    def _getMigrationObjectByName(self, mo_type, migrationObject, doc_name, session = None):
        return self._getMigrationObject(mo_type, migrationObject.doc_status, migrationObject.doc_owner, doc_name, session)             

    @classmethod
    def getDeploymentsMigrationByName(self, migrationObject, doc_name, session = None):
        if migrationObject is None:
            raise Exception("migrationObject is None")
        return self._getMigrationObjectByName(DeploymentsMigration, migrationObject, doc_name, session)        

    @classmethod
    def getDeploymentDataMigrationByName(self, migrationObject, doc_name, session = None):
        if migrationObject is None:
            raise Exception("migrationObject is None")
        return self._getMigrationObjectByName(DeploymentDataMigration, migrationObject, doc_name, session)

    @classmethod
    def getDataEntityMigrationbyPath(self, migrationObject, session = None):
        """
            Returns the DataEntityMigration associated with the given path
            @param migrationObject: the migration object to look for. If None returns all the DataEntityMigration items
        """
        intSession = MigrationEPB._getSession(session)
        if migrationObject:
            ret = intSession.query(DataEntityMigration).filter(*[EPB.buildFilter('doc_name', migrationObject.doc_name)]).first()               
        else: #then process all the DataEntities
            ret = EPB.getAllObjects(DataEntityMigration, intSession)
        if session is None:
            intSession.close()                   
        return ret

    @classmethod        
    def updateMigrationObject(self, migration_object, cols_to_update, session = None):
        """
            Update and eventually commit a Migration Object in Migration db
            @param ceda_object: the Migration object to persist
            @param dict: a dictionary containing the columns to update for the given migration_object
            @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
        """
        intSession = MigrationEPB._getSession(session)
        coll = None
        try:
            coll = intSession.merge(migration_object)     
        except Exception as e:
            print e               
        if coll != None:        
            for k,v in cols_to_update.items():
                if hasattr(coll, k):
                    val = None
                    try:
                        val = intSession.merge(v)
                    except Exception:
                        val = v
                    coll_k = getattr(coll, k)                        
                    if type(coll_k) == list or type(coll_k) == InstrumentedList:
                        if  type(val) == list or type(val) == InstrumentedList:
                            coll_k.extend(val)
                        else:
                            coll_k.append(val)
                    else:
                        setattr(coll, k, val)
        EPB.persistInstance(coll, intSession)                        
        #intSession.commit()        
        if session is None:
            intSession.close()
        #if coll:
        #    return coll
            

    @classmethod
    def getNewMigrationSession(self):
        return MigrationEPB._getSession()

    @classmethod
    def loadAttributes(self, instance, attributes, session = None):
        """
            Returns the attribute of an instance. The parameter "attributes" is a single string or a list of attributes 
            owned by the instance of "clazz". Furthermore such list may contain 
            also the children of the main attributes. For example "attrs" may look 
            like
            ['resultAccumulation', 'identifier.authority', 'resultTime.position.dateTime8601.month', \
                      'relatedParty.party', 'result.source.function', 'permission', \
                      'geographicExtent', 'phenomenonTime', 'keywords', 'description', \
                      'inSupportOf.abstract', 'dataLineage']
            the first parameter refers to the main class so is equivalent to 
            clazz.resultAccumulation
            the second parameter is equivalent to invoke
            clazz.identifier.authority
            As single string "attributes" could be as well just 'identifier.authority'
            @param instance: an instance containing the appropriate id
            @param attributes: the attribute value required
            @param session: the session to use for the operation
            @return: a detached instance (or array of instances) of the required attribute.                     
        """
        intSession = MigrationEPB._getSession(session)
        instance = intSession.merge(instance)
        EPB.loadAttributes(instance, attributes, session)        
        if session is None:
            intSession.close()                
        return instance  

    @classmethod
    def search(self, clazz, inst_id, session = None):
        if clazz is None or inst_id is None:
            return None 
        intSession = MigrationEPB._getSession(session)
        ret = EPB.search(clazz, inst_id, intSession)
        if session is None:
            intSession.close()
        return ret 
         

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