def get_subject(self):
if self.email_type == EVENT:
from app.dao.events_dao import dao_get_event_by_id
event = dao_get_event_by_id(str(self.event_id))
return "{}: {}".format(event.event_type.event_type, event.title)
return 'No email type'
def it_gets_event_by_id(self, db, db_session, sample_event,
sample_event_type):
create_event(title='test title 2', event_type_id=sample_event_type.id)
event_from_db = dao_get_event_by_id(sample_event.id)
assert Event.query.count() == 2
assert event_from_db == sample_event
def dao_create_email(email):
if email.email_type == EVENT:
try:
event = dao_get_event_by_id(email.event_id)
email.subject = u"{}: {}".format(event.event_type.event_type,
event.title)
if not email.send_starts_at:
email.send_starts_at = datetime.strptime(
event.get_first_event_date(),
"%Y-%m-%d") - timedelta(weeks=2)
if not email.expires:
email.expires = event.get_last_event_date()
except NoResultFound:
raise InvalidRequest('event not found: {}'.format(email.event_id),
400)
elif email.email_type == MAGAZINE and not email.old_id:
if email.magazine_id:
try:
magazine = dao_get_magazine_by_id(email.magazine_id)
email.subject = u"New Acropolis bi-monthly magazine: {}".format(
magazine.title)
if not email.send_starts_at:
email.send_starts_at = _get_nearest_bi_monthly_send_date()
email.expires = email.send_starts_at + timedelta(weeks=2)
except NoResultFound:
raise InvalidRequest(
'magazine not found: {}'.format(email.event_id), 400)
else:
current_app.logger.info('No magazine id for email')
return
db.session.add(email)
return True
def it_gets_event_by_id_with_reject_reason(self, db_session,
sample_event_type,
sample_reject_reason):
event_from_db = dao_get_event_by_id(sample_reject_reason.event_id)
assert Event.query.count() == 1
assert event_from_db.reject_reasons == [sample_reject_reason]
def delete_event(event_id):
dao_delete_event(event_id)
try:
event = dao_get_event_by_id(event_id)
if event:
raise InvalidRequest("{} was not deleted".format(event_id), 500)
except NoResultFound:
current_app.logger.info('{} deleted'.format(event_id))
return jsonify({'message': '{} deleted'.format(event_id)}), 200
def get_email_html(email_type, **kwargs):
if email_type == EVENT:
event = dao_get_event_by_id(kwargs.get('event_id'))
return render_template(
'emails/events.html',
event=event,
event_dates=get_nice_event_dates(event.event_dates),
description=h.unescape(event.description),
details=kwargs.get('details'),
extra_txt=kwargs.get('extra_txt'),
)
def get_default_details(event_id):
event = dao_get_event_by_id(event_id)
fees = f"<div><strong>Fees:</strong> £{event.fee}, £{event.conc_fee} concession for students, "\
"income support & OAPs, and free for members of New Acropolis.</div>"
if event.fee == 0:
fees = "<div><strong>Fees:</strong> Free Admission</div>"
elif event.fee == -2:
fees = "<div><strong>Fees:</strong> External site</div>"
elif event.fee == -3:
fees = "<div><strong>Fees:</strong> Donation</div>"
details = f"{fees}<div><strong>Venue:</strong> {event.venue.address}</div>{event.venue.directions}"
return jsonify({'details': details})
def get_expired_date(self):
if self.email_type == EVENT:
from app.dao.events_dao import dao_get_event_by_id
event = dao_get_event_by_id(str(self.event_id))
return event.get_last_event_date()
elif self.email_type == MAGAZINE:
from app.dao.emails_dao import _get_nearest_bi_monthly_send_date
send_start = _get_nearest_bi_monthly_send_date(
created_at=self.created_at)
return (send_start +
datetime.timedelta(weeks=2)).strftime('%Y-%m-%d')
def get_email_html(email_type, **kwargs):
member_id = kwargs.get('member_id')
unsubcode = encrypt(
"{}={}".format(current_app.config['EMAIL_TOKENS']['member_id'],
member_id),
current_app.config['EMAIL_UNSUB_SALT']) if member_id else None
if email_type == EVENT:
event = dao_get_event_by_id(kwargs.get('event_id'))
current_app.logger.debug('Email Tokens %s',
current_app.config['EMAIL_TOKENS'])
return render_template(
'emails/events.html',
event=event,
event_dates=get_nice_event_dates(event.event_dates),
description=h.unescape(event.description),
details=kwargs.get('details'),
extra_txt=kwargs.get('extra_txt'),
unsubcode=unsubcode,
remote_access=kwargs.get('remote_access'),
remote_pw=kwargs.get('remote_pw'),
)
elif email_type == MAGAZINE:
magazine = dao_get_magazine_by_id(kwargs.get('magazine_id'))
topics = []
if magazine.topics:
if all([':' in t for t in magazine.topics.split('\n')]):
_topics = [(t.split(':')[0], t.split(':')[1])
for t in magazine.topics.split('\n')]
else:
_topics = [
("Missing divider",
"Use : as divider between topic header and sub-header"),
("Topics", magazine.topics)
]
for title, description in _topics:
topics.append({'title': title, 'description': description})
return render_template('emails/magazine.html',
magazine=magazine,
topics=topics,
unsubcode=unsubcode)
elif email_type == BASIC:
return render_template('emails/basic.html',
title=kwargs.get('title', ''),
message=kwargs.get('message'),
unsubcode=unsubcode)
def get_email_html(email_type, **kwargs):
if email_type == EVENT:
event = dao_get_event_by_id(kwargs.get('event_id'))
member_id = kwargs.get('member_id')
if not member_id:
member_id = '0' # for preview of emails
current_app.logger.debug('Email Tokens %s',
current_app.config['EMAIL_TOKENS'])
unsubcode = encrypt(
"{}={}".format(current_app.config['EMAIL_TOKENS']['member_id'],
member_id), current_app.config['EMAIL_UNSUB_SALT'])
return render_template('emails/events.html',
event=event,
event_dates=get_nice_event_dates(
event.event_dates),
description=h.unescape(event.description),
details=kwargs.get('details'),
extra_txt=kwargs.get('extra_txt'),
unsubcode=unsubcode)
def create_update_paypal_button_task(self, event_id):
current_app.logger.info('Task create_paypal_button received for event %s',
str(event_id))
try:
event = dao_get_event_by_id(event_id)
if not event.booking_code:
dao_update_event(event_id,
booking_code=f'pending: {self.request.id}')
booking_code = event.booking_code
if event.booking_code.startswith(
'pending:') or event.booking_code.startswith('error:'):
booking_code = None
p = PayPal()
booking_code = p.create_update_paypal_button(
event_id,
event.title,
event.fee,
event.conc_fee,
event.multi_day_fee,
event.multi_day_conc_fee,
True if event.event_type == 'Talk' else False,
booking_code=booking_code)
dao_update_event(event_id, booking_code=booking_code)
except NoResultFound as e:
current_app.logger.error(
f'No result error trying to create_update_paypal_button {e} {event_id}'
)
except PaypalException as e:
dao_update_event(event_id, booking_code=f'error: {str(e)[:40]}')
current_app.logger.error(
f'Paypal error trying to create_update_paypal_button {e} {event_id}'
)
def get_subject(self):
if self.email_type == EVENT:
from app.dao.events_dao import dao_get_event_by_id
event = dao_get_event_by_id(str(self.event_id))
return u"{}: {}".format(event.event_type.event_type, event.title)
elif self.email_type == MAGAZINE:
if self.magazine_id:
from app.dao.magazines_dao import dao_get_magazine_by_id
magazine = dao_get_magazine_by_id(str(self.magazine_id))
else:
from app.dao.magazines_dao import dao_get_magazine_by_title
issue_no = self.details.split(' ')[-1]
magazine = dao_get_magazine_by_title('Issue ' + issue_no)
if magazine:
current_app.logger.info('magazine found %s' % magazine.title)
return u"New Acropolis bi-monthly magazine: {}".format(
magazine.title)
current_app.logger.error('No magazine found')
return "Magazine not found"
return 'No email type'
def parse_ipn(ipn, replace_order=False):
order_data = {}
receiver_email = None
errors = []
short_response = order_data, None, None, None, None, errors
tickets = []
events = []
products = []
delivery_zones = []
custom_map = 'linked_txn_id'
if 'custom' in ipn.keys() and ipn['custom'] == 'Donation':
custom_map = 'is_donation'
order_mapping = {
'custom': custom_map,
'payer_email': 'email_address',
'first_name': 'first_name',
'last_name': 'last_name',
'payment_status': 'payment_status',
'txn_type': 'txn_type',
'mc_gross': 'payment_total',
'txn_id': 'txn_id',
'payment_date': 'created_at',
'address_street': 'address_street',
'address_city': 'address_city',
'address_zip': 'address_postal_code',
'address_state': 'address_state',
'address_country': 'address_country',
'address_country_code': 'address_country_code',
}
for key in ipn.keys():
if key == 'receiver_email':
receiver_email = ipn[key]
if key in order_mapping.keys():
order_data[order_mapping[key]] = ipn[key]
order_data['buyer_name'] = '{} {}'.format(order_data['first_name'],
order_data['last_name'])
del order_data['first_name']
del order_data['last_name']
if order_data['payment_status'] != 'Completed':
current_app.logger.error('Order: %s, payment not complete: %s',
order_data['txn_id'],
order_data['payment_status'])
return short_response
if receiver_email.replace(' ',
'+') != current_app.config['PAYPAL_RECEIVER']:
current_app.logger.error('Paypal receiver not valid: %s for %s',
receiver_email, order_data['txn_id'])
order_data['payment_status'] = 'Invalid receiver'
return short_response
order_found = dao_get_order_with_txn_id(order_data['txn_id'])
if order_found:
if replace_order:
current_app.logger.info(
f'Replacing order txn_id: {order_data["txn_id"]}')
dao_delete_order(order_data['txn_id'])
# truncate txn_id to remove XX-INVALID-nnnnnnnnnn- for original txn id
if order_data['txn_id'].startswith('XX-'):
order_data['txn_id'] = order_data['txn_id'][22:]
elif order_data['txn_id'].startswith('INVALID_'):
order_data['txn_id'] = order_data['txn_id'][19:]
else:
msg = f"Order: {order_data['txn_id']}, payment already made"
current_app.logger.error(msg)
errors.append(msg)
return short_response
if ipn['txn_type'] == 'paypal_here':
_event_date = datetime.strptime(
ipn['payment_date'], '%H:%M:%S %b %d, %Y PST').strftime('%Y-%m-%d')
event_date = dao_get_event_date_on_date(_event_date)
ticket = {
'ticket_number': 1,
'event_id': event_date.event_id,
'eventdate_id': event_date.id,
'status': TICKET_STATUS_USED
}
event = dao_get_event_by_id(event_date.event_id)
events.append(event)
tickets.append(ticket)
elif ipn['txn_type'] != 'web_accept':
counter = 1
while ('item_number%d' % counter) in ipn:
quantity = int(ipn['quantity%d' % counter])
price = float("{0:.2f}".format(
float(ipn['mc_gross_%d' % counter]) / quantity))
if ipn['item_number%d' % counter].startswith('delivery'):
delivery_zone = ipn['option_selection1_%d' % counter]
if 'delivery_zone' not in order_data.keys():
order_data['delivery_zone'] = delivery_zone
else:
current_app.logger.error(
f"Multiple delivery costs in order: {order_data['txn_id']}"
)
delivery_zones.append(delivery_zone)
elif ipn['item_number%d' % counter].startswith('book-'):
book_id = ipn['item_number%d' % counter][len("book-"):]
UUID_LENGTH = 36
if len(book_id) < UUID_LENGTH:
book = dao_get_book_by_old_id(book_id)
else:
book = dao_get_book_by_id(book_id)
if book:
products.append({
"type": BOOK,
"book_id": book.id,
"title": book.title,
"quantity": quantity,
"price": price
})
else:
msg = f"Book not found for item_number: {book_id}"
current_app.logger.error(msg)
counter += 1
errors.append(msg)
continue
else:
try:
event = dao_get_event_by_id(ipn['item_number%d' % counter])
events.append(event)
except NoResultFound:
msg = f"Event not found for item_number: {ipn['item_number%d' % counter]}"
current_app.logger.error(msg)
counter += 1
errors.append(msg)
continue
if 'option_name2_%d' % counter in ipn.keys():
if ipn['option_selection2_%d' % counter] == 'all':
event_date_index = -1
else:
event_date_index = int(ipn['option_selection2_%d' % counter]) \
if ipn['option_name2_%d' % counter] == 'Date' else 1
else:
event_date_index = 1
def create_ticket(event_date_id):
for i in range(1, quantity + 1):
ticket = {
'ticket_number':
i,
'event_id':
event.id,
'ticket_type':
ipn['option_selection1_%d' % counter],
'eventdate_id':
event_date_id,
'price':
price,
'name':
ipn.get('option_selection3_%d' % counter)
if ipn.get('option_name3_%d' %
counter) == 'Course Member name' else
ipn.get('option_selection2_%d' % counter) if
ipn.get('option_name2_%d' %
counter) == 'Course Member name' else None
}
tickets.append(ticket)
if event_date_index == -1:
for event_date_idx in range(0, len(event.event_dates)):
event_date_id = event.event_dates[event_date_idx].id
create_ticket(event_date_id)
else:
if event_date_index > len(event.event_dates):
error_msg = f"Event date {event_date_index} not found for: {ipn['item_number%d' % counter]}"
current_app.logger.error(error_msg)
counter += 1
errors.append(error_msg)
continue
event_date_id = event.event_dates[event_date_index - 1].id
create_ticket(event_date_id)
counter += 1
return order_data, tickets, events, products, delivery_zones, errors
def update_email(email_id):
data = request.get_json(force=True)
validate(data, post_update_email_schema)
if data['email_type'] == EVENT:
try:
event = dao_get_event_by_id(data.get('event_id'))
except NoResultFound:
raise InvalidRequest(
'event not found: {}'.format(data.get('event_id')), 400)
email_data = {}
for k in data.keys():
if hasattr(Email, k):
email_data[k] = data[k]
current_app.logger.info('Update email: {}'.format(email_data))
res = dao_update_email(email_id, **email_data)
if res:
email = dao_get_email_by_id(email_id)
response = None
emails_to = [user.email for user in dao_get_users()]
if data.get('email_state') == READY:
# send email to admin users and ask them to log in in order to approve the email
review_part = '<div>Please review this email: {}/emails/{}</div>'.format(
current_app.config['FRONTEND_ADMIN_URL'], str(email.id))
subject = None
if email.email_type == EVENT:
event = dao_get_event_by_id(email.event_id)
subject = 'Please review {}'.format(event.title)
event_html = get_email_html(**data)
response = send_smtp_email(emails_to, subject,
review_part + event_html)
elif email.email_type == MAGAZINE:
magazine = dao_get_magazine_by_id(email.magazine_id)
subject = 'Please review {}'.format(magazine.title)
magazine_html = get_email_html(MAGAZINE,
magazine_id=magazine.id)
response = send_smtp_email(emails_to, subject,
review_part + magazine_html)
elif data.get('email_state') == REJECTED:
dao_update_email(email_id, email_state=REJECTED)
message = '<div>Please correct this email <a href="{}">{}</a></div>'.format(
'{}/emails/{}'.format(current_app.config['FRONTEND_ADMIN_URL'],
str(email.id)), email.get_subject())
message += '<div>Reason: {}</div>'.format(
data.get('reject_reason'))
response = send_smtp_email(
emails_to,
'{} email needs to be corrected'.format(event.title), message)
elif data.get('email_state') == APPROVED:
later = datetime.utcnow() + timedelta(
hours=current_app.config['EMAIL_DELAY'])
if later < email.send_starts_at:
later = email.send_starts_at + timedelta(hours=9)
dao_update_email(email_id, send_after=later)
review_part = '<div>Email will be sent after {}, log in to reject: {}/emails/{}</div>'.format(
later.strftime("%d/%m/%Y %H:%M"),
current_app.config['FRONTEND_ADMIN_URL'], str(email.id))
if email.email_type == EVENT:
event_html = get_email_html(**data)
response = send_smtp_email(
emails_to,
"{} has been approved".format(email.get_subject()),
review_part + event_html)
email_json = email.serialize()
if response:
email_json['email_status_code'] = response
return jsonify(email_json), 200
raise InvalidRequest('{} did not update email'.format(email_id), 400)
def parse_ipn(ipn):
order_data = {}
receiver_email = None
tickets = []
events = []
order_mapping = {
'payer_email': 'email_address',
'first_name': 'first_name',
'last_name': 'last_name',
'payment_status': 'payment_status',
'txn_type': 'txn_type',
'mc_gross': 'payment_total',
'txn_id': 'txn_id',
}
for key in ipn.keys():
if key == 'receiver_email':
receiver_email = ipn[key]
if key in order_mapping.keys():
order_data[order_mapping[key]] = ipn[key]
if order_data['payment_status'] != 'Completed':
current_app.logger.error('Order: %s, payment not complete: %s',
order_data['txn_id'],
order_data['payment_status'])
return None, None, None
if receiver_email != current_app.config['PAYPAL_RECEIVER']:
current_app.logger.error('Paypal receiver not valid: %s for %s',
receiver_email, order_data['txn_id'])
order_data['payment_status'] = 'Invalid receiver'
return None, None, None
order_found = dao_get_order_with_txn_id(order_data['txn_id'])
if order_found:
current_app.logger.error('Order: %s, payment already made',
order_data['txn_id'])
return None, None, None
if ipn['txn_type'] == 'paypal_here':
_event_date = datetime.strptime(
ipn['payment_date'], '%H:%M:%S %b %d, %Y PST').strftime('%Y-%m-%d')
event_date = dao_get_event_date_on_date(_event_date)
ticket = {
'ticket_number': 1,
'event_id': event_date.event_id,
'eventdate_id': event_date.id,
'status': TICKET_STATUS_USED
}
event = dao_get_event_by_id(event_date.event_id)
events.append(event)
tickets.append(ticket)
else:
counter = 1
while ('item_number%d' % counter) in ipn:
try:
event = dao_get_event_by_id(ipn['item_number%d' % counter])
events.append(event)
except NoResultFound:
current_app.logger.error("Event not found for item_number: %s",
ipn['item_number%d' % counter])
counter += 1
continue
event_date_index = int(ipn['option_selection2_%d' % counter]) \
if ipn['option_name2_%d' % counter] == 'Date' else None
if not event_date_index:
event_date_index = 1
if event_date_index > len(event.event_dates):
current_app.logger.error("Event date %s not found for: %s",
event_date_index,
ipn['item_number%d' % counter])
counter += 1
continue
event_date_id = event.event_dates[event_date_index - 1].id
quantity = int(ipn['quantity%d' % counter])
price = float("{0:.2f}".format(
float(ipn['mc_gross_%d' % counter]) / quantity))
for i in range(1, quantity + 1):
ticket = {
'ticket_number':
i,
'event_id':
event.id,
'ticket_type':
ipn['option_selection1_%d' % counter],
'eventdate_id':
event_date_id,
'price':
price,
'name':
ipn.get('option_selection3_%d' % counter) if ipn.get(
'option_name3_%d' % counter) == 'Course Member name'
else ipn.get('option_selection2_%d' % counter)
if ipn['option_name2_%d' %
counter] == 'Course Member name' else None
}
tickets.append(ticket)
counter += 1
if not tickets:
current_app.logger.error('No valid tickets, no order created: %s',
order_data['txn_id'])
return None, None, None
order_data['buyer_name'] = '{} {}'.format(order_data['first_name'],
order_data['last_name'])
del order_data['first_name']
del order_data['last_name']
return order_data, tickets, events
def update_event(event_id):
data = request.get_json(force=True)
current_app.logger.info('Update event: {}'.format(data))
validate(data, post_update_event_schema)
try:
event = dao_get_event_by_id(event_id)
except NoResultFound:
raise InvalidRequest('event not found: {}'.format(event_id), 400)
errs = []
event_dates = []
event_data = {}
if data.get('event_state') == REJECTED:
new_rejects = [
r for r in data.get('reject_reasons') if not r.get('id')
]
if not new_rejects:
raise InvalidRequest('rejected event requires new reject reason',
400)
elif data.get('event_state') == APPROVED:
if data.get('reject_reasons'):
rejects = [
r for r in data.get('reject_reasons') if not r.get('resolved')
]
if rejects:
raise InvalidRequest(
'approved event should not have any reject reasons', 400)
data_event_dates = data.get('event_dates')
if data_event_dates:
serialized_event_dates = event.serialize_event_dates()
data_event_dates__dates = [e['event_date'] for e in data_event_dates]
serialized_event_dates__dates = [
e['event_datetime'] for e in serialized_event_dates
]
diff_add = set(data_event_dates__dates).difference(
serialized_event_dates__dates)
intersect = set(data_event_dates__dates).intersection(
serialized_event_dates__dates)
dates_to_add = [
e for e in data_event_dates if e['event_date'] in diff_add
]
dates_to_update = [
e for e in data_event_dates if e['event_date'] in intersect
]
for _date in dates_to_add:
speakers = []
for s in _date.get('speakers', []):
speaker = dao_get_speaker_by_id(s['speaker_id'])
speakers.append(speaker)
e = EventDate(event_id=event_id,
event_datetime=_date['event_date'],
end_time=_date.get('end_time'),
speakers=speakers)
current_app.logger.info('Adding event date: {}'.format(
_date['event_date']))
dao_create_event_date(e)
if _date['event_date'] not in [
_e.event_datetime for _e in event_dates
]:
event_dates.append(e)
for _date in sorted(dates_to_update, key=lambda k: k['event_date']):
speakers = []
for s in _date['speakers']:
speaker = dao_get_speaker_by_id(s['speaker_id'])
speakers.append(speaker)
db_event_date = [
e for e in event.event_dates if e.event_datetime.strftime(
'%Y-%m-%d %H:%M') == _date['event_date']
][0]
db_event_date.speakers = speakers
if _date['event_date'] not in [
_e.event_datetime for _e in event_dates
]:
event_dates.append(db_event_date)
if data.get('reject_reasons'):
for reject_reason in data.get('reject_reasons'):
if reject_reason.get('id'):
reject_data = {
'reason': reject_reason['reason'],
'resolved': reject_reason.get('resolved') or False
}
dao_update_reject_reason(reject_reason.get('id'),
**reject_data)
else:
rr = RejectReason(event_id=event_id,
reason=reject_reason['reason'],
resolved=reject_reason.get('resolved')
or False,
created_by=reject_reason.get('created_by'))
dao_create_reject_reason(rr)
event_data = {}
for k in data.keys():
if hasattr(Event, k) and k not in ['reject_reasons']:
event_data[k] = data[k]
if event_dates:
event_data['event_dates'] = event_dates
elif data_event_dates == []:
raise InvalidRequest('{} needs an event date'.format(event_id), 400)
if event_data.get('fee') and event_data.get('fee') > 0:
update_data = {
'fee': event_data.get('fee'),
'conc_fee': event_data.get('conc_fee'),
'multi_day_fee': event_data.get('multi_day_fee') or 0,
'multi_day_conc_fee': event_data.get('multi_day_conc_fee') or 0,
'event_type_id': event_data.get('event_type_id'),
}
db_data = {
'fee': event.fee,
'conc_fee': event.conc_fee,
'multi_day_fee': event.multi_day_fee,
'multi_day_conc_fee': event.multi_day_conc_fee,
'event_type_id': str(event.event_type.id),
}
if update_data != db_data:
if data.get('event_state') in [READY, APPROVED]:
paypal_tasks.create_update_paypal_button_task.apply_async(
(str(event_id), ))
res = dao_update_event(event_id, **event_data)
if res:
image_data = data.get('image_data')
image_filename = data.get('image_filename')
if current_app.config['STORAGE'].startswith('None'):
current_app.logger.warn('Storage not setup')
else:
storage = Storage(current_app.config['STORAGE'])
if image_data:
event_year = str(
event.event_dates[0].event_datetime).split('-')[0]
target_image_filename = '{}/{}'.format(event_year,
str(event_id))
if data.get('event_state') != APPROVED:
target_image_filename += '-temp'
storage.upload_blob_from_base64string(
image_filename, target_image_filename,
base64.b64decode(image_data))
unix_time = time.time()
image_filename = '{}?{}'.format(target_image_filename,
unix_time)
elif image_filename:
image_filename_without_cache_buster = image_filename.split(
'?')[0]
if not storage.blob_exists(
image_filename_without_cache_buster):
raise InvalidRequest(
'{} does not exist'.format(
image_filename_without_cache_buster), 400)
if image_filename:
if data.get('event_state') == APPROVED:
if '-temp' in image_filename:
q_pos = image_filename.index('-temp?')
image_filename = image_filename[0:q_pos]
storage.rename_image(image_filename + '-temp',
image_filename)
else:
current_app.logger.warn(
f"No temp file to rename: {image_filename}")
event.image_filename = image_filename
dao_update_event(event.id, image_filename=image_filename)
json_event = event.serialize()
if data.get('event_state') == READY:
emails_to = [admin.email for admin in dao_get_admin_users()]
message = 'Please review this event for publishing <a href="{}">{}</a>'.format(
'{}/events/{}'.format(current_app.config['FRONTEND_ADMIN_URL'],
event_id), event.title)
status_code = send_smtp_email(
emails_to, '{} is ready for review'.format(event.title),
message)
if status_code != 200:
errs.append(f"Problem sending admin email {status_code}")
elif data.get('event_state') == REJECTED:
emails_to = [user.email for user in dao_get_users()]
message = '<div>Please correct this event <a href="{}">{}</a></div>'.format(
'{}/events/{}'.format(current_app.config['FRONTEND_ADMIN_URL'],
event_id), event.title)
message += '<ol>'
for reject_reason in [
rr for rr in json_event.get('reject_reasons')
if not rr.get('resolved')
]:
message += '<li>{}</li>'.format(reject_reason['reason'])
message += '</ol>'
status_code = send_smtp_email(
emails_to,
'{} event needs to be corrected'.format(event.title), message)
if status_code != 200:
errs.append(f"Problem sending smtp emails: {status_code}")
json_event['errors'] = errs
return jsonify(json_event), 200
raise InvalidRequest('{} did not update event'.format(event_id), 400)
def update_email(email_id):
data = request.get_json(force=True)
validate(data, post_update_email_schema)
if data['email_type'] == EVENT:
try:
event = dao_get_event_by_id(data.get('event_id'))
except NoResultFound:
raise InvalidRequest('event not found: {}'.format(data.get('event_id')), 400)
email_data = {}
for k in data.keys():
if hasattr(Email, k):
email_data[k] = data[k]
current_app.logger.info('Update email: {}'.format(email_data))
res = dao_update_email(email_id, **email_data)
if res:
email = dao_get_email_by_id(email_id)
response = None
emails_to = [user.email for user in dao_get_users()]
if data.get('email_state') == READY:
subject = None
if data['email_type'] == EVENT:
event = dao_get_event_by_id(data.get('event_id'))
subject = 'Please review {}'.format(event.title)
# send email to admin users and ask them to log in in order to approve the email
review_part = '<div>Please review this email: {}/emails/{}</div>'.format(
current_app.config['FRONTEND_ADMIN_URL'], str(email.id))
event_html = get_email_html(**data)
response = send_email(emails_to, subject, review_part + event_html)
elif data.get('email_state') == REJECTED:
if email.task_id:
revoke_task(email.task_id)
message = '<div>Please correct this email <a href="{}">{}</a></div>'.format(
'{}/emails/{}'.format(current_app.config['FRONTEND_ADMIN_URL'], str(email.id)),
email.get_subject())
message += '<div>Reason: {}</div>'.format(data.get('reject_reason'))
response = send_email(emails_to, '{} email needs to be corrected'.format(event.title), message)
elif data.get('email_state') == APPROVED:
# send the email later in order to allow it to be rejected
later = datetime.utcnow() + timedelta(seconds=current_app.config['EMAIL_DELAY'])
if later < email.send_starts_at:
later = email.send_starts_at + timedelta(hours=9)
result = email_tasks.send_emails.apply_async(((str(email_id)),), eta=later)
dao_update_email(email_id, task_id=result.id)
current_app.logger.info('Task: send_email: %d, %r at %r', email_id, result.id, later)
review_part = '<div>Email will be sent at {}, log in to reject: {}/emails/{}</div>'.format(
later, current_app.config['FRONTEND_ADMIN_URL'], str(email.id))
event_html = get_email_html(**data)
response = send_email(
emails_to, "{} has been approved".format(email.get_subject()), review_part + event_html)
email_json = email.serialize()
if response:
email_json['email_status_code'] = response
return jsonify(email_json), 200
raise InvalidRequest('{} did not update email'.format(email_id), 400)
def get_event_by_id(event_id):
event = dao_get_event_by_id(event_id)
return jsonify(event.serialize())
def get_expired_date(self):
if self.email_type == EVENT:
from app.dao.events_dao import dao_get_event_by_id
event = dao_get_event_by_id(str(self.event_id))
return "{}".format(event.get_last_event_date())
