def get_by_attribute(self, attribute):
"""
fetches one Value instance with the information of the given attribute
:param attribute: the attribute in context
:type attribute: Attribute
:returns : Value
"""
self.__set_class_by_attribute(attribute)
try:
clazz = self.get_broker_class()
result = self.session.query(clazz).filter(
clazz.attribute_id == attribute.identifier).one()
except sqlalchemy.orm.exc.NoResultFound:
raise NothingFoundException(
u'No value found with ID :{0} in {1}'.format(
attribute.identifier, self.get_broker_class()))
except sqlalchemy.orm.exc.MultipleResultsFound:
raise TooManyResultsFoundException(
'Too many value found for ID :{0} in {1}'.format(
attribute.identifier, self.get_broker_class()))
except sqlalchemy.exc.SQLAlchemyError as error:
raise BrokerException(error)
return result
def get_related_object_by_child_object_id(self, identifier):
try:
return self.session.query(RelatedObject).filter(RelatedObject.child_id == identifier).one()
except sqlalchemy.orm.exc.NoResultFound:
raise NothingFoundException('Nothing found with ID :{0} in {1}'.format(identifier, self.__class__.__name__))
except sqlalchemy.orm.exc.MultipleResultsFound:
raise TooManyResultsFoundException('Too many results found for ID :{0}'.format(identifier))
except sqlalchemy.exc.SQLAlchemyError as error:
raise BrokerException(error)
def get_by_id_and_event_id(self, identifier, event_id):
try:
result = self.session.query(Observable).filter(and_(Observable.identifier == identifier, Observable.event_id == event_id)).one()
except sqlalchemy.orm.exc.NoResultFound:
raise NothingFoundException('No observable found with ID :{0} in event with ID {1}'.format(identifier, event_id))
except sqlalchemy.orm.exc.MultipleResultsFound:
raise TooManyResultsFoundException('Too many results found for observable with ID {0} in event with ID {1}'.format(identifier, event_id))
except sqlalchemy.exc.SQLAlchemyError as error:
raise BrokerException(error)
return result
def get_by_name(self, name):
try:
result = self.session.query(Group).filter(Group.name == name).one()
return result
except sqlalchemy.orm.exc.NoResultFound:
raise NothingFoundException('Nothing found with name :{0}'.format(name))
except sqlalchemy.orm.exc.MultipleResultsFound:
raise TooManyResultsFoundException('Too many results found for name :{0}'.format(name))
except sqlalchemy.exc.SQLAlchemyError as error:
raise BrokerException(error)
def get_condition_by_value(self, value):
try:
if value == None:
value = 'Equals'
return self.session.query(Condition).filter(Condition.value == value).one()
except NoResultFound:
raise NothingFoundException('Nothing found with ID :{0} in {1}'.format(value, self.__class__.__name__))
except MultipleResultsFound:
raise TooManyResultsFoundException('Too many results found for ID :{0}'.format(value))
except SQLAlchemyError as error:
raise BrokerException(error)
def get_definition_by_name(self, name):
try:
return self.session.query(ReferenceDefinition).filter(
ReferenceDefinition.name == name).one()
except NoResultFound:
raise NothingFoundException(
'Nothing found with ID :{0} in {1}'.format(
name, self.__class__.__name__))
except MultipleResultsFound:
raise TooManyResultsFoundException(
'Too many results found for ID :{0}'.format(name))
except SQLAlchemyError as error:
raise BrokerException(error)
def get_user_by_api_key(self, api_key):
# check if api key exists
try:
result = self.session.query(User).filter(
User.api_key == api_key).one()
return result
except sqlalchemy.orm.exc.NoResultFound:
raise NothingFoundException(
u'Nothing found with apikey :{0}'.format(api_key))
except sqlalchemy.orm.exc.MultipleResultsFound:
raise TooManyResultsFoundException(
'Too many results found for apikey :{0}'.format(api_key))
except sqlalchemy.exc.SQLAlchemyError as error:
raise BrokerException(error)
def get_event_group_permissions(self, event, group):
try:
return self.session.query(EventGroupPermission).filter(
and_(EventGroupPermission.event_id == event.identifier,
EventGroupPermission.group_id == group.identifier)).one()
except sqlalchemy.orm.exc.MultipleResultsFound:
raise TooManyResultsFoundException(
'Too many results found for this cannot happen')
except sqlalchemy.orm.exc.NoResultFound:
raise NothingFoundException(
'Group {0} was not associated to event {1}'.format(
group.identifier, event.identifier))
except sqlalchemy.exc.SQLAlchemyError as error:
raise BrokerException(error)
def get_user_by_act_str(self, activation_str):
try:
result = self.session.query(User).filter(
User.activation_str == activation_str).one()
return result
except sqlalchemy.orm.exc.NoResultFound:
raise NothingFoundException(
u'Nothing found for activation_str {0}'.format(activation_str))
except sqlalchemy.orm.exc.MultipleResultsFound:
raise TooManyResultsFoundException(
'Too many results found for activation_str :{0}'.format(
activation_str))
except sqlalchemy.exc.SQLAlchemyError as error:
raise BrokerException(error)
def get_by_key(self, key):
"""
Returns a Ce1susConfig by it's key
"""
try:
return self.session.query(Ce1susConfig).filter(
Ce1susConfig.key == key).one()
except sqlalchemy.orm.exc.NoResultFound:
raise NothingFoundException(
u'Nothing found with key :{0}'.format(key))
except sqlalchemy.orm.exc.MultipleResultsFound:
raise TooManyResultsFoundException(
'Too many results found for key :{0}'.format(key))
except sqlalchemy.exc.SQLAlchemyError as error:
raise BrokerException(error)
def get_handler_by_id(self, identifier):
try:
result = self.session.query(ReferenceHandler).filter(
ReferenceHandler.identifier == identifier).one()
except NoResultFound:
raise NothingFoundException(
'Nothing found with ID :{0} in {1}'.format(
identifier, self.__class__.__name__))
except MultipleResultsFound:
raise TooManyResultsFoundException(
'Too many results found for ID :{0}'.format(identifier))
except SQLAlchemyError as error:
raise BrokerException(error)
return result
def get_type_by_name(self, name):
try:
for key, value in IndicatorType.get_dictionary().iteritems():
if value == name:
type_ = IndicatorType()
type_.type = key
return type_
raise NoResultFound
except NoResultFound:
raise NothingFoundException(
'Nothing found with ID :{0} in {1}'.format(
name, self.__class__.__name__))
except MultipleResultsFound:
raise TooManyResultsFoundException(
'Too many results found for ID :{0}'.format(name))
except SQLAlchemyError as error:
raise BrokerException(error)
def get_observable_by_id_and_parent_id(self, identifier, parent_id):
try:
# Returns an observable belonging to
result = self.session.query(Observable).join(
ObservableComposition.observables).filter(
and_(Observable.identifier == identifier,
ObservableComposition.parent_id == parent_id)).one()
except sqlalchemy.orm.exc.NoResultFound:
raise NothingFoundException(
'No observable found with ID :{0} in composed observable with ID {1}'
.format(identifier, parent_id))
except sqlalchemy.orm.exc.MultipleResultsFound:
raise TooManyResultsFoundException(
'Too many results found for observable with ID {0} in composed observable with ID {1}'
.format(identifier, parent_id))
except sqlalchemy.exc.SQLAlchemyError as error:
raise BrokerException(error)
return result
def get_by_observable_id(self, identifier):
try:
# TODO find a solution with one
result = self.session.query(ObservableComposition).join(
ObservableComposition.observables).filter(
Observable.identifier == identifier).all()
if result:
return result[0]
else:
raise sqlalchemy.orm.exc.NoResultFound()
except sqlalchemy.orm.exc.NoResultFound:
raise NothingFoundException(
'No composition found in observable with ID {0}'.format(
identifier))
except sqlalchemy.orm.exc.MultipleResultsFound:
raise TooManyResultsFoundException(
'Too many results found for observable with ID {0}'.format(
identifier))
except sqlalchemy.exc.SQLAlchemyError as error:
raise BrokerException(error)
def getUserByUsernameAndPassword(self, username, password, salt=None):
"""
Returns the user with the following username and password
Note: Password will be hashed inside this function
:param user: The username
:type user: Stirng
:param password: The username
:type password: Stirng
:returns: User
"""
if salt:
passwd = hashSHA1(password, salt)
old_pwd = hashSHA1(password + username)
else:
passwd = password
old_pwd = None
try:
if old_pwd:
user = self.session.query(User).filter(
User.username == username,
or_(
User.password == passwd,
User.password == old_pwd,
)).one()
else:
user = self.session.query(User).filter(
User.username == username, User.password == passwd).one()
except sqlalchemy.orm.exc.NoResultFound:
raise NothingFoundException(
u'Nothing found with ID :{0}'.format(username))
except sqlalchemy.orm.exc.MultipleResultsFound:
raise TooManyResultsFoundException(
u'Too many results found for ID ' + ':{0}'.format(username))
except sqlalchemy.exc.SQLAlchemyError as error:
self.session.rollback()
raise BrokerException(error)
return user
def get_defintion_by_name(self, name):
"""
Returns the attribute definition object with the given name
Note: raises a NothingFoundException or a TooManyResultsFound Exception
:param identifier: the id of the requested user object
:type identifier: integer
:returns: Object
"""
try:
definition = self.session.query(self.get_broker_class()).filter(getattr(self.get_broker_class(), 'name') == name).one()
return definition
except sqlalchemy.orm.exc.MultipleResultsFound:
raise TooManyResultsFoundException('Too many results found for name :{0}'.format(name))
except sqlalchemy.orm.exc.NoResultFound:
raise NothingFoundException(u'No {0} not found for {1}'.format(self.get_broker_class().__class__.__name__, name))
except sqlalchemy.exc.SQLAlchemyError as error:
self.session.rollback()
raise BrokerException(error)
def getUserByUserName(self, username):
"""
Returns the user with the following username
:param user: The username
:type user: Stirng
:returns: User
"""
try:
user = self.session.query(User).filter(
User.username == username).one()
except sqlalchemy.orm.exc.NoResultFound:
raise NothingFoundException(
u'Nothing found with username :{0}'.format(username))
except sqlalchemy.orm.exc.MultipleResultsFound:
raise TooManyResultsFoundException(u'Too many results found for' +
'ID :{0}'.format(username))
except sqlalchemy.exc.SQLAlchemyError as error:
self.session.rollback()
raise BrokerException(error)
return user
def __get_template(self, identifier):
"""
Returns the object by the given identifier
Note: raises a NothingFoundException or a TooManyResultsFound Exception
:returns: MailTemplate
"""
try:
result = self.session.query(MailTemplate).filter(
MailTemplate.name == identifier).one()
except NoResultFound:
raise NothingFoundException(
u'Nothing found for function_id :{0}'.format(identifier))
except MultipleResultsFound:
raise TooManyResultsFoundException(
'Too many results found for function_id :{0}'.format(
identifier))
except SQLAlchemyError as error:
raise BrokerException(error)
return result