def delete(self):
args = self.del_req_parser.parse_args()
current_user_id = g.current_user['id']
response = response_repository.get_by_id(args['id'])
if not response:
return errors.RESPONSE_NOT_FOUND
if response.user_id != current_user_id:
return errors.UNAUTHORIZED
response.withdraw()
response_repository.save(response)
try:
user = user_repository.get_by_id(current_user_id)
event = response.application_form.event
organisation = event.organisation
emailer.email_user(
'withdrawal',
template_parameters=dict(
organisation_name=organisation.name
),
event=event,
user=user
)
except:
LOGGER.error('Failed to send withdrawal confirmation email for response with ID : {id}, but the response was withdrawn succesfully'.format(id=args['id']))
return {}, 204
def test_build_response_html_app_info(self):
self._seed_static_data()
response = response_repository.get_by_id(self.response_id)
html_info_string = build_response_html_app_info(response, 'en')
self.assertIsNotNone(html_info_string)
def post(self):
args = self.post_req_parser.parse_args()
response_id = args['response_id']
title = args['title']
firstname = args['firstname']
lastname = args['lastname']
relation = args['relation']
email = args['email']
user = user_repository.get_by_id(g.current_user['id'])
if not user:
return USER_NOT_FOUND
event = event_repository.get_event_by_response_id(response_id)
if not event:
return EVENT_NOT_FOUND
response = response_repository.get_by_id(response_id)
if not response:
return RESPONSE_NOT_FOUND
reference_request = ReferenceRequest(response_id=response_id,
title=title,
firstname=firstname,
lastname=lastname,
relation=relation,
email=email)
reference_request_repository.create(reference_request)
link = "{host}/reference/{token}".format(host=misc.get_baobab_host(),
token=reference_request.token)
candidate, candidate_firstname, nominator = _get_candidate_nominator(
response)
if nominator is None:
nomination_text = "has nominated themself"
else:
nomination_text = "has been nominated by {}".format(nominator)
subject = 'REFERENCE REQUEST - {}'.format(event.name)
body = REFERENCE_REQUEST_EMAIL_BODY.format(
title=title,
firstname=firstname,
lastname=lastname,
candidate=candidate,
candidate_firstname=candidate_firstname,
nomination_text=nomination_text,
event_name=event.name,
event_url=event.url,
application_close_date=event.application_close,
link=link)
send_mail(recipient=email, subject=subject, body_text=body)
reference_request.set_email_sent(datetime.now())
reference_request_repository.add(reference_request)
return reference_request, 201
def post(self):
args = self.post_req_parser.parse_args()
response_id = args['response_id']
title = args['title']
firstname = args['firstname']
lastname = args['lastname']
relation = args['relation']
email = args['email']
user = user_repository.get_by_id(g.current_user['id'])
if not user:
return USER_NOT_FOUND
event = event_repository.get_event_by_response_id(response_id)
if not event:
return EVENT_NOT_FOUND
response = response_repository.get_by_id(response_id)
if not response:
return RESPONSE_NOT_FOUND
reference_request = ReferenceRequest(response_id=response_id,
title=title,
firstname=firstname,
lastname=lastname,
relation=relation,
email=email)
reference_request_repository.create(reference_request)
link = "{host}/reference/{token}".format(host=misc.get_baobab_host(),
token=reference_request.token)
try:
candidate, candidate_firstname, nominator = _get_candidate_nominator(
response)
except ValueError as e:
LOGGER.error(e)
return BAD_CONFIGURATION
email_user('reference-request-self-nomination'
if nominator is None else 'reference-request',
template_parameters=dict(
candidate=candidate,
candidate_firstname=candidate_firstname,
nominator=nominator,
event_url=event.url,
application_close_date=event.application_close,
link=link),
event=event,
user=user)
reference_request.set_email_sent(datetime.now())
reference_request_repository.add(reference_request)
return reference_request, 201
def test_build_response_html_answers(self):
self._seed_static_data()
application_form = application_form_repository.get_by_id(
self.application_form_id)
answers = response_repository.get_by_id(self.response_id).answers
html_answer_string = build_response_html_answers(
answers, 'en', application_form)
self.assertIsNotNone(html_answer_string)
def get(self):
args = self.post_req_parser.parse_args()
token = args['token']
reference_request = reference_request_repository.get_by_token(
token) # type: ReferenceRequest
if not reference_request:
return REFRERENCE_REQUEST_WITH_TOKEN_NOT_FOUND
response_id = reference_request.response_id
response = response_repository.get_by_id(response_id) # type: Response
if not response:
return RESPONSE_NOT_FOUND
event = event_repository.get_event_by_response_id(
response_id) # type: Event
if not event:
return EVENT_NOT_FOUND
reference = reference_repository.get_by_reference_request_id(
reference_request.id)
app_form = event.get_application_form() # type: ApplicationForm
# Determine whether the response is a nomination
try:
candidate, _, nominator = _get_candidate_nominator(response)
except ValueError as e:
LOGGER.error(e)
return BAD_CONFIGURATION
return_object = {
'candidate':
candidate,
'nominator':
nominator,
'relation':
reference_request.relation,
'name':
event.get_name('en'),
'description':
event.get_description('en'),
'is_application_open':
event.is_application_open,
'email_from':
event.email_from,
'reference_submitted_timestamp':
reference.timestamp if reference is not None else None
}
return return_object, 200
def test_build_response_html_answers_with_answers_missing(self):
"""
Tests that the builder doesn't break when a question is submitted without an answer
"""
self._seed_static_data()
application_form = application_form_repository.get_by_id(
self.application_form_id)
answers = response_repository.get_by_id(self.response_id2).answers
html_string = build_response_html_answers(answers, 'en',
application_form)
self.assertIsNotNone(html_string)
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 get(self, event_id):
req_parser = reqparse.RequestParser()
req_parser.add_argument('response_id', type=int, required=True)
req_parser.add_argument('language', type=str, required=True)
args = req_parser.parse_args()
response_id = args['response_id']
language = args['language']
response = response_repository.get_by_id(response_id)
review_form = review_repository.get_review_form(event_id)
review_form_id = None if review_form is None else review_form.id
review_config = review_configuration_repository.get_configuration_for_event(event_id)
num_reviewers = review_config.num_reviews_required + review_config.num_optional_reviews if review_config is not None else 1
return ResponseDetailAPI._serialize_response(response, language, review_form_id, num_reviewers)
def get(self):
args = self.get_req_parser.parse_args()
user = user_repository.get_by_id(g.current_user['id'])
response = response_repository.get_by_id(args['response_id'])
if not response:
return RESPONSE_NOT_FOUND
event = event_repository.get_event_by_response_id(response.id)
if not user.is_event_admin(event.id):
return FORBIDDEN
reference_responses = reference_request_repository.get_references_by_response_id(
response.id)
return [
reference_response.Reference
for reference_response in reference_responses
], 200
def test_repo_get_response(self):
"""Test for when retrieving a response from the repository and not via the api directly"""
self._seed_data()
response = response_repository.get_by_id_and_user_id(
self.test_response.id, self.other_user_data['id'])
self.assertEqual(response.application_form_id, self.test_form.id)
self.assertEqual(response.user_id, self.other_user_data['id'])
self.assertIsNone(response.submitted_timestamp)
self.assertFalse(response.is_withdrawn)
self.assertTrue(response.answers)
same_response = response_repository.get_by_id(self.test_response.id)
self.assertEqual(response, same_response)
all_user_responses = response_repository.get_by_user_id(
self.other_user_data['id'])
self.assertEqual(len(all_user_responses), 2)
self.assertEqual(response, all_user_responses[0])
def get(self):
def _get_answer(question_id, answers):
# Get the answer for a question
for a in answers:
if a.question_id == question_id:
return a
return None
def _get_files(application_form, answers):
# Get the response files that should be exported in the ZIP file
file_names = []
for section in application_form.sections:
for question in section.questions:
answer = _get_answer(question.id, answers)
if answer is not None:
# We are only interested in the files,
# the text answers will be in the main PDF file
if question.type == 'multi-file':
file_names.extend(json.loads(answer.value))
if question.type == 'file':
file_names.append(json.loads(answer.value))
return file_names
req_parser = reqparse.RequestParser()
req_parser.add_argument('response_id', type=int, required=True)
req_parser.add_argument('language', type=str, required=True)
args = req_parser.parse_args()
response_id = args['response_id']
language = args['language']
response = response_repository.get_by_id(response_id)
application_form = application_form_repository.get_by_id(response_id)
# Build the HTML string
response_string = strings.build_response_html_app_info(response, language) + \
strings.build_response_html_answers(response.answers, language, application_form)
# Convert to PDF
files_to_compress = [('response.pdf',
pdfconvertor.html_to_pdf(response.id,
response_string))]
# The files that were uploaded as part of the response
files_to_get = _get_files(application_form, response.answers)
bucket = storage.get_storage_bucket()
# Download and name the files
files_to_compress.extend([
(f['rename'] or f['filename'],
io.BytesIO(bucket.blob(f['filename']).download_as_bytes()))
for f in files_to_get
])
# Zip files
zipped_files = zip_in_memory(files_to_compress)
with tempfile.NamedTemporaryFile() as temp:
temp.write(zipped_files.getvalue())
return send_file(temp.name,
as_attachment=True,
attachment_filename=f"response_{response.id}.zip")
