def _serialize_review_form(review_form, language):
review_questions = []
for question in review_form.review_questions:
translation = question.get_translation(language)
if translation is None:
LOGGER.warn(
'Missing {} translation for review question id {}'.format(
language, question.id))
translation = question.get_translation('en')
review_questions.append({
'id': question.id,
'question_id': question.question_id,
'description': translation.description,
'headline': translation.headline,
'type': question.type,
'placeholder': translation.placeholder,
'options': translation.options,
'is_required': question.is_required,
'order': question.order,
'validation_regex': translation.validation_regex,
'validation_text': translation.validation_text,
'weight': question.weight
})
form = {
'id': review_form.id,
'application_form_id': review_form.application_form_id,
'is_open': review_form.is_open,
'deadline': review_form.deadline.isoformat(),
'review_questions': review_questions
}
return form
def get(self):
args = self.req_parser.parse_args()
try:
event = db.session.query(Event).filter(Event.id == args['event_id']).first()
if not event:
LOGGER.warn("Event not found for event_id: {}".format(args['event_id']))
return errors.EVENT_NOT_FOUND
form = db.session.query(ApplicationForm).filter(ApplicationForm.event_id == args['event_id']).first()
if not form:
LOGGER.warn("Form not found for event_id: {}".format(args['event_id']))
return errors.FORM_NOT_FOUND
# Get the latest response (note there may be older withdrawn responses)
response = db.session.query(Response).filter(
Response.application_form_id == form.id, Response.user_id == g.current_user['id']
).order_by(Response.started_timestamp.desc()).first()
if not response:
LOGGER.debug("Response not found for event_id: {}".format(args['event_id']))
return errors.RESPONSE_NOT_FOUND
answers = db.session.query(Answer).filter(Answer.response_id == response.id).all()
response.answers = list(answers)
return response
except SQLAlchemyError as e:
LOGGER.error("Database error encountered: {}".format(e))
return errors.DB_NOT_AVAILABLE
except:
LOGGER.error("Encountered unknown error: {}".format(traceback.format_exc()))
return errors.DB_NOT_AVAILABLE
def send_confirmation(self, user, questions, answers, confirmed, event_name):
if answers is None:
LOGGER.warn(
'Found no answers associated with response with id {response_id}'.format(response_id=user.id))
if questions is None:
LOGGER.warn(
'Found no questions associated with application form with id {form_id}'.format(form_id=user.id))
try:
# Building the summary, where the summary is a dictionary whose key is the question headline, and the value
# is the relevant answer
summary = ""
for answer in answers:
for question in questions:
if answer.registration_question_id == question.id:
summary += "Question heading :" + question.headline + "\nQuestion Description :" + \
question.description + "\nAnswer :" + _get_answer_value(
answer, question) + "\n"
subject = event_name + ' Registration'
greeting = strings.build_response_email_greeting(
user.user_title, user.firstname, user.lastname)
if len(summary) <= 0:
summary = '\nNo valid questions were answered'
body_text = greeting + '\n\n' + REGISTRATION_MESSAGE + \
self.get_confirmed_message(
confirmed) + '\n\nHere is a copy of your responses:\n\n' + summary
emailer.send_mail(user.email, subject, body_text=body_text)
except Exception as e:
LOGGER.error('Could not send confirmation email for response with id : {response_id}'.format(
response_id=user.id))
def send_confirmation(self, user, questions, answers, confirmed, event):
if answers is None:
LOGGER.warn(
'Found no answers associated with response with id {response_id}'
.format(response_id=user.id))
if questions is None:
LOGGER.warn(
'Found no questions associated with application form with id {form_id}'
.format(form_id=user.id))
try:
# Building the summary, where the summary is a dictionary whose key is the question headline, and the value
# is the relevant answer
summary = ""
for answer in answers:
for question in questions:
if answer.registration_question_id == question.id:
summary += "Question:" + question.headline + "\nAnswer:" + _get_answer_value(
answer, question) + "\n"
emailer.email_user('registration-with-confirmation' if confirmed
else 'registration-pending-confirmation',
template_parameters=dict(summary=summary),
event=event,
user=user)
except Exception as e:
LOGGER.error(
'Could not send confirmation email for response with id : {response_id}'
.format(response_id=user.id))
def get(self):
LOGGER.debug('Received get request for camera')
args = self.req_parser.parse_args()
LOGGER.debug('Parsed Args for site_id: {}'.format(args))
try:
site = db.session.query(Site).filter(
Site.id == args['site_id']).first()
if (not site):
LOGGER.warn('Site not found for site_id: {}'.format(
args['site_id']))
return SITE_NOT_FOUND
cameras = db.session.query(Camera).filter(
Camera.site_id == site.id).all() #All cameras at our site
if (not cameras):
LOGGER.warn(
'No cameras found for site with site_id: {}'.format(
args['site_id']))
return CAMERA_NOT_FOUND
for camera in cameras:
cv2.VideoCapture(camera.ip_address).read()
except SQLAlchemyError as e:
LOGGER.error("Database error encountered: {}".format(e))
return DB_NOT_AVAILABLE
except:
LOGGER.error("Encountered unknown error: {}".format(
traceback.format_exc()))
return DB_NOT_AVAILABLE
def _serialize_tag(tag, language):
tag_translation = tag.get_translation(language)
if not tag_translation:
LOGGER.warn('Could not find {} translation for tag id {}'.format(
language, tag.id))
tag_translation = tag.get_translation('en')
return {'id': tag.id, 'name': tag_translation.name}
def send_confirmation(self, user, questions, answers, event_name):
if answers is None:
LOGGER.warn(
'Found no answers associated with response with id {response_id}'
.format(response_id=user.id))
if questions is None:
LOGGER.warn(
'Found no questions associated with application form with id {form_id}'
.format(form_id=user.id))
try:
# Building the summary, where the summary is a dictionary whose key is the question headline, and the value
# is the relevant answer
summary = ""
for answer in answers:
for question in questions:
if answer.registration_question_id == question.id:
summary += "Question heading :" + question.headline + "\nQuestion Description :" + \
question.description + "\nAnswer :" + _get_answer_value(
answer, question) + "\n"
subject = event_name + ' Registration'
greeting = strings.build_response_email_greeting(
user.user_title, user.firstname, user.lastname)
if len(summary) <= 0:
summary = '\nNo valid questions were answered'
body_text = greeting + '\n\n' + 'Thank you for completing your guest registration. Please find a copy of your answers below for future reference.' + '\n\n' + summary + '\n\nKind Regards, The Deep Learning Indaba Team'
emailer.send_mail(user.email, subject, body_text=body_text)
return True
except Exception as e:
LOGGER.error(
'Could not send confirmation email for response with id : {response_id}'
.format(response_id=user.id))
return False
def _serialize_tag(tag, language):
"""Serialize a tag in a specific language."""
translation = tag.get_translation(language)
if translation is None:
LOGGER.warn(
'Could not find translation for language {} for tag id {}'.format(
language, tag.id))
translation = tag.get_translation('en')
return {'id': tag.id, 'event_id': tag.event_id, 'name': translation.name}
def _serialize_question(question, language):
translation = question.get_translation(language)
if not translation:
LOGGER.warn('Could not find {} translation for question id {}'.format(
language, question.id))
translation = question.get_translation('en')
return dict(question_id=question.id,
headline=translation.headline,
type=question.type)
def put(self):
# Update an existing response for the logged-in user.
req_parser = reqparse.RequestParser()
req_parser.add_argument('id', type=int, required=True)
req_parser.add_argument('is_submitted', type=bool, required=True)
req_parser.add_argument('application_form_id', type=int, required=True)
req_parser.add_argument('answers', type=list, required=True, location='json')
args = req_parser.parse_args()
user_id = g.current_user['id']
try:
old_response = db.session.query(Response).filter(Response.id == args['id']).first()
if not old_response:
LOGGER.error("Response not found for id {}".format(args['id']))
return errors.RESPONSE_NOT_FOUND
if old_response.user_id != user_id:
LOGGER.error("Old user id {} does not match user id {}".format(old_response.user_id, user_id))
return errors.UNAUTHORIZED
if old_response.application_form_id != args['application_form_id']:
LOGGER.error("Update conflict for {}".format(args['application_form_id']))
return errors.UPDATE_CONFLICT
old_response.is_submitted = args['is_submitted']
if args['is_submitted']:
old_response.submitted_timestamp = datetime.datetime.now()
old_response.is_withdrawn = False
old_response.withdrawn_timestamp = None
for answer_args in args['answers']:
old_answer = db.session.query(Answer).filter(Answer.response_id == old_response.id, Answer.question_id == answer_args['question_id']).first()
if old_answer: # Update the existing answer
old_answer.value = answer_args['value']
else:
answer = Answer(old_response.id, answer_args['question_id'], answer_args['value'])
db.session.add(answer)
db.session.commit()
db.session.flush()
try:
if old_response.is_submitted:
LOGGER.info('Sending confirmation email for response with ID : {id}'.format(id=old_response.id))
user = db.session.query(AppUser).filter(AppUser.id==g.current_user['id']).first()
self.send_confirmation(user, old_response)
except:
LOGGER.warn('Failed to send confirmation email for response with ID : {id}, but the response was submitted succesfully'.format(id=old_response.id))
finally:
return old_response, 200
except SQLAlchemyError as e:
LOGGER.error("Database error encountered: {}".format(e))
return errors.DB_NOT_AVAILABLE
except:
LOGGER.error("Encountered unknown error: {}".format(traceback.format_exc()))
return errors.DB_NOT_AVAILABLE
def _serialize_answer(answer, language):
translation = answer.question.get_translation(language)
if not translation:
translation = answer.question.get_translation('en')
LOGGER.warn(
'Could not find {} translation for question id {}'.format(
language, answer.question.id))
return {
'headline': translation.headline,
'value': answer.value_display
}
def _serialise_identifier(answer, language):
question_translation = answer.question.get_translation(language)
if question_translation is None:
question_translation = answer.question.get_translation('en')
LOGGER.warn(
'Could not find {} translation for question id {}'.format(
language, answer.question.id))
return {
'headline': question_translation.headline,
'value': answer.value_display
}
def get(self):
args = self.req_parser.parse_args()
event_id = args['event_id']
try:
registration_form = db.session.query(RegistrationForm).filter(
RegistrationForm.event_id == event_id).first()
if not registration_form:
return errors.REGISTRATION_FORM_NOT_FOUND
sections = (db.session.query(RegistrationSection).filter(
RegistrationSection.registration_form_id ==
registration_form.id).filter(
RegistrationSection.show_for_travel_award == None).filter(
RegistrationSection.show_for_accommodation_award ==
None).filter(RegistrationSection.
show_for_payment_required == None).all())
if not sections:
LOGGER.warn('Sections not found for event_id: {}'.format(
args['event_id']))
return errors.SECTION_NOT_FOUND
registration_form.registration_sections = sections
questions = db.session.query(RegistrationQuestion).filter(
RegistrationQuestion.registration_form_id ==
registration_form.id).all()
if not questions:
LOGGER.warn('Questions not found for event_id: {}'.format(
args['event_id']))
return errors.QUESTION_NOT_FOUND
for s in registration_form.registration_sections:
s.registration_questions = []
for q in questions:
if q.section_id == s.id:
s.registration_questions.append(q)
return marshal(registration_form,
self.registration_form_fields), 201
except SQLAlchemyError as e:
LOGGER.error("Database error encountered: {}".format(e))
return errors.DB_NOT_AVAILABLE
except:
LOGGER.error("Encountered unknown error: {}".format(
traceback.format_exc()))
return errors.DB_NOT_AVAILABLE
def _serialize_answer(answer, language):
question = answer.question
translation = question.get_translation(language)
if translation is None:
LOGGER.warn('No {} translation found for question id {}'.format(language, question.id))
translation = question.get_translation('en')
return {
'question_id': answer.question_id,
'value': answer.value,
'type': answer.question.type,
'options': translation.options,
'headline': translation.headline
}
def send_confirmation(self, user, response):
try:
answers = db.session.query(Answer).filter(Answer.response_id == response.id).all()
if answers is None:
LOGGER.warn('Found no answers associated with response with id {response_id}'.format(response_id=response.id))
questions = db.session.query(Question).filter(Question.application_form_id == response.application_form_id).all()
if questions is None:
LOGGER.warn('Found no questions associated with application form with id {form_id}'.format(form_id=response.application_form_id))
application_form = db.session.query(ApplicationForm).filter(ApplicationForm.id == response.application_form_id).first()
if application_form is None:
LOGGER.warn('Found no application form with id {form_id}'.format(form_id=response.application_form_id))
event = db.session.query(Event).filter(Event.id == application_form.event_id).first()
if event is None:
LOGGER.warn('Found no event id {event_id}'.format(form_id=application_form.event_id))
except:
LOGGER.error('Could not connect to the database to retrieve response confirmation email data on response with ID : {response_id}'.format(response_id=response.id))
try:
# Building the summary, where the summary is a dictionary whose key is the question headline, and the value is the relevant answer
summary = {}
for answer in answers:
for question in questions:
if answer.question_id == question.id:
summary[question.headline] = _get_answer_value(answer, question)
subject = 'Your application to {}'.format(event.description)
greeting = strings.build_response_email_greeting(user.user_title, user.firstname, user.lastname)
body_text = greeting + '\n\n' + strings.build_response_email_body(event.name, event.description, summary)
emailer.send_mail(user.email, subject, body_text=body_text)
except:
LOGGER.error('Could not send confirmation email for response with id : {response_id}'.format(response_id=response.id))
def post(self):
args = self.post_req_parser.parse_args()
user_id = g.current_user['id']
is_submitted = args['is_submitted']
application_form_id = args['application_form_id']
language = args['language']
if len(language) != 2:
language = 'en' # Fallback to English if language doesn't look like an ISO 639-1 code
application_form = application_form_repository.get_by_id(
application_form_id)
if application_form is None:
return errors.FORM_NOT_FOUND_BY_ID
user = user_repository.get_by_id(user_id)
responses = response_repository.get_all_for_user_application(
user_id, application_form_id)
if not application_form.nominations and len(responses) > 0:
return errors.RESPONSE_ALREADY_SUBMITTED
response = Response(application_form_id, user_id, language)
if is_submitted:
response.submit()
response_repository.save(response)
answers = []
for answer_args in args['answers']:
answer = Answer(response.id, answer_args['question_id'],
answer_args['value'])
answers.append(answer)
response_repository.save_answers(answers)
try:
if response.is_submitted:
LOGGER.info(
'Sending confirmation email for response with ID : {id}'.
format(id=response.id))
user = user_repository.get_by_id(user_id)
response = response_repository.get_by_id_and_user_id(
response.id, user_id)
self.send_confirmation(user, response)
except:
LOGGER.warn(
'Failed to send confirmation email for response with ID : {id}, but the response was submitted succesfully'
.format(id=response.id))
finally:
return response, 201
def post(self):
# Save a new response for the logged-in user.
req_parser = reqparse.RequestParser()
req_parser.add_argument('is_submitted', type=bool, required=True)
req_parser.add_argument('application_form_id', type=int, required=True)
req_parser.add_argument('answers',
type=list,
required=True,
location='json')
args = req_parser.parse_args()
user_id = g.current_user['id']
try:
response = Response(args['application_form_id'], user_id)
response.is_submitted = args['is_submitted']
if args['is_submitted']:
response.submitted_timestamp = datetime.datetime.now()
db.session.add(response)
db.session.commit()
for answer_args in args['answers']:
answer = Answer(response.id, answer_args['question_id'],
answer_args['value'])
db.session.add(answer)
db.session.commit()
try:
if response.is_submitted:
LOGGER.info(
'Sending confirmation email for response with ID : {id}'
.format(id=response.id))
user = db.session.query(AppUser).filter(
AppUser.id == g.current_user['id']).first()
self.send_confirmation(user, response)
except:
LOGGER.warn(
'Failed to send confirmation email for response with ID : {id}, but the response was submitted succesfully'
.format(id=response.id))
finally:
return response, 201 # 201 is 'CREATED' status code
except SQLAlchemyError as e:
LOGGER.error("Database error encountered: {}".format(e))
return errors.DB_NOT_AVAILABLE
except:
LOGGER.error("Encountered unknown error: {}".format(
traceback.format_exc()))
return errors.DB_NOT_AVAILABLE
def _serialise_response(response: Response, review_form: ReviewForm,
language: str):
scores = []
for review_section in review_form.review_sections:
for review_question in review_section.review_questions:
if review_question.weight > 0:
review_question_translation = review_question.get_translation(
language)
if not review_question_translation:
review_question_translation = review_question.get_translation(
'en')
LOGGER.warn(
'Could not find {} translation for review question id {}'
.format(language, review_score.review_question.id))
average_score = review_repository.get_average_score_for_review_question(
response.id, review_question.id)
score = {
"review_question_id": review_question.id,
"headline": review_question_translation.headline,
"description": review_question_translation.description,
"type": review_question.type,
"score": average_score,
"weight": review_question.weight
}
scores.append(score)
response_summary = {
"response_id":
response.id,
"response_user_title":
response.user.user_title,
"response_user_firstname":
response.user.firstname,
"response_user_lastname":
response.user.lastname,
"identifiers": [
ReviewResponseDetailListAPI._serialise_identifier(
answer, response.language) for answer in response.answers
if answer.question.is_review_identifier()
],
"scores":
scores,
"total":
sum(score['score'] * score['weight'] for score in scores)
}
return response_summary
def put(self):
args = self.put_req_parser.parse_args()
user_id = g.current_user['id']
is_submitted = args['is_submitted']
language = args['language']
response = response_repository.get_by_id(args['id'])
if not response:
return errors.RESPONSE_NOT_FOUND
if response.user_id != user_id:
return errors.UNAUTHORIZED
if response.application_form_id != args['application_form_id']:
return errors.UPDATE_CONFLICT
response.is_submitted = is_submitted
response.language = language
if is_submitted:
response.submit()
response_repository.save(response)
answers = []
for answer_args in args['answers']:
answer = response_repository.get_answer_by_question_id_and_response_id(
answer_args['question_id'], response.id)
if answer:
answer.update(answer_args['value'])
else:
answer = Answer(response.id, answer_args['question_id'],
answer_args['value'])
answers.append(answer)
response_repository.save_answers(answers)
try:
if response.is_submitted:
LOGGER.info(
'Sending confirmation email for response with ID : {id}'.
format(id=response.id))
user = user_repository.get_by_id(user_id)
response = response_repository.get_by_id_and_user_id(
response.id, user_id)
self.send_confirmation(user, response)
except:
LOGGER.warn(
'Failed to send confirmation email for response with ID : {id}, but the response was submitted succesfully'
.format(id=response.id))
finally:
return response, 200
def _serialise_score(review_score, language):
review_question_translation = review_score.review_question.get_translation(
language)
if review_question_translation is None:
review_question_translation = review_score.review_question.get_translation(
'en')
LOGGER.warn(
'Could not find {} translation for review question id {}'.
format(language, review_score.review_question.id))
return {
'review_question_id': review_score.review_question.id,
'headline': review_question_translation.headline,
'description': review_question_translation.description,
'type': review_score.review_question.type,
'score': review_score.value,
'weight': review_score.review_question.weight,
}
def get(self):
LOGGER.debug('Received get request for application form')
args = self.req_parser.parse_args()
LOGGER.debug('Parsed Args for event_id: {}'.format(args))
try:
form = db.session.query(ApplicationForm).filter(
ApplicationForm.event_id == args['event_id']).first()
if (not form):
LOGGER.warn('Form not found for event_id: {}'.format(
args['event_id']))
return FORM_NOT_FOUND
if not form.is_open:
return APPLICATIONS_CLOSED
sections = db.session.query(Section).filter(
Section.application_form_id ==
form.id).all() #All sections in our form
if (not sections):
LOGGER.warn('Sections not found for event_id: {}'.format(
args['event_id']))
return SECTION_NOT_FOUND
questions = db.session.query(Question).filter(
Question.application_form_id ==
form.id).all() #All questions in our form
if (not questions):
LOGGER.warn('Questions not found for event_id: {}'.format(
args['event_id']))
return QUESTION_NOT_FOUND
form.sections = sections
for s in form.sections:
s.questions = []
for q in questions:
if (q.section_id == s.id):
s.questions.append(q)
if (form):
return marshal(form, self.form_fields)
else:
LOGGER.warn("Event not found for event_id: {}".format(
args['event_id']))
return EVENT_NOT_FOUND
except SQLAlchemyError as e:
LOGGER.error("Database error encountered: {}".format(e))
return DB_NOT_AVAILABLE
except:
LOGGER.error("Encountered unknown error: {}".format(
traceback.format_exc()))
return DB_NOT_AVAILABLE
def _serialize_review_question(review_question, language):
translation = review_question.get_translation(language)
if translation is None:
LOGGER.warn(
'Missing {} translation for review review_question id {}'.format(
language, review_question.id))
translation = review_question.get_translation('en')
return {
'id': review_question.id,
'question_id': review_question.question_id,
'description': translation.description,
'headline': translation.headline,
'type': review_question.type,
'placeholder': translation.placeholder,
'options': translation.options,
'is_required': review_question.is_required,
'order': review_question.order,
'validation_regex': translation.validation_regex,
'validation_text': translation.validation_text,
'weight': review_question.weight
}
def _serialize_review_form(review_form: ReviewForm,
language: str) -> Mapping[str, Any]:
review_sections = []
for section in review_form.review_sections:
translation = section.get_translation(language)
if translation is None:
LOGGER.warn(
'Missing {} translation for review section id {}'.format(
language, section.id))
translation = section.get_translation('en')
review_sections.append({
'id':
section.id,
'order':
section.order,
'headline':
translation.headline,
'description':
translation.description,
'review_questions': [
_serialize_review_question(q, language)
for q in section.review_questions
]
})
form = {
'id': review_form.id,
'application_form_id': review_form.application_form_id,
'is_open': review_form.is_open,
'deadline': review_form.deadline.isoformat(),
'stage': review_form.stage,
'review_sections': review_sections
}
return form
def send_confirmation(self, user, response):
try:
answers = db.session.query(Answer).join(
Question, Answer.question_id == Question.id).filter(
Answer.response_id == response.id).order_by(
Question.order).all()
if answers is None:
LOGGER.warn(
'Found no answers associated with response with id {response_id}'
.format(response_id=response.id))
application_form = db.session.query(ApplicationForm).filter(
ApplicationForm.id == response.application_form_id).first()
if application_form is None:
LOGGER.warn(
'Found no application form with id {form_id}'.format(
form_id=response.application_form_id))
event = db.session.query(Event).filter(
Event.id == application_form.event_id).first()
if event is None:
LOGGER.warn('Found no event id {event_id}'.format(
form_id=application_form.event_id))
except:
LOGGER.error(
'Could not connect to the database to retrieve response confirmation email data on response with ID : {response_id}'
.format(response_id=response.id))
try:
subject = 'Your application to {}'.format(event.description)
question_answer_summary = strings.build_response_email_body(
answers)
template = email_repository.get(event.id,
'confirmation-response').template
body_text = template.format(
title=user.user_title,
firstname=user.firstname,
lastname=user.lastname,
event_description=event.description,
question_answer_summary=question_answer_summary,
event_name=event.name)
emailer.send_mail(user.email,
subject,
body_text=body_text,
sender_name=g.organisation.name,
sender_email=g.organisation.email_from)
except:
LOGGER.error(
'Could not send confirmation email for response with id : {response_id}'
.format(response_id=response.id))
def send_confirmation(self, user, response):
try:
answers = response.answers
if not answers:
LOGGER.warn(
'Found no answers associated with response with id {response_id}'
.format(response_id=response.id))
application_form = response.application_form
if application_form is None:
LOGGER.warn(
'Found no application form with id {form_id}'.format(
form_id=response.application_form_id))
event = application_form.event
if event is None:
LOGGER.warn('Found no event id {event_id}'.format(
form_id=application_form.event_id))
except:
LOGGER.error(
'Could not connect to the database to retrieve response confirmation email data on response with ID : {response_id}'
.format(response_id=response.id))
try:
question_answer_summary = strings.build_response_email_body(
answers, user.user_primaryLanguage, application_form)
if event.has_specific_translation(user.user_primaryLanguage):
event_description = event.get_description(
user.user_primaryLanguage)
else:
event_description = event.get_description('en')
emailer.email_user(
'confirmation-response-call' if event.event_type
== EventType.CALL else 'confirmation-response',
template_parameters=dict(
event_description=event_description,
question_answer_summary=question_answer_summary,
),
event=event,
user=user)
except Exception as e:
LOGGER.error(
'Could not send confirmation email for response with id : {response_id} due to: {e}'
.format(response_id=response.id, e=e))
def get(self):
args = self.req_parser.parse_args()
event_id = args['event_id']
offer_id = args['offer_id']
try:
offer = db.session.query(Offer).filter(
Offer.id == offer_id).first()
user_id = verify_token(request.headers.get('Authorization'))['id']
if offer and (not offer.user_id == user_id):
return errors.FORBIDDEN
if not offer.candidate_response:
return errors.OFFER_NOT_ACCEPTED
registration_form = db.session.query(RegistrationForm).filter(
RegistrationForm.event_id == event_id).first()
if not registration_form:
return errors.REGISTRATION_FORM_NOT_FOUND
sections = db.session.query(RegistrationSection).filter(
RegistrationSection.registration_form_id == registration_form.id).all()
if not sections:
LOGGER.warn(
'Sections not found for event_id: {}'.format(args['event_id']))
return errors.SECTION_NOT_FOUND
included_sections = []
for section in sections:
if (section.show_for_travel_award is None) and (section.show_for_accommodation_award is None) and \
(section.show_for_payment_required is None):
included_sections.append(section)
elif (section.show_for_travel_award and offer.travel_award and offer.accepted_travel_award) or \
(section.show_for_accommodation_award and offer.accommodation_award and offer.accepted_accommodation_award) or \
(section.show_for_payment_required and offer.payment_required):
included_sections.append(section)
registration_form.registration_sections = included_sections
questions = db.session.query(RegistrationQuestion).filter(
RegistrationQuestion.registration_form_id == registration_form.id).all()
if not questions:
LOGGER.warn(
'Questions not found for event_id: {}'.format(args['event_id']))
return errors.QUESTION_NOT_FOUND
for s in registration_form.registration_sections:
s.registration_questions = []
for q in questions:
if q.section_id == s.id:
s.registration_questions.append(q)
return marshal(registration_form, self.registration_form_fields), 201
except SQLAlchemyError as e:
LOGGER.error("Database error encountered: {}".format(e))
return errors.DB_NOT_AVAILABLE
except:
LOGGER.error("Encountered unknown error: {}".format(
traceback.format_exc()))
return errors.DB_NOT_AVAILABLE
