def read(self, object_id):
existing_report = BenchmarkReport.query.filter(
BenchmarkReport.id == object_id).first()
if not existing_report:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(
BenchmarkReport, object_id))
return existing_report
def read(self, type_id):
existing_type = OrganisationType.query.filter(
OrganisationType.id == type_id).first()
if not existing_type:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(
OrganisationType, type_id))
return existing_type
def read(self, item_id):
existing_document = Document.query.filter(
Document.id == item_id).first()
if not existing_document:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(
Document, item_id))
return existing_document
def get_risk_factor(self, risk_factor_name):
risk_factor = RiskFactor.query.filter(
RiskFactor.risk_factor == risk_factor_name).first()
if risk_factor is None:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(
RiskFactor, risk_factor_name))
return risk_factor
def query_user_report_question(self, input_data):
"""
Return a question answer (which should be unique for this combination) for a specific question in
a specific user_report.
:param input_data:
:return:
"""
cleaned_data = {}
for key in self.possible_params:
if key in self.required_params and key != 'answer_id':
if key not in input_data:
raise RequiredAttributeMissing(
_e['attr_missing'].format(key))
cleaned_data[key] = input_data[key]
else:
if key not in input_data:
cleaned_data[key] = None
else:
cleaned_data[key] = input_data[key]
existing_question_answer = QuestionAnswer.query.filter(
and_(
QuestionAnswer.user_report_id ==
cleaned_data['user_report_id'],
QuestionAnswer.user_id == cleaned_data['user_id'],
QuestionAnswer.question_id ==
cleaned_data['question_id'])).first()
if existing_question_answer is None:
raise DatabaseItemDoesNotExist(
_('No QuestionAnswer with user_report_id %(user_report_id)s user_id %(user_id)s and question_id %(question_id)s',
user_report_id=cleaned_data['user_report_id'],
user_id=cleaned_data['user_id'],
question_id=cleaned_data['question_id']))
return existing_question_answer
def read(self, question_answer_id):
existing_question_answer = QuestionAnswer.query.filter(
QuestionAnswer.id == question_answer_id).first()
if existing_question_answer is None:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(
'QuestionAnswer', question_answer_id))
return existing_question_answer
def by_session_token(self, session_token):
existing_user = User.query.filter(
User.session_token == session_token).first()
if not existing_user:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(
User, session_token))
return existing_user
def by_menu_link(self, menu_link):
existing_menu_link = MenuLink.query.filter(
MenuLink.menu_link == menu_link).first()
if not existing_menu_link:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(
MenuLink, menu_link))
return existing_menu_link
def get_section(self, section_title, report_id):
existing_section = Section.query.filter(
and_(Section.title == section_title,
Section.report_id == report_id)).first()
if existing_section is None:
raise DatabaseItemDoesNotExist(_e['item_not_in'].format(
Section, section_title, Report, report_id))
return existing_section
def get_question(self, question_name, section_id):
existing_question = Question.query.filter(
and_(Question.question == question_name,
Question.section_id == section_id)).first()
if existing_question is None:
raise DatabaseItemDoesNotExist(_e['item_not_in'].format(
Question, question_name, Section, section_id))
return existing_question
def read(self, report_id):
"""
Get a report by its id. See QuestionApi.read()
:param report_id:
:return:
"""
existing_report = Report.query.filter(Report.id == report_id).first()
if existing_report is None:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(
Report, report_id))
return existing_report
def read(self, role_id):
"""
Get a role by its id
:param role_id:
:return:
"""
existing_role = Role.query.filter(Role.id == role_id).first()
if existing_role is None:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(
Role, role_id))
return existing_role
def read(self, user_id):
"""
Return a user by its id.
:param user_id:
:return:
"""
existing_user = User.query.filter(User.id == user_id).first()
if existing_user is None:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(
User, user_id))
return existing_user
def read(self, answer_id):
"""
Return an answer by its id. See QuestionApi.read()
:param answer_id:
:return:
"""
existing_answer = Answer.query.filter(Answer.id == answer_id).first()
if existing_answer is None:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(
Answer, answer_id))
return existing_answer
def get_by_user(self, user_name):
"""
Get a user by its user_name
:param user_name:
:return:
"""
existing_user = User.query.filter(User.username == user_name).first()
if existing_user is None:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(
User, user_name))
return existing_user
def by_menu_link_and_lang(self, menu_link, lang):
# Language
existing_lang = self.lang_api.by_lang(lang)
# Menu link
existing_menu_link = self.menu_link_api.by_menu_link(menu_link)
existing_page = Page.query.filter(and_(Page.menu_link_id == existing_menu_link.id,
Page.lang_id == existing_lang.id)).first()
if not existing_page:
raise DatabaseItemDoesNotExist(_('A page for menu_link {0} in language {1} does not exist.')
.format(menu_link, lang))
return existing_page
def query(self, input_data):
cleaned_data = self.parse_input_data(input_data)
existing_benchmark = Benchmark.query.filter(and_(
Benchmark.benchmark_report_id == cleaned_data['benchmark_report_id'],
Benchmark.question_id == cleaned_data['question_id']
)).first()
if not existing_benchmark:
raise DatabaseItemDoesNotExist(_('No benchmark with benchmark_report_id {0} and question_id {1}.').format(
cleaned_data['benchmark_report_id'],
cleaned_data['question_id']
))
return existing_benchmark
def read(self, risk_factor_id):
"""
Return a RiskFactor by its id. See QuestionApi.read()
:param risk_factor_id:
:return:
"""
existing_risk_factor = RiskFactor.query.filter(
RiskFactor.id == risk_factor_id).first()
if existing_risk_factor is None:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(
RiskFactor, risk_factor_id))
return existing_risk_factor
def read(self, question_id):
"""
Get a question from the database by its ID
:param question_id:
:return:
"""
existing_question = Question.query.filter(
Question.id == question_id).first()
if existing_question is None:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(
Question, question_id))
return existing_question
def query(self, question_question):
"""
Select a question by its name ("question"): this attribute is unique
:param question_question:
:return:
"""
existing_question = Question.query.filter(
Question.question == question_question).first()
if not existing_question:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(
Question, question_question))
return existing_question
def read(self, section_id):
"""
Return a section based on its id. See QuestionApi.read()
:param section_id:
:param section_data:
:return:
"""
existing_section = Section.query.filter(
Section.id == section_id).first()
if existing_section is None:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(
Section, section_id))
return existing_section
def get_answer_by_question_id(self, question_id, user_id, user_report_id):
"""
Get the answer to a question by its question_id in a specific report.
:param question_id:
:param user_id:
:param user_report_id:
:return:
"""
question_answer = QuestionAnswer.query.filter(
and_(QuestionAnswer.question_id == question_id,
QuestionAnswer.user_id == user_id,
QuestionAnswer.user_report_id == user_report_id)).first()
if question_answer is None:
raise DatabaseItemDoesNotExist(
_('No answer found for question %(question_id)s in report %(report_id)s',
question_id=question_id,
report_id=user_report_id))
return question_answer
def query(self, input_data):
"""
Query for a QuestionAnswer where question_id, answer_id, user_id and user_report_id equal the input.
Return QuestionAnswer or throw DatabaseItemDoesNotExist
:param input_data:
:return:
"""
cleaned_data = self.parse_input_data(input_data)
existing_question_answer = QuestionAnswer.query.filter(
and_(
QuestionAnswer.user_report_id ==
cleaned_data['user_report_id'],
QuestionAnswer.user_id == cleaned_data['user_id'],
QuestionAnswer.question_id == cleaned_data['question_id'],
QuestionAnswer.answer_id ==
cleaned_data['answer_id'])).first()
if existing_question_answer is None:
raise DatabaseItemDoesNotExist(
_('No QuestionAnswer with user_report_id %(user_report_id)s user_id %(user_id)s question_id %(question_id)s and answer_id %(answer_id)s',
user_report_id=cleaned_data['user_report_id'],
user_id=cleaned_data['user_id'],
question_id=cleaned_data['question_id'],
answer_id=cleaned_data['answer_id']))
return existing_question_answer
def get_by_role(self, input_role):
existing_role = Role.query.filter(Role.role == input_role).first()
if existing_role is None:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(
Role, input_role))
return existing_role
def get_answer(self, answer_name):
answer = Answer.query.filter(Answer.answer == answer_name).first()
if answer is None:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(
Answer, answer_name))
return answer
def by_api_key(self, api_key):
existing_user = User.query.filter(User.api_key == api_key).first()
if not existing_user:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(
User, api_key))
return existing_user
def read(self, report_id):
existing_user_report = UserReport.query.filter(UserReport.id == report_id).first()
if existing_user_report is None:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(UserReport, report_id))
return existing_user_report
def by_lang(self, lang):
existing_lang = Lang.query.filter(Lang.lang == lang).first()
if not existing_lang:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(
Lang, lang))
return existing_lang
def read(self, organisation_id):
existing_organisation = Organisation.query.filter(Organisation.id == organisation_id).first()
if not existing_organisation:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(Organisation, organisation_id))
return existing_organisation
def read(self, page_id):
existing_page = Page.query.filter(Page.id == page_id).first()
if not existing_page:
raise DatabaseItemDoesNotExist(_e['item_not_exists'].format(Page, page_id))
return existing_page