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, user):
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
try:
emailer.email_user(
'invitation-letter',
event=event,
user=user,
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 get(self):
LOGGER.debug('Received get request for reference-request')
args = self.get_req_parser.parse_args()
return reference_request_repository.get_by_id(args['id']), 200
def send_mail(recipient,
subject,
body_text='',
body_html='',
charset='UTF-8',
mail_type='AMZ',
file_name='',
file_path='',
sender_name=None,
sender_email=None):
'''[summary]
Arguments:
recipient {[type]} -- [description]
subject {[type]} -- [description]
body_text {[type]} -- [description]
Keyword Arguments:
body_html {[type]} -- [description] (default: {None})
type {str} -- [description] (default: {'AMZ'})
Raises:
e -- [description]
'''
sender_name = sender_name or SMTP_SENDER_NAME
sender_email = sender_email or SMTP_SENDER_EMAIL
if (not DEBUG):
if mail_type == 'AMZ':
try:
msg = MIMEMultipart()
msg['Subject'] = subject
msg['From'] = email.utils.formataddr(
(sender_name, sender_email))
msg['To'] = recipient
body_part1 = MIMEText(body_text, 'plain', _charset=charset)
body_part2 = MIMEText(body_html, 'html', _charset=charset)
if file_name != "" and file_path != "":
attachment = open(file_path, "rb")
part = MIMEBase('application', 'octet-stream')
part.set_payload(attachment.read())
encoders.encode_base64(part)
part.add_header('Content-Disposition',
"attachment; filename= %s" % file_name)
msg.attach(part)
msg.attach(body_part1)
msg.attach(body_part2)
server = smtplib.SMTP(SMTP_HOST, SMTP_PORT)
server.ehlo()
server.starttls()
server.ehlo()
server.login(SMTP_USERNAME, SMTP_PASSWORD)
server.sendmail(sender_email, recipient, msg.as_string())
server.close()
except Exception as e:
LOGGER.error(
"Exception {} while trying to send email: {}, {}".format(
e, traceback.format_exc()))
raise e
else:
LOGGER.debug(
'Sender Name: {sender_name}'.format(sender_name=sender_name))
LOGGER.debug(
'Sender Email: {sender_email}'.format(sender_email=sender_email))
LOGGER.debug('Recipient : {recipient}'.format(recipient=recipient))
LOGGER.debug('Subject : {subject}'.format(subject=subject))
LOGGER.debug('Body Text : {body}'.format(body=body_text))
LOGGER.debug('Body HTML : {body}'.format(body=body_html))
def _log_application_status(context):
LOGGER.debug("Application {} for user_id: {}, event_id: {}".format(
context, user_id, event_id))
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']
user_primaryLanguage = args['language']
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)
user.user_primaryLanguage = user_primaryLanguage
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):
email_user(
'verify-email',
template_parameters=dict(
system=g.organisation.system_name,
organisation=g.organisation.name,
host=misc.get_baobab_host(),
token=user.verify_token
),
user=user,
subject_parameters=dict(system=g.organisation.system_name))
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
parser.add_argument('--port',
metavar='PORT',
default=80,
help='Specify port.')
return parser.parse_args()
if __name__ == '__main__':
arguments = parse_args()
if arguments.debug == True:
ENABLE_LOGGING_DEBUG()
#read csv step_codes
parse_csv("app/static/Cisco_Identity_Services_Engine_Log_Messages_20.csv")
LOGGER.debug(step_codes['3000'])
# Start UDP Server
if not isfile(LOG_FILE):
with open(LOG_FILE, 'a') as current_file:
current_file.write('')
udp_thread = threading.Thread(target=initialize_udp_server,
args=(0.5, '0.0.0.0', 8514),
daemon=True)
udp_thread.start()
website.run(host=arguments.ip, port=arguments.port, debug=arguments.debug)
def get(self):
args = self.get_req_parser.parse_args()
user_id = g.current_user['id']
event_id = args['event_id']
page_number = args['page_number']
limit = args['limit']
sort_column = args['sort_column']
reviewer = db.session.query(AppUser).get(user_id).is_reviewer(event_id)
if not reviewer:
return FORBIDDEN
form_id = db.session.query(
ApplicationForm.id).filter_by(event_id=event_id).first()[0]
reviews = (db.session.query(
ReviewResponse.id, ReviewResponse.submitted_timestamp, AppUser,
ReviewScore.value, ReviewQuestion.options).filter(
ReviewResponse.reviewer_user_id == user_id).join(
ReviewForm,
ReviewForm.id == ReviewResponse.review_form_id).filter(
ReviewForm.application_form_id == form_id).join(
Response,
ReviewResponse.response_id == Response.id).join(
ReviewQuestion,
ReviewForm.id == ReviewQuestion.review_form_id)
.filter(ReviewQuestion.headline == 'Final Verdict').join(
ReviewScore,
and_(
ReviewQuestion.id == ReviewScore.review_question_id,
ReviewResponse.id ==
ReviewScore.review_response_id)).join(
AppUser, Response.user_id == AppUser.id))
if sort_column == 'review_response_id':
reviews = reviews.order_by(ReviewResponse.id)
if sort_column == 'submitted_timestamp':
reviews = reviews.order_by(ReviewResponse.submitted_timestamp)
if sort_column == 'nationality_country':
reviews = reviews.join(
Country,
AppUser.nationality_country_id == Country.id).order_by(
Country.name)
if sort_column == 'residence_country':
reviews = reviews.join(
Country, AppUser.residence_country_id == Country.id).order_by(
Country.name)
if sort_column == 'affiliation':
reviews = reviews.order_by(AppUser.affiliation)
if sort_column == 'department':
reviews = reviews.order_by(AppUser.department)
if sort_column == 'user_category':
reviews = reviews.join(
UserCategory,
AppUser.user_category_id == UserCategory.id).order_by(
UserCategory.name)
if sort_column == 'final_verdict':
reviews = reviews.order_by(ReviewScore.value)
reviews = reviews.slice(page_number * limit,
page_number * limit + limit).all()
num_entries = (db.session.query(ReviewResponse).filter(
ReviewResponse.reviewer_user_id == user_id).join(
ReviewForm,
ReviewForm.id == ReviewResponse.review_form_id).filter(
ReviewForm.application_form_id == form_id).count())
total_pages = ceil(float(num_entries) / limit)
LOGGER.debug(reviews)
reviews = [ReviewHistoryModel(review) for review in reviews]
return {
'reviews': reviews,
'num_entries': num_entries,
'current_pagenumber': page_number,
'total_pages': total_pages
}
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
