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 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, 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 get(self):
email = request.args.get('email')
LOGGER.debug("Resending verification email to: {}".format(email))
user = db.session.query(AppUser).filter(
func.lower(AppUser.email) == func.lower(email)).first()
if not user:
LOGGER.debug("User not found for email: {}".format(email))
return USER_NOT_FOUND
if user.verify_token is None:
user.verify_token = make_code()
try:
db.session.commit()
except IntegrityError:
LOGGER.error("Adding verify token for {} failed. ".format(email))
return ADD_VERIFY_TOKEN_FAILED
send_mail(recipient=user.email,
subject='Baobab Email Verification',
body_text=VERIFY_EMAIL_BODY.format(user.user_title,
user.firstname,
user.lastname,
get_baobab_host(),
user.verify_token))
LOGGER.debug("Resent email verification to: {}".format(email))
return {}, 201
def post(self):
req_parser = reqparse.RequestParser()
req_parser.add_argument('email', type=str, required=True)
args = req_parser.parse_args()
LOGGER.debug("Requesting password reset for email {}".format(
args['email']))
user = db.session.query(AppUser).filter(
func.lower(AppUser.email) == func.lower(args['email'])).first()
if not user:
LOGGER.debug("No user found for email {}".format(args['email']))
return USER_NOT_FOUND
password_reset = PasswordReset(user=user)
db.session.add(password_reset)
db.session.commit()
send_mail(recipient=args['email'],
subject='Password Reset for Deep Learning Indaba portal',
body_text=RESET_EMAIL_BODY.format(user.user_title,
user.firstname,
user.lastname,
get_baobab_host(),
password_reset.code))
return {}, 201
def post(self):
req_parser = reqparse.RequestParser()
req_parser.add_argument('user_id', type=int, required=True)
req_parser.add_argument('email_subject', type=str, required=True)
req_parser.add_argument('email_body', type=str, required=True)
args = req_parser.parse_args()
user = user_repository.get_by_id(args['user_id'])
if user is None:
return errors.USER_NOT_FOUND
try:
send_mail(recipient=user.email,
sender_name=g.organisation.name,
sender_email=g.organisation.email_from,
subject=args['email_subject'],
body_text=GENERIC_EMAIL_TEMPLATE.format(
user_title=user.user_title,
user_firstname=user.firstname,
user_lastname=user.lastname,
body=args['email_body'],
)
)
except Exception as e:
LOGGER.error('Error sending email: {}'.format(e))
return errors.EMAIL_NOT_SENT
def post(self):
args = self.req_parser.parse_args()
event_id = args['event_id']
user_id = g.current_user['id']
event = db.session.query(Event).get(event_id)
if not event:
return EVENT_NOT_FOUND
current_user = user_repository.get_by_id(user_id)
if not current_user.is_event_admin(event_id):
return FORBIDDEN
users = user_repository.get_all_without_responses()
for user in users:
title = user.user_title
firstname = user.firstname
lastname = user.lastname
event_name = event.name
deadline = event.get_application_form().deadline.strftime('%A %-d %B %Y')
subject = 'FINAL REMINDER: We do not have your application to attend {}'.format(event_name)
body = NOT_STARTED_EMAIL_BODY.format(title=title, firstname=firstname, lastname=lastname, event=event_name, deadline=deadline)
send_mail(recipient=user.email, subject=subject, body_text=body)
return {'not_started_responses': len(users)}, 201
def post(self):
args = self.req_parser.parse_args()
user_id = args['user_id']
event_id = args['event_id']
email_template = args['email_template']
offer_date = datetime.strptime((args['offer_date']),
'%Y-%m-%dT%H:%M:%S.%fZ')
expiry_date = datetime.strptime((args['expiry_date']),
'%Y-%m-%dT%H:%M:%S.%fZ')
payment_required = args['payment_required']
travel_award = args['travel_award']
accommodation_award = args['accommodation_award']
user = db.session.query(AppUser).filter(AppUser.id == user_id).first()
event_name = db.session.query(Event).filter(
Event.id == event_id).first().name
existing_offer = db.session.query(Offer).filter(
Offer.user_id == user_id, Offer.event_id == event_id).first()
if existing_offer:
return errors.DUPLICATE_OFFER
existing_outcome = outcome_repository.get_latest_by_user_for_event(
user_id, event_id)
if existing_outcome:
if existing_outcome.status == Status.REJECTED:
return errors.CANDIDATE_REJECTED
existing_outcome.reset_latest()
new_outcome = Outcome(event_id, user_id, Status.ACCEPTED,
g.current_user['id'])
outcome_repository.add(new_outcome)
offer_entity = Offer(user_id=user_id,
event_id=event_id,
offer_date=offer_date,
expiry_date=expiry_date,
payment_required=payment_required,
travel_award=travel_award,
accommodation_award=accommodation_award)
db.session.add(offer_entity)
db.session.commit()
if user.email:
email_body_template = email_template or OFFER_EMAIL_BODY
send_mail(
recipient=user.email,
subject='{} Application Status Update'.format(event_name),
body_text=email_body_template.format(
user_title=user.user_title,
first_name=user.firstname,
last_name=user.lastname,
event_name=event_name,
host=misc.get_baobab_host(),
expiry_date=offer_entity.expiry_date.strftime("%Y-%m-%d")))
LOGGER.debug("Sent an offer email to {}".format(user.email))
return offer_info(offer_entity), 201
def delete(self):
# Delete an existing response for the logged-in user.
req_parser = reqparse.RequestParser()
req_parser.add_argument('id', type=int, required=True)
args = req_parser.parse_args()
try:
response = db.session.query(Response).filter(
Response.id == args['id']).first()
if not response:
return errors.RESPONSE_NOT_FOUND
if response.user_id != g.current_user['id']:
return errors.UNAUTHORIZED
response.is_withdrawn = True
response.withdrawn_timestamp = datetime.datetime.now()
response.is_submitted = False
response.submitted_timestamp = None
db.session.commit()
db.session.flush()
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
try:
user = db.session.query(AppUser).filter(
AppUser.id == g.current_user['id']).first()
event = response.application_form.event
organisation = event.organisation
subject = 'Withdrawal of Application for the {event_name}'.format(
event_name=event.description)
withdrawal_template = email_repository.get(event.id,
'withdrawal').template
body_text = withdrawal_template.format(
title=user.user_title,
firstname=user.firstname,
lastname=user.lastname,
organisation_name=organisation.name,
event_name=event.name)
emailer.send_mail(user.email,
subject,
body_text,
sender_name=g.organisation.name,
sender_email=g.organisation.email_from)
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_send_email(self):
try:
LOGGER.info("Testing mailer")
send_mail(recipient='*****@*****.**',
subject='TestSMTPEmail',
body_text='Hello world from Amazon SES')
return True
except Exception:
return False
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 put(self):
args = self.req_parser.parse_args()
email = args['email']
firstname = args['firstname']
lastname = args['lastname']
user_title = args['user_title']
nationality_country_id = args['nationality_country_id']
residence_country_id = args['residence_country_id']
user_gender = args['user_gender']
affiliation = args['affiliation']
department = args['department']
user_disability = args['user_disability']
user_category_id = args['user_category_id']
user_dateOfBirth = datetime.strptime((args['user_dateOfBirth']),
'%Y-%m-%dT%H:%M:%S.%fZ')
user_primaryLanguage = args['user_primaryLanguage']
user = db.session.query(AppUser).filter(
AppUser.id == g.current_user['id']).first()
if user.email != email:
user.update_email(email)
user.firstname = firstname
user.lastname = lastname
user.user_title = user_title
user.nationality_country_id = nationality_country_id
user.residence_country_id = residence_country_id
user.user_gender = user_gender
user.affiliation = affiliation
user.department = department
user.user_disability = user_disability
user.user_category_id = user_category_id
user.user_dateOfBirth = user_dateOfBirth
user.user_primaryLanguage = user_primaryLanguage
try:
db.session.commit()
except IntegrityError:
LOGGER.error("email {} already in use".format(email))
return EMAIL_IN_USE
if not user.verified_email:
send_mail(recipient=user.email,
subject='Baobab Email Re-Verification',
body_text=VERIFY_EMAIL_BODY.format(
user_title, firstname, lastname, get_baobab_host(),
user.verify_token))
LOGGER.debug("Sent re-verification email to {}".format(user.email))
roles = db.session.query(EventRole).filter(
EventRole.user_id == user.id).all()
return user_info(user, roles), 200
def post(self, send_email=True):
args = self.req_parser.parse_args()
event_id = args['event_id']
email = args['email']
role = args['role']
user = user_repository.get_by_email(email, g.organisation.id)
if not user:
return USER_NOT_FOUND
event = event_repository.get_by_id(event_id)
if not event:
return EVENT_NOT_FOUND
existingInvitedGuest = db.session.query(InvitedGuest).filter(
InvitedGuest.event_id == event_id).filter(
InvitedGuest.user_id == user.id).first()
if existingInvitedGuest:
return INVITED_GUEST_FOR_EVENT_EXISTS
invitedGuest = InvitedGuest(event_id=event_id,
user_id=user.id,
role=role)
db.session.add(invitedGuest)
try:
db.session.commit()
except IntegrityError:
LOGGER.error("Failed to add invited guest: {}".format(email))
return ADD_INVITED_GUEST_FAILED
if send_email:
try:
send_mail(recipient=user.email,
subject='Your invitation to {}'.format(event.name),
body_text=GUEST_EMAIL_TEMPLATE.format(
user_title=user.user_title,
firstname=user.firstname,
lastname=user.lastname,
role=role,
event_name=event.name,
event_key=event.key,
system_name=g.organisation.system_name,
host=misc.get_baobab_host()))
except Exception as e:
LOGGER.error(
'Failed to send email to invited guest with user Id {}, due to {}'
.format(user.id, e))
return INVITED_GUEST_EMAIL_FAILED
return invitedGuest_info(invitedGuest, user), 201
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_registration_confirmation_mail(user, event_name):
subject = event_name + ' Registration Confirmation'
greeting = strings.build_response_email_greeting(
user.user_title, user.firstname, user.lastname)
body_text = greeting + '\n\n' + \
REGISTRATION_CONFIRMED_MESSAGE.format(event_name=event_name)
try:
emailer.send_mail(user.email, subject, body_text=body_text)
return True
except Exception as e:
LOGGER.error(
'Error occured while sending email to {}: {}'.format(user.email, e))
return False
def post(self):
args = self.post_req_parser.parse_args()
user_id = g.current_user['id']
event_id = args['event_id']
reviewer_user_email = args['reviewer_user_email']
num_reviews = args['num_reviews']
event = db.session.query(Event).filter(Event.id == event_id).first()
if not event:
return EVENT_NOT_FOUND
current_user = user_repository.get_by_id(user_id)
if not current_user.is_event_admin(event_id):
return FORBIDDEN
reviewer_user = user_repository.get_by_email(reviewer_user_email,
g.organisation.id)
if reviewer_user is None:
return USER_NOT_FOUND
if not reviewer_user.is_reviewer(event_id):
self.add_reviewer_role(reviewer_user.id, event_id)
config = review_configuration_repository.get_configuration_for_event(
event_id)
response_ids = self.get_eligible_response_ids(
event_id, reviewer_user.id, num_reviews,
config.num_reviews_required)
response_reviewers = [
ResponseReviewer(response_id, reviewer_user.id)
for response_id in response_ids
]
db.session.add_all(response_reviewers)
db.session.commit()
if len(response_ids) > 0:
send_mail(recipient=reviewer_user.email,
subject='You have been assigned reviews in Baobab',
body_text=ASSIGNED_BODY.format(
title=reviewer_user.user_title,
firstname=reviewer_user.firstname,
lastname=reviewer_user.lastname,
num_reviews=len(response_ids),
baobab_host=misc.get_baobab_host(),
system_name=g.organisation.system_name,
event_key=event.key,
event=event.name))
return {}, 201
def post(self):
LOGGER.debug('Received post request for reference-request')
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
response_event = event_repository.get_event_by_response_id(response_id)
if not response_event or not response_event.Event:
return EVENT_NOT_FOUND
event = response_event.Event
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}/{key}/reference?token={token}".format(
host=misc.get_baobab_host(),
key=event.key,
token=reference_request.token)
subject = 'REFERENCE REQUEST - {}'.format(event.name)
body = REFERENCE_REQUEST_EMAIL_BODY.format(
title=title,
firstname=firstname,
lastname=lastname,
event_description=event.description,
link=link,
candidate_firstname=user.firstname,
candidate_lastname=user.lastname,
application_close_date=event.application_close)
send_mail(recipient=email, subject=subject, body_text=body)
reference_request.set_email_sent(datetime.now())
reference_request_repository.update(reference_request)
return {}, 201
def put(self):
args = self.put_req_parser.parse_args()
firstname = args['firstname']
lastname = args['lastname']
user_title = args['user_title']
email = args['email']
user = db.session.query(AppUser).filter(
AppUser.id == g.current_user['id']).first()
if user.email != email:
user.update_email(email)
user.firstname = firstname
user.lastname = lastname
user.user_title = user_title
try:
db.session.commit()
except Exception as e:
LOGGER.error("Exception updating user profile - {}".format(e))
return ERROR_UPDATING_USER_PROFILE
if not user.verified_email:
send_mail(recipient=user.email,
sender_name=g.organisation.name,
sender_email=g.organisation.email_from,
subject='{} Email Re-Verification'.format(
g.organisation.system_name),
body_text=VERIFY_EMAIL_BODY.format(
title=user_title,
firstname=firstname,
lastname=lastname,
system=g.organisation.system_name,
organisation=g.organisation.name,
host=misc.get_baobab_host(),
token=user.verify_token))
LOGGER.debug("Sent re-verification email to {}".format(user.email))
roles = db.session.query(EventRole).filter(
EventRole.user_id == user.id).all()
return user_info(user, roles), 200
def post(self):
args = self.req_parser.parse_args()
user_api = UserAPI.UserAPI()
user, status = user_api.post(invitedGuest=True)
if status != 201:
return user, status
invited_guest_api = InvitedGuestAPI()
invited_guest_info, status = invited_guest_api.post(send_email=False)
if status == 201:
event_id = invited_guest_info['event_id']
role = invited_guest_info['role']
user = user_repository.get_by_id(user['id'])
event = event_repository.get_by_id(event_id)
reset_code = misc.make_code()
password_reset = PasswordReset(user=user)
db.session.add(password_reset)
db.session.commit()
try:
send_mail(recipient=user.email,
subject='Your invitation to {}'.format(event.name),
body_text=NEW_GUEST_EMAIL_TEMPLATE.format(
user_title=user.user_title,
firstname=user.firstname,
lastname=user.lastname,
role=role,
event_name=event.name,
event_key=event.key,
system_name=g.organisation.system_name,
host=misc.get_baobab_host(),
reset_code=password_reset.code))
except Exception as e:
LOGGER.error(
'Failed to send email for invited guest with user Id {} due to: {}'
.format(user.id, e))
return INVITED_GUEST_EMAIL_FAILED
return invited_guest_info, status
def delete(self):
# Delete an existing response for the logged-in user.
req_parser = reqparse.RequestParser()
req_parser.add_argument('id', type=int, required=True)
args = req_parser.parse_args()
try:
response = db.session.query(Response).filter(Response.id == args['id']).first()
if not response:
return errors.RESPONSE_NOT_FOUND
if response.user_id != g.current_user['id']:
return errors.UNAUTHORIZED
response.is_withdrawn = True
response.withdrawn_timestamp = datetime.datetime.now()
response.is_submitted = False
response.submitted_timestamp = None
db.session.commit()
db.session.flush()
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
try:
user = db.session.query(AppUser).filter(AppUser.id == g.current_user['id']).first()
subject = 'Withdrawal of Application for the Deep Learning Indaba'
WITHDRAWAL_BODY.format(title=user.user_title, firstname=user.firstname, lastname=user.lastname)
emailer.send_mail(user.email, subject, body_text)
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 get(self):
email = request.args.get('email')
LOGGER.debug("Resending verification email to: {}".format(email))
user = user_repository.get_by_email(email, g.organisation.id)
if not user:
LOGGER.debug(
"User not found for email: {} in organisation: {}".format(
email, g.organisation.name))
return USER_NOT_FOUND
if user.verify_token is None:
user.verify_token = make_code()
try:
db.session.commit()
except IntegrityError:
LOGGER.error("Adding verify token for {} failed. ".format(email))
return ADD_VERIFY_TOKEN_FAILED
send_mail(recipient=user.email,
sender_name=g.organisation.name,
sender_email=g.organisation.email_from,
subject='{} Email Verification'.format(
g.organisation.system_name),
body_text=VERIFY_EMAIL_BODY.format(
title=user.user_title,
firstname=user.firstname,
lastname=user.lastname,
system=g.organisation.system_name,
organisation=g.organisation.name,
host=misc.get_baobab_host(),
token=user.verify_token))
LOGGER.debug("Resent email verification to: {}".format(email))
return {}, 201
def post(self):
args = self.req_parser.parse_args()
event_id = args['event_id']
user_id = g.current_user['id']
event = db.session.query(Event).get(event_id)
if not event:
return EVENT_NOT_FOUND
current_user = user_repository.get_by_id(user_id)
if not current_user.is_event_admin(event_id):
return FORBIDDEN
users = user_repository.get_all_with_unsubmitted_response()
for user in users:
title = user.user_title
firstname = user.firstname
lastname = user.lastname
event_name = event.name
organisation_name = event.organisation.name
deadline = event.get_application_form().deadline.strftime(
'%A %-d %B %Y')
subject = 'FINAL REMINDER to submit you application for {}'.format(
event_name)
not_submitted_body = email_repository.get(
event_id, 'application-not-submitted').template
body = not_submitted_body.format(
title=title,
firstname=firstname,
lastname=lastname,
event=event_name,
organisation_name=organisation_name,
deadline=deadline)
send_mail(recipient=user.email, subject=subject, body_text=body)
return {'unsubmitted_responses': len(users)}, 201
def post(self):
req_parser = reqparse.RequestParser()
req_parser.add_argument('email', type=str, required=True)
args = req_parser.parse_args()
LOGGER.debug(
"Requesting password reset for email {} and organisation {}".
format(args['email'], g.organisation.name))
user = user_repository.get_by_email(args['email'], g.organisation.id)
if not user:
LOGGER.debug(
"No user found for email {} and organisation {}".format(
args['email'], g.organisation.name))
return USER_NOT_FOUND
password_reset = PasswordReset(user=user)
db.session.add(password_reset)
db.session.commit()
send_mail(recipient=args['email'],
sender_name=g.organisation.name,
sender_email=g.organisation.email_from,
subject='Password Reset for {}'.format(
g.organisation.system_name),
body_text=RESET_EMAIL_BODY.format(
title=user.user_title,
firstname=user.firstname,
lastname=user.lastname,
system=g.organisation.system_name,
organisation=g.organisation.name,
host=misc.get_baobab_host(),
token=password_reset.code))
return {}, 201
def post(self, invitedGuest=False):
args = self.req_parser.parse_args()
email = args['email']
firstname = args['firstname']
lastname = args['lastname']
user_title = args['user_title']
policy_agreed = args['policy_agreed']
if (invitedGuest):
password = self.randomPassword()
else:
password = args['password']
if (password is None):
return MISSING_PASSWORD
if not policy_agreed:
return POLICY_NOT_AGREED
LOGGER.info("Registering email: {}".format(email))
user = AppUser(email=email,
firstname=firstname,
lastname=lastname,
user_title=user_title,
password=password,
organisation_id=g.organisation.id)
db.session.add(user)
try:
db.session.commit()
except IntegrityError:
LOGGER.error("email: {} already in use".format(email))
return EMAIL_IN_USE
if (not invitedGuest):
send_mail(recipient=user.email,
sender_name=g.organisation.name,
sender_email=g.organisation.email_from,
subject='{} Email Verification'.format(
g.organisation.system_name),
body_text=VERIFY_EMAIL_BODY.format(
title=user_title,
firstname=firstname,
lastname=lastname,
system=g.organisation.system_name,
organisation=g.organisation.name,
host=misc.get_baobab_host(),
token=user.verify_token))
LOGGER.debug("Sent verification email to {}".format(user.email))
else:
user.verified_email = True
try:
db.session.commit()
except IntegrityError:
LOGGER.error("Unable to verify email: {}".format(email))
return VERIFY_EMAIL_INVITED_GUEST
return user_info(user, []), 201
def post(self):
args = self.req_parser.parse_args()
event_id = args['event_id']
user_id = args['user_id']
registration_user_id = g.current_user['id']
registration_user = user_repository.get_by_id(registration_user_id)
if not registration_user.is_registration_volunteer(event_id):
return FORBIDDEN
event = event_repository.get_by_id(event_id)
if event is None:
return EVENT_NOT_FOUND
user = user_repository.get_by_id(user_id)
if user is None:
return USER_NOT_FOUND
if attendance_repository.exists(event_id, user_id):
return ATTENDANCE_ALREADY_CONFIRMED
attendance = Attendance(event_id, user_id, registration_user_id)
attendance_repository.create(attendance)
send_mail(recipient=user.email,
subject='Welcome to {}'.format(event.name),
body_text=ATTENDANCE_EMAIL_BODY.format(
user_title=user.user_title,
first_name=user.firstname,
last_name=user.lastname,
event_name=event.name))
# Other Fields
unavailable_response = None
invitedguest_role = unavailable_response
is_invited_guest = unavailable_response
has_accepted_accom_award = unavailable_response
offer = db.session.query(Offer).filter(
Offer.user_id == user_id).filter(
Offer.event_id == event_id).first()
if offer:
has_accepted_accom_award = (offer.accommodation_award
and offer.accepted_accommodation_award)
# Check if invited guest
invited_guest = db.session.query(InvitedGuest).filter(
InvitedGuest.event_id == event_id).filter(
InvitedGuest.user_id == user.id).first()
if (invited_guest):
is_invited_guest = True
invitedguest_role = invited_guest.role
# Shirt Size
shirt_answer = (
get_registration_answer_based_headline(user_id, "T-Shirt Size")
and get_registration_answer_based_headline(
user_id, "T-Shirt Size").value) or unavailable_response
# Poster registration
bringing_poster = False
poster_answer = get_registration_answer_based_headline(
user_id, "Will you be bringing a poster?")
if (poster_answer is not None and poster_answer.value == 'yes'):
bringing_poster = True
attendance_user = AttendanceUser(attendance, has_accepted_accom_award,
shirt_answer, is_invited_guest,
bringing_poster, invitedguest_role)
return attendance_user, 201
def generate(template_path, event_id, work_address, addressed_to,
residential_address, passport_name, passport_no,
passport_issued_by, invitation_letter_sent_at, to_date, from_date,
country_of_residence, nationality, date_of_birth, email,
user_title, firstname, lastname, bringing_poster, expiry_date):
check_values(template_path, event_id, work_address, addressed_to,
residential_address, passport_name, passport_no,
passport_issued_by, invitation_letter_sent_at, to_date,
from_date, country_of_residence, nationality, date_of_birth,
email, user_title, firstname, lastname, bringing_poster,
expiry_date)
# Path to store the template locally of merged and unmerged
template = 'app/invitationletter/template/tmp.docx'
template_merged = 'app/invitationletter/template/template.docx'
download_blob(bucket_name=GCP_BUCKET_NAME,
source_blob_name=template_path,
destination_file_name=template)
if not os.path.exists(template):
return errors.TEMPLATE_NOT_FOUND
document = MailMerge(template)
LOGGER.debug("merge-fields.... {} .".format(document.get_merge_fields()))
document.merge(TITLE=user_title,
FIRSTNAME=firstname,
LASTNAME=lastname,
WORK_ADDRESS=work_address.decode('utf-8'),
ADDRESSED_TO=addressed_to.decode('utf-8'),
RESIDENTIAL_ADDRESS=residential_address.decode('utf-8'),
PASSPORT_NAME=passport_name.decode('utf-8'),
PASSPORT_NO=passport_no.decode('utf-8'),
ISSUED_BY=passport_issued_by.decode('utf-8'),
EXPIRY_DATE=expiry_date,
ACCOMODATION_END_DATE=to_date,
ACCOMODATION_START_DATE=from_date,
COUNTRY_OF_RESIDENCE=country_of_residence.decode('utf-8'),
NATIONALITY=nationality,
DATE_OF_BIRTH=date_of_birth,
INVITATION_LETTER_SENT_AT=invitation_letter_sent_at,
BRINGING_POSTER=bringing_poster)
document.write(template_merged)
# Conversion
template_pdf = 'app/invitationletter/letter/template.pdf'
if os.path.exists(template_pdf):
os.remove(template_pdf)
success = pdfconvertor.convert_to(folder='app/invitationletter/letter',
source=template_merged,
output=template_pdf)
if not success:
return errors.CREATING_INVITATION_FAILED
event = db.session.query(Event).get(event_id)
if not event:
return errors.EVENT_NOT_FOUND
subject = "Invitation Letter for " + event.name
try:
emailer.send_mail(recipient=email,
subject=subject,
body_text=INVITATION_EMAIL_BODY.format(
user_title=user_title,
first_name=firstname,
last_name=lastname),
file_name="InvitationLetter.pdf",
file_path=template_pdf)
LOGGER.debug('successfully sent email...')
return True
except ValueError:
LOGGER.debug('Did not send email...')
return False
return False
def post(self, invitedGuest=False):
args = self.req_parser.parse_args()
email = args['email']
firstname = args['firstname']
lastname = args['lastname']
user_title = args['user_title']
nationality_country_id = args['nationality_country_id']
residence_country_id = args['residence_country_id']
user_gender = args['user_gender']
affiliation = args['affiliation']
department = args['department']
user_disability = args['user_disability']
user_category_id = args['user_category_id']
if (invitedGuest):
password = self.randomPassword()
else:
password = args['password']
if (password is None):
return MISSING_PASSWORD
user_dateOfBirth = datetime.strptime((args['user_dateOfBirth']),
'%Y-%m-%dT%H:%M:%S.%fZ')
user_primaryLanguage = args['user_primaryLanguage']
LOGGER.info("Registering email: {}".format(email))
user = AppUser(email=email,
firstname=firstname,
lastname=lastname,
user_title=user_title,
nationality_country_id=nationality_country_id,
residence_country_id=residence_country_id,
user_gender=user_gender,
affiliation=affiliation,
department=department,
user_disability=user_disability,
user_category_id=user_category_id,
user_dateOfBirth=user_dateOfBirth,
user_primaryLanguage=user_primaryLanguage,
password=password)
db.session.add(user)
try:
db.session.commit()
except IntegrityError:
LOGGER.error("email: {} already in use".format(email))
return EMAIL_IN_USE
if (not invitedGuest):
send_mail(recipient=user.email,
subject='Baobab Email Verification',
body_text=VERIFY_EMAIL_BODY.format(
user_title, firstname, lastname, get_baobab_host(),
user.verify_token))
LOGGER.debug("Sent verification email to {}".format(user.email))
else:
user.verified_email = True
try:
db.session.commit()
except IntegrityError:
LOGGER.error("Unable to verify email: {}".format(email))
return VERIFY_EMAIL_INVITED_GUEST
return user_info(user, []), 201
