def get(self):
try:
user_id = verify_token(request.headers.get('Authorization'))['id']
db_offer = db.session.query(Offer).filter(
Offer.user_id == user_id).first()
if db_offer is None:
return errors.OFFER_NOT_FOUND
registration = db.session.query(Registration).filter(
Registration.offer_id == db_offer.id).first()
if registration is None:
return 'no Registration', 404
registration_form = db.session.query(RegistrationForm).filter(RegistrationForm.id == registration.
registration_form_id).first()
if registration_form is None:
return errors.REGISTRATION_FORM_NOT_FOUND
db_answers = db.session.query(RegistrationAnswer).filter(RegistrationAnswer.registration_id ==
registration.id).all()
response = {
'registration_id': registration.id,
'offer_id': db_offer.id,
'registration_form_id': registration_form.id,
'answers': db_answers
}
return marshal(response, self.response_fields)
except Exception as e:
LOGGER.error("Database error encountered: {}".format(e))
return errors.DB_NOT_AVAILABLE
def put(self):
# update existing offer
args = self.req_parser.parse_args()
offer_id = args['offer_id']
candidate_response = args['candidate_response']
accepted_accommodation_award = args['accepted_accommodation_award']
accepted_travel_award = args['accepted_travel_award']
rejected_reason = args['rejected_reason']
offer = db.session.query(Offer).filter(Offer.id == offer_id).first()
LOGGER.info('Updating offer {} with values: candidate response: {}, Accepted accommodation: {}, '
'Accepted travel: {}, Rejected Reason: {}'.format(offer_id, candidate_response, accepted_accommodation_award,
accepted_travel_award, rejected_reason))
if not offer:
return errors.OFFER_NOT_FOUND
try:
user_id = verify_token(request.headers.get('Authorization'))['id']
if offer and offer.user_id != user_id:
return errors.FORBIDDEN
offer.responded_at = datetime.now()
offer.candidate_response = candidate_response
offer.accepted_accommodation_award = accepted_accommodation_award
offer.accepted_travel_award = accepted_travel_award
offer.rejected_reason = rejected_reason
db.session.commit()
except Exception as e:
LOGGER.error("Failed to update offer with id {} due to {}".format(args['offer_id'], e))
return errors.ADD_OFFER_FAILED
return offer_update_info(offer), 201
def is_token_valid():
incoming = request.get_json()
is_valid = verify_token(incoming["token"])
if is_valid:
return jsonify(token_is_valid=True)
else:
return jsonify(token_is_valid=False), 403
def put(self):
# Update an existing response for the logged-in user.
req_parser = reqparse.RequestParser()
args = self.req_parser.parse_args()
try:
user_id = verify_token(request.headers.get('Authorization'))['id']
registration = db.session.query(Registration).filter(
Registration.id == args['registration_id']).one_or_none()
if registration is None:
return 'Registration not found', 404
db_offer = db.session.query(Offer).filter(
Offer.id == registration.offer_id).one_or_none()
if db_offer is None:
return errors.OFFER_NOT_FOUND
if db_offer.user_id != user_id:
return errors.FORBIDDEN
registration.registration_form_id = args['registration_form_id']
db.session.commit()
for answer_args in args['answers']:
answer = db.session.query(RegistrationAnswer).filter(
RegistrationAnswer.registration_question_id ==
answer_args['registration_question_id'],
RegistrationAnswer.registration_id ==
args['registration_id']).one_or_none()
if answer is not None:
answer.value = answer_args['value']
elif db.session.query(RegistrationQuestion).filter(
RegistrationQuestion.id ==
answer_args['registration_question_id']).one():
answer = RegistrationAnswer(
registration_id=registration.id,
registration_question_id=answer_args[
'registration_question_id'],
value=answer_args['value'])
db.session.add(answer)
db.session.commit()
return 200
except Exception as e:
return 'Could not access DB', 400
def process_request(self, req, res):
req.context['auth_user'] = verify_token(req.auth) if req.auth else None
def post(self):
# Save a new response for the logged-in user.
req_parser = reqparse.RequestParser()
args = self.req_parser.parse_args()
offer_id = args['offer_id']
try:
offer = db.session.query(Offer).filter(
Offer.id == offer_id).first()
if not offer:
return errors.OFFER_NOT_FOUND
user_id = verify_token(request.headers.get('Authorization'))['id']
if not user_id:
return errors.USER_NOT_FOUND
current_user = db.session.query(AppUser).filter(
AppUser.id == user_id).first()
registration_form = db.session.query(RegistrationForm).filter(
RegistrationForm.id == args['registration_form_id']).first()
if not registration_form:
return errors.REGISTRATION_FORM_NOT_FOUND
registration = Registration(
offer_id=args['offer_id'],
registration_form_id=args['registration_form_id'],
confirmed=True if (not offer.payment_required) else False,
confirmation_email_sent_at=date.today())
db.session.add(registration)
db.session.commit()
event = event_repository.get_by_id(registration_form.event_id)
for answer_args in args['answers']:
if db.session.query(RegistrationQuestion).filter(
RegistrationQuestion.id ==
answer_args['registration_question_id']).first():
answer = RegistrationAnswer(
registration_id=registration.id,
registration_question_id=answer_args[
'registration_question_id'],
value=answer_args['value'])
db.session.add(answer)
db.session.commit()
registration_answers = db.session.query(RegistrationAnswer).filter(
RegistrationAnswer.registration_id == registration.id).all()
registration_questions = db.session.query(
RegistrationQuestion).filter(
RegistrationQuestion.registration_form_id ==
args['registration_form_id']).all()
self.send_confirmation(current_user, registration_questions,
registration_answers,
registration.confirmed, event)
# 201 is 'CREATED' status code
return marshal(registration, self.registration_fields), 201
except SQLAlchemyError as e:
LOGGER.error("Database error encountered: {}".format(e))
return errors.DB_NOT_AVAILABLE
except Exception as e:
LOGGER.error("Encountered unknown error: {}".format(
traceback.format_exc()))
return errors.DB_NOT_AVAILABLE
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
def post(self):
# Save a new response for the logged-in user.
req_parser = reqparse.RequestParser()
args = self.req_parser.parse_args()
try:
user_id = verify_token(request.headers.get('Authorization'))['id']
if not user_id:
return errors.USER_NOT_FOUND
current_user = db.session.query(AppUser).filter(
AppUser.id == user_id).first()
registration_form = db.session.query(RegistrationForm).filter(
RegistrationForm.id == args['registration_form_id']).first()
if not registration_form:
return errors.REGISTRATION_FORM_NOT_FOUND
registration = GuestRegistration(
registration_form_id=args['registration_form_id'],
user_id=user_id,
confirmed=True,
created_at=date.today(),
confirmation_email_sent_at=date.today() #None
)
db.session.add(registration)
db.session.commit()
event_name = db.session.query(Event).filter(
Event.id == registration_form.event_id).first().name
for answer_args in args['answers']:
if db.session.query(RegistrationQuestion).filter(
RegistrationQuestion.id ==
answer_args['registration_question_id']).first():
answer = GuestRegistrationAnswer(
guest_registration_id=registration.id,
registration_question_id=answer_args[
'registration_question_id'],
value=answer_args['value'])
db.session.add(answer)
db.session.commit()
registration_answers = db.session.query(
GuestRegistrationAnswer).filter(
GuestRegistrationAnswer.guest_registration_id ==
registration.id).all()
registration_questions = db.session.query(
RegistrationQuestion).filter(
RegistrationQuestion.registration_form_id ==
args['registration_form_id']).all()
email_sent = self.send_confirmation(current_user,
registration_questions,
registration_answers,
event_name)
if email_sent:
registration.confirmation_email_sent_at = date.today()
db.session.commit()
return registration, 201 # 201 is 'CREATED' status code
except SQLAlchemyError as e:
LOGGER.error("Database error encountered: {}".format(e))
return errors.DB_NOT_AVAILABLE
except Exception as e:
LOGGER.error("Encountered unknown error: {}".format(
traceback.format_exc()))
return errors.DB_NOT_AVAILABLE
def post(self):
# Process arguments
args = self.req_parser.parse_args()
event_id = args['event_id']
work_address = args['work_address'] if args[
'work_address'] is not None else ' '
addressed_to = args['addressed_to'] or 'Whom it May Concern'
residential_address = args['residential_address']
passport_name = args['passport_name']
passport_no = args['passport_no']
passport_issued_by = args['passport_issued_by']
passport_expiry_date = datetime.strptime(
(args['passport_expiry_date']), '%Y-%m-%d')
registration_event = EventRepository.get_by_id(event_id)
if (registration_event is not None):
to_date = registration_event.end_date
from_date = registration_event.start_date
else:
return errors.EVENT_ID_NOT_FOUND
# Finding registation_id for this user at this event
user_id = verify_token(request.headers.get('Authorization'))['id']
offer = db.session.query(Offer).filter(
Offer.user_id == user_id).filter(
Offer.event_id == event_id).first()
registration_form = db.session.query(RegistrationForm).filter(
RegistrationForm.event_id == event_id).first()
if not registration_form:
return errors.REGISTRATION_FORM_NOT_FOUND
# Check if Guest Registration
registration = None
registration = db.session.query(GuestRegistration).filter(
GuestRegistration.user_id == user_id).filter(
GuestRegistration.registration_form_id ==
registration_form.id).first()
if registration:
is_guest_registration = True
else:
is_guest_registration = False
# Normal Registration
if (not registration) and offer:
registration = db.session.query(Registration).filter(
Registration.offer_id == offer.id).first()
if not registration:
return errors.REGISTRATION_NOT_FOUND
try:
if (is_guest_registration):
invitation_letter_request = InvitationLetterRequest(
guest_registration_id=registration.id,
event_id=event_id,
work_address=work_address,
addressed_to=addressed_to,
residential_address=residential_address,
passport_name=passport_name,
passport_no=passport_no,
passport_issued_by=passport_issued_by,
passport_expiry_date=passport_expiry_date,
to_date=to_date,
from_date=from_date)
else:
invitation_letter_request = InvitationLetterRequest(
registration_id=registration.id,
event_id=event_id,
work_address=work_address,
addressed_to=addressed_to,
residential_address=residential_address,
passport_name=passport_name,
passport_no=passport_no,
passport_issued_by=passport_issued_by,
passport_expiry_date=passport_expiry_date,
to_date=to_date,
from_date=from_date)
db.session.add(invitation_letter_request)
db.session.commit()
except Exception as e:
LOGGER.error(
'Failed to add invitation letter request for user id {} due to: {}'
.format(user_id, e))
return errors.ADD_INVITATION_REQUEST_FAILED
invitation_template = None
if (is_guest_registration):
invitation_template = (db.session.query(InvitationTemplate).filter(
InvitationTemplate.send_for_both_travel_accommodation == False
).filter(
InvitationTemplate.send_for_travel_award_only == False).filter(
InvitationTemplate.send_for_accommodation_award_only ==
False).first())
elif (offer.accommodation_award and offer.accepted_accommodation_award
and offer.travel_award and offer.accepted_travel_award):
invitation_template = db.session.query(InvitationTemplate).filter(
InvitationTemplate.event_id == offer.event_id).filter(
InvitationTemplate.send_for_both_travel_accommodation ==
True).first()
elif (offer.travel_award and offer.accepted_travel_award):
invitation_template = db.session.query(InvitationTemplate).filter(
InvitationTemplate.event_id == offer.event_id).filter(
InvitationTemplate.send_for_travel_award_only ==
True).first()
elif (offer.accommodation_award
and offer.accepted_accommodation_award):
invitation_template = db.session.query(InvitationTemplate).filter(
InvitationTemplate.event_id == offer.event_id).filter(
InvitationTemplate.send_for_accommodation_award_only ==
True).first()
else:
invitation_template = (db.session.query(InvitationTemplate).filter(
InvitationTemplate.send_for_both_travel_accommodation == False
).filter(
InvitationTemplate.send_for_travel_award_only == False).filter(
InvitationTemplate.send_for_accommodation_award_only ==
False).first())
template_url = invitation_template.template_path
user = db.session.query(AppUser).filter(AppUser.id == user_id).first()
country_of_residence = db.session.query(Country).filter(
Country.id == user.residence_country_id).first()
nationality = db.session.query(Country).filter(
Country.id == user.nationality_country_id).first()
if user.user_dateOfBirth is not None:
date_of_birth = user.user_dateOfBirth.strftime("%Y-%m-%d")
else:
return errors.MISSING_DATE_OF_BIRTH
# Poster registration
bringing_poster = ""
poster_registration_question = db.session.query(
RegistrationQuestion).filter(
RegistrationQuestion.headline ==
"Will you be bringing a poster?").first()
if poster_registration_question is not None:
poster_answer = (db.session.query(RegistrationAnswer).join(
Registration,
RegistrationAnswer.registration_id == Registration.id).join(
Offer, Offer.id == Registration.offer_id).filter(
Offer.user_id == user_id).filter(
RegistrationAnswer.registration_question_id ==
poster_registration_question.id).first())
if poster_answer is not None and poster_answer.value == 'yes':
bringing_poster = "The participant will be presenting a poster of their research."
# Handling fields
invitation_letter_request.invitation_letter_sent_at = datetime.now()
is_sent = generate(
template_path=template_url,
event_id=event_id,
work_address=work_address,
addressed_to=addressed_to,
residential_address=residential_address,
passport_name=passport_name,
passport_no=passport_no,
passport_issued_by=passport_issued_by,
invitation_letter_sent_at=invitation_letter_request.
invitation_letter_sent_at.strftime("%Y-%m-%d"),
expiry_date=passport_expiry_date.strftime("%Y-%m-%d"),
to_date=to_date.strftime("%Y-%m-%d"),
from_date=from_date.strftime("%Y-%m-%d"),
country_of_residence=country_of_residence.name,
nationality=nationality.name,
date_of_birth=date_of_birth,
email=user.email,
user_title=user.user_title,
firstname=user.firstname,
lastname=user.lastname,
bringing_poster=bringing_poster,
user=user)
if not is_sent:
return errors.SENDING_INVITATION_FAILED
try:
db.session.commit()
return invitation_info(invitation_letter_request), 201
except Exception as e:
LOGGER.error(
"Failed to add invitation request for user with email: {} due to {}"
.format(user.email, e))
return errors.ADD_INVITATION_REQUEST_FAILED
def put(self):
# Update an existing response for the logged-in user.
args = self.req_parser.parse_args()
try:
user_id = verify_token(request.headers.get('Authorization'))['id']
registration = db.session.query(GuestRegistration).filter(
GuestRegistration.id ==
args['guest_registration_id']).one_or_none()
if registration is None:
return 'Registration not found', 404
registration.registration_form_id = args['registration_form_id']
db.session.commit()
for answer_args in args['answers']:
answer = db.session.query(GuestRegistrationAnswer).filter(
GuestRegistrationAnswer.registration_question_id ==
answer_args['registration_question_id'],
GuestRegistrationAnswer.guest_registration_id ==
args['guest_registration_id']).one_or_none()
if answer is not None:
answer.value = answer_args['value']
elif db.session.query(RegistrationQuestion).filter(
RegistrationQuestion.id ==
answer_args['registration_question_id']).one():
answer = GuestRegistrationAnswer(
guest_registration_id=registration.id,
registration_question_id=answer_args[
'registration_question_id'],
value=answer_args['value'])
db.session.add(answer)
db.session.commit()
current_user = user_repository.get_by_id(user_id)
registration_answers = db.session.query(
GuestRegistrationAnswer).filter(
GuestRegistrationAnswer.guest_registration_id ==
registration.id).all()
registration_questions = db.session.query(
RegistrationQuestion).filter(
RegistrationQuestion.registration_form_id ==
args['registration_form_id']).all()
registration_form = db.session.query(RegistrationForm).filter(
RegistrationForm.id == args['registration_form_id']).first()
event = event_repository.get_by_id(registration_form.event_id)
email_sent = self.send_confirmation(current_user,
registration_questions,
registration_answers, event)
if email_sent:
registration.confirmation_email_sent_at = date.today()
db.session.commit()
return 200
except Exception as e:
return 'Could not access DB', 400
