def test_current_authentication(self): from camelot.model.authentication import get_current_authentication authentication = get_current_authentication() # current authentication cache should survive # a session expire + expunge orm.object_session(authentication).expire_all() orm.object_session(authentication).expunge_all() authentication = get_current_authentication() self.assertTrue(authentication.username) self.assertTrue(unicode(authentication))
def test_current_authentication(self): from camelot.model.authentication import get_current_authentication authentication = get_current_authentication() # current authentication cache should survive # a session expire + expunge orm.object_session(authentication).expire_all() orm.object_session(authentication).expunge_all() authentication = get_current_authentication() self.assertTrue(authentication.username)
def flush(self, entity_instance): """Flush the pending changes of this entity instance to the backend""" from sqlalchemy.orm.session import Session session = Session.object_session( entity_instance ) if session: modifications = {} try: modifications = self.get_modifications( entity_instance ) except Exception, e: # todo : there seems to be a bug in sqlalchemy that causes the # get history to fail in some cases logger.error( 'could not get modifications from object', exc_info = e ) session.flush( [entity_instance] ) # # If needed, track the changes # primary_key = self.primary_key( entity_instance ) if modifications and (primary_key != None) and len(primary_key)==1: from camelot.model.memento import Memento # only register the update when the camelot model is active if hasattr(Memento, 'query'): from camelot.model.authentication import get_current_authentication history = Memento( model = unicode( self.entity.__name__ ), memento_type = 'before_update', primary_key = primary_key[0], previous_attributes = modifications, authentication = get_current_authentication() ) try: history.flush() except exc.DatabaseError, e: self.logger.error( 'Programming Error, could not flush history', exc_info = e )
def test_memento(self): from camelot.model import memento from camelot.model.authentication import get_current_authentication m = memento.Memento(primary_key=1, model='TestCase', authentication=get_current_authentication(), memento_type=1, previous_attributes={'name': u'memento'}) self.assertTrue(m.previous)
def test_memento( self ): from camelot.model import memento from camelot.model.authentication import get_current_authentication m = memento.Memento( primary_key = 1, model = 'TestCase', authentication = get_current_authentication(), memento_type = 1, previous_attributes = {'name':u'memento'} ) self.assertTrue( m.previous )
def get_state(self, model_context): from camelot.model.authentication import get_current_authentication from camelot.view import art state = super(Authentication, self).get_state(model_context) authentication = get_current_authentication() state.verbose_name = authentication.username state.tooltip = ', '.join([g.name for g in authentication.groups]) representation = authentication.get_representation() if representation is not None: state.icon = art.IconFromImage(representation) return state
def model_run(self, model_context): from camelot.model.authentication import get_current_authentication from camelot.view import action_steps from camelot.view.controls.editors.imageeditor import ImageEditor select_file = action_steps.SelectFile( file_name_filter=ImageEditor.filter) filenames = yield select_file for filename in filenames: yield action_steps.UpdateProgress(text=ugettext('Scale image')) image = QtGui.QImage(filename) image = image.scaled(self.image_size, self.image_size, Qt.KeepAspectRatio) authentication = get_current_authentication() authentication.set_representation(image) yield action_steps.FlushSession(model_context.session)
def delete(self, entity_instance): """Delete an entity instance""" from sqlalchemy.orm.session import Session session = Session.object_session( entity_instance ) # # new and deleted instances cannot be deleted # if session: if entity_instance in session.new: session.expunge(entity_instance) elif (entity_instance not in session.deleted) and \ (entity_instance in session): # if the object is not in the session, it might already be deleted history = None # # only if we know the primary key, we can keep track of its history # primary_key = self.mapper.primary_key_from_instance(entity_instance) # # we can only store history of objects where the primary key has only # 1 element # @todo: store history for compound primary keys # if not None in primary_key and len(primary_key)==1: pk = primary_key[0] # save the state before the update from camelot.model.memento import Memento # only register the delete when the camelot model is active if hasattr(Memento, 'query'): from camelot.model.authentication import get_current_authentication history = Memento( model = unicode( self.entity.__name__ ), memento_type = 'before_delete', primary_key = pk, previous_attributes = {}, authentication = get_current_authentication() ) entity_instance.delete() session.flush( [entity_instance] ) if history: Session.object_session( history ).flush( [history] )
def _get_authentication_id( self ): """:return: the id to store in the memento table""" from camelot.model.authentication import get_current_authentication return get_current_authentication().id
def _get_authentication_id( self ): """:return: the id to store in the memento table""" from camelot.model.authentication import get_current_authentication return get_current_authentication().id