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

'''
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 sqlalchemy.orm.collections import InstrumentedList


class MigrationEPBFactory(EPB):
    
    def __init__(self, dbManager):
        self._dbManager = dbManager

    def _getSession(self):
        if self._dbManager is not None:
            return self._dbManager.createDbSession()                
        return None
        
    def createEPB(self):
        return MigrationEPB(self._getSession())
        
        
class MigrationEPB(object):
            
    def __init__(self, session):
        self._session = session            

    def close(self):
        return self._session.close()
            
    def persistInstance(self, instance):
        """
            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 
        """      
        EPB.persistInstance(instance, self._session)
        #return ret

    def getAllDeploymentsMigrationByDataEntitySortedByDate(self, dataEntity, deploymentNames):
        return EPB.getAllObjects(DeploymentsMigration, self._session).filter(DeploymentsMigration.doc_name.in_(deploymentNames)).order_by(asc("doc_creation")).all()
        #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"))

    def _getMigrationObject(self, mo_type, doc_status, doc_owner, doc_name):
        return self._session.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()

    def _getMigrationObjectByName(self, mo_type, migrationObject, doc_name):
        return self._getMigrationObject(mo_type, migrationObject.doc_status, migrationObject.doc_owner, doc_name)             

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

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

    def getDataEntityMigrationbyPath(self, migrationObject):
        """
            Returns the DataEntityMigration associated with the given path
            @param migrationObject: the migration object to look for. If None returns all the DataEntityMigration items
        """
        ret = []
        if migrationObject:
            ret.append(self._session.query(DataEntityMigration).filter(*[EPB.buildFilter('doc_name', migrationObject.doc_name)]).first())               
        else: #then process all the DataEntities
            res = self._session.query(DataEntityMigration).all()
            for item in res:
                ret.append(item)              
        return ret
     
    def updateMigrationObject(self, migration_object, cols_to_update):
        """
            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
        """
        coll = None
        try:
            coll = self._session.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 = self._session.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)
        self._session.add(coll)
        self._session.commit()                            

    def search(self, clazz, inst_id):
        if clazz is None or inst_id is None:
            return None 
        ret = EPB.search(clazz, inst_id, self._session)
        return ret