def fees_by_events_view(self):
from_date = request.args.get('from_date')
to_date = request.args.get('to_date')
if ('from_date' in request.args and not from_date) or ('to_date' in request.args and not to_date) or \
('from_date' in request.args and 'to_date' not in request.args) or \
('to_date' in request.args and 'from_date' not in request.args):
return redirect(url_for('.fees_by_events_view'))
marketer_role = CustomSysRole.query.filter_by(name='Marketer').first()
marketer_id = login.current_user.id if login.current_user.is_sys_role(
marketer_role.id) else None
if from_date and to_date:
orders = TicketingManager.get_orders(
from_date=datetime.strptime(from_date, '%d/%m/%Y'),
to_date=datetime.strptime(to_date, '%d/%m/%Y'),
status='completed',
marketer_id=marketer_id)
else:
orders = TicketingManager.get_orders(status='completed',
marketer_id=marketer_id)
events = DataGetter.get_all_events()
fee_summary = {}
for event in events:
fee_summary[str(event.id)] = {
'name': event.name,
'payment_currency': event.payment_currency,
'fee_rate': get_fee(event.payment_currency),
'fee_amount': 0,
'tickets_count': 0
}
fee_total = 0
tickets_total = 0
for order in orders:
for order_ticket in order.tickets:
fee_summary[str(
order.event.id)]['tickets_count'] += order_ticket.quantity
tickets_total += order_ticket.quantity
ticket = CachedGetter.get_ticket(order_ticket.ticket_id)
if order.paid_via != 'free' and order.amount > 0 and ticket.price > 0:
fee = ticket.price * (
get_fee(order.event.payment_currency) / 100)
fee = forex(order.event.payment_currency,
self.display_currency, fee)
fee_summary[str(order.event.id)]['fee_amount'] += fee
fee_total += fee
return self.render('/gentelella/admin/super_admin/sales/fees.html',
fee_summary=fee_summary,
display_currency=self.display_currency,
from_date=from_date,
to_date=to_date,
tickets_total=tickets_total,
fee_total=fee_total)
def display_orders(event_id, pdf=None):
from_date = request.args.get('from_date')
to_date = request.args.get('to_date')
discount_code = request.args.get('discount_code')
if ('from_date' in request.args and not from_date) or ('to_date' in request.args and not to_date) or \
('from_date' in request.args and 'to_date' not in request.args) or \
('to_date' in request.args and 'from_date' not in request.args):
return redirect(url_for('.display_orders', event_id=event_id))
if from_date and to_date:
orders = TicketingManager.get_orders(
event_id=event_id,
from_date=datetime.strptime(from_date, '%d/%m/%Y'),
to_date=datetime.strptime(to_date, '%d/%m/%Y')
)
elif discount_code == '':
return redirect(url_for('.display_orders', event_id=event_id))
elif discount_code:
orders = TicketingManager.get_orders(
event_id=event_id,
discount_code=discount_code,
)
else:
orders = TicketingManager.get_orders(event_id)
event = DataGetter.get_event(event_id)
if pdf is not None:
return (event, event_id, orders, discount_code)
else:
return render_template('gentelella/users/events/tickets/orders.html', event=event, event_id=event_id,
orders=orders, from_date=from_date, to_date=to_date, discount_code=discount_code)
def apply_promo():
discount = TicketingManager.get_discount_code(request.form.get('event_id'), request.form.get('promo_code', ''))
access_code = TicketingManager.get_access_code(request.form.get('event_id'), request.form.get('promo_code', ''))
if discount and access_code and discount.is_active:
return jsonify({
'discount_type': discount.type,
'discount_amount': discount.value,
'discount_status': True,
'access_status': True,
'access_code_ticket': access_code.tickets,
'discount_code_ticket': discount.tickets,
})
elif discount and discount.is_active:
return jsonify({
'discount_type': discount.type,
'discount_amount': discount.value,
'discount_status': True,
'access_status': False,
'discount_code_ticket': discount.tickets,
})
elif access_code:
return jsonify({
'access_status': True,
'discount_status': False,
'access_code_ticket': access_code.tickets,
})
else:
return jsonify({
'discount_status': False,
'access_status': False,
})
def display_orders(event_id):
from_date = request.args.get('from_date')
to_date = request.args.get('to_date')
discount_code = request.args.get('discount_code')
if ('from_date' in request.args and not from_date) or ('to_date' in request.args and not to_date) or \
('from_date' in request.args and 'to_date' not in request.args) or \
('to_date' in request.args and 'from_date' not in request.args):
return redirect(url_for('.display_orders', event_id=event_id))
if from_date and to_date:
orders = TicketingManager.get_orders(
event_id=event_id,
from_date=datetime.strptime(from_date, '%d/%m/%Y'),
to_date=datetime.strptime(to_date, '%d/%m/%Y'))
elif discount_code == '':
return redirect(url_for('.display_orders', event_id=event_id))
elif discount_code:
orders = TicketingManager.get_orders(
event_id=event_id,
discount_code=discount_code,
)
else:
orders = TicketingManager.get_orders(event_id)
event = DataGetter.get_event(event_id)
return render_template('gentelella/users/events/tickets/orders.html',
event=event,
event_id=event_id,
orders=orders,
from_date=from_date,
to_date=to_date,
discount_code=discount_code)
def display_my_tickets():
page_content = {
"tab_upcoming_events": "Upcoming Events",
"tab_past_events": "Past Events",
"title": "My Tickets"
}
upcoming_events_orders = TicketingManager.get_orders_of_user(
upcoming_events=True)
past_events_orders = TicketingManager.get_orders_of_user(
upcoming_events=False)
placeholder_images = DataGetter.get_event_default_images()
custom_placeholder = DataGetter.get_custom_placeholders()
im_config = DataGetter.get_image_configs()
im_size = ''
for config in im_config:
if config.page == 'mysession':
im_size = config.size
return render_template('gentelella/admin/mytickets/mytickets_list.html',
page_content=page_content,
upcoming_events_orders=upcoming_events_orders,
past_events_orders=past_events_orders,
placeholder_images=placeholder_images,
custom_placeholder=custom_placeholder,
im_size=im_size)
def access_codes_edit(event_id, access_code_id=None):
if not TicketingManager.get_access_code(event_id, access_code_id):
abort(404)
if request.method == 'POST':
TicketingManager.create_edit_access_code(request.form, event_id, access_code_id)
flash("The access code has been edited.", "success")
return redirect(url_for('.access_codes_view', event_id=event_id))
return access_codes_create(event_id, access_code_id)
def fees_by_events_view():
from_date = request.args.get('from_date')
to_date = request.args.get('to_date')
if ('from_date' in request.args and not from_date) or ('to_date' in request.args and not to_date) or \
('from_date' in request.args and 'to_date' not in request.args) or \
('to_date' in request.args and 'from_date' not in request.args):
return redirect(url_for('.fees_by_events_view'))
marketer_role = CustomSysRole.query.filter_by(name='Marketer').first()
marketer_id = login.current_user.id if login.current_user.is_sys_role(marketer_role.id) else None
if from_date and to_date:
orders = TicketingManager.get_orders(
from_date=datetime.strptime(from_date, '%d/%m/%Y'),
to_date=datetime.strptime(to_date, '%d/%m/%Y'),
status='completed',
marketer_id=marketer_id
)
else:
orders = TicketingManager.get_orders(status='completed', marketer_id=marketer_id)
events = DataGetter.get_all_events()
fee_summary = {}
for event in events:
fee_summary[str(event.id)] = {
'name': event.name,
'payment_currency': event.payment_currency,
'fee_rate': get_fee(event.payment_currency),
'fee_amount': 0,
'tickets_count': 0
}
fee_total = 0
tickets_total = 0
for order in orders:
if order.event:
for order_ticket in order.tickets:
fee_summary[str(order.event.id)]['tickets_count'] += order_ticket.quantity
tickets_total += order_ticket.quantity
ticket = CachedGetter.get_ticket(order_ticket.ticket_id)
if order.paid_via != 'free' and order.amount > 0 and ticket.price > 0:
fee = ticket.price * (get_fee(order.event.payment_currency) / 100)
fee = forex(order.event.payment_currency, display_currency, fee)
fee_summary[str(order.event.id)]['fee_amount'] += fee
fee_total += fee
return render_template('gentelella/super_admin/sales/fees.html',
fee_summary=fee_summary,
display_currency=display_currency,
from_date=from_date,
to_date=to_date,
tickets_total=tickets_total,
fee_total=fee_total,
navigation_bar=list_navbar())
def access_codes_create(event_id, access_code_id=None):
event = DataGetter.get_event(event_id)
if request.method == 'POST':
TicketingManager.create_edit_access_code(request.form, event_id)
flash("The access code has been added.", "success")
return redirect(url_for('.access_codes_view', event_id=event_id))
access_code = None
if access_code_id:
access_code = TicketingManager.get_access_code(event_id, access_code_id)
return render_template('gentelella/users/events/tickets/access_codes_create.html', event=event, event_id=event_id,
access_code=access_code)
def discount_codes_create(self, event_id, discount_code_id=None):
event = DataGetter.get_event(event_id)
if request.method == 'POST':
TicketingManager.create_edit_discount_code(request.form, event_id)
flash("The discount code has been added.", "success")
return redirect(url_for('.discount_codes_view', event_id=event_id))
discount_code = None
if discount_code_id:
discount_code = TicketingManager.get_discount_code(event_id, discount_code_id)
return self.render('/gentelella/admin/event/tickets/discount_codes_create.html', event=event, event_id=event_id,
discount_code=discount_code)
def display_attendees(event_id):
event = DataGetter.get_event(event_id)
orders = TicketingManager.get_orders(event_id)
holders = []
for order in orders:
for holder in order.ticket_holders:
discount = TicketingManager.get_discount_code(
event_id, order.discount_code_id)
order_holder = {}
order_holder['order_invoice'] = order.get_invoice_number()
order_holder['order_url'] = url_for('ticketing.view_order_after_payment', order_identifier=order.identifier) \
if order.status == 'completed' else url_for('ticketing.show_transaction_error', \
order_identifier=order.identifier)
order_holder['by_whom'] = order.user.user_detail.fullname if order.user.user_detail \
and order.user.user_detail.fullname else order.user.email
order_holder['paid_via'] = order.paid_via
order_holder['status'] = order.status
order_holder['completed_at'] = order.completed_at
order_holder['created_at'] = order.created_at
order_holder['ticket_name'] = holder.ticket.name
order_holder['firstname'] = holder.firstname
order_holder['lastname'] = holder.lastname
order_holder['email'] = holder.email
order_holder['ticket_name'] = holder.ticket.name
order_holder['ticket_price'] = holder.ticket.price
if discount and str(
holder.ticket.id) in discount.tickets.split(","):
if discount.type == "amount":
order_holder['ticket_price'] = order_holder[
'ticket_price'] - discount.value
else:
order_holder['ticket_price'] = order_holder['ticket_price'] - (order_holder['ticket_price'] \
* discount.value / 100.0 )
order_holder['checked_in'] = holder.checked_in
order_holder['id'] = holder.id
holders.append(order_holder)
if len(order.ticket_holders) == 0:
order_holder = {}
order_holder['order_invoice'] = order.get_invoice_number()
order_holder['order_url'] = url_for('ticketing.view_order_after_payment', order_identifier=order.identifier) \
if order.status == 'completed' else url_for('ticketing.show_transaction_error', \
order_identifier=order.identifier)
order_holder['by_whom'] = order.user.user_detail.fullname if order.user.user_detail \
and order.user.user_detail.fullname else order.user.email
order_holder['paid_via'] = order.paid_via
order_holder['status'] = order.status
order_holder['completed_at'] = order.completed_at
order_holder['created_at'] = order.created_at
holders.append(order_holder)
return render_template('gentelella/admin/event/tickets/attendees.html',
event=event,
event_id=event_id,
holders=holders)
def fees_by_events_view(self):
from_date = request.args.get('from_date')
to_date = request.args.get('to_date')
if ('from_date' in request.args and not from_date) or ('to_date' in request.args and not to_date) or \
('from_date' in request.args and 'to_date' not in request.args) or \
('to_date' in request.args and 'from_date' not in request.args):
return redirect(url_for('.fees_by_events_view'))
if from_date and to_date:
orders = TicketingManager.get_orders(
from_date=datetime.strptime(from_date, '%d/%m/%Y'),
to_date=datetime.strptime(to_date, '%d/%m/%Y'),
status='completed'
)
else:
orders = TicketingManager.get_orders(status='completed')
events = DataGetter.get_all_events()
fee_summary = {}
for event in events:
fee_summary[str(event.id)] = {
'name': event.name,
'payment_currency': event.payment_currency,
'fee_rate': get_fee(event.payment_currency),
'fee_amount': 0,
'tickets_count': 0
}
fee_total = 0
tickets_total = 0
for order in orders:
for order_ticket in order.tickets:
fee_summary[str(order.event.id)]['tickets_count'] += order_ticket.quantity
tickets_total += order_ticket.quantity
ticket = TicketingManager.get_ticket(order_ticket.ticket_id)
if order.paid_via != 'free' and order.amount > 0 and ticket.price > 0:
fee = ticket.price * (get_fee(order.event.payment_currency)/100)
fee = forex(order.event.payment_currency, self.display_currency, fee)
fee_summary[str(order.event.id)]['fee_amount'] += fee
fee_total += fee
return self.render('/gentelella/admin/super_admin/sales/fees.html',
fee_summary=fee_summary,
display_currency=self.display_currency,
from_date=from_date,
to_date=to_date,
tickets_total=tickets_total,
fee_total=fee_total)
def discount_codes_create(self, event_id, discount_code_id=None):
event = DataGetter.get_event(event_id)
if request.method == 'POST':
TicketingManager.create_edit_discount_code(request.form, event_id)
flash("The discount code has been added.", "success")
return redirect(url_for('.discount_codes_view', event_id=event_id))
discount_code = None
if discount_code_id:
discount_code = TicketingManager.get_discount_code(
event_id, discount_code_id)
return self.render(
'/gentelella/admin/event/tickets/discount_codes_create.html',
event=event,
event_id=event_id,
discount_code=discount_code)
def send_event_fee_notification():
with app.app_context():
events = Event.query.all()
for event in events:
latest_invoice = EventInvoice.filter_by(event_id=event.id).order_by(EventInvoice.created_at.desc()).first()
if latest_invoice:
orders = Order.query\
.filter_by(event_id=event.id)\
.filter_by(status='completed')\
.filter(Order.completed_at > latest_invoice.created_at).all()
else:
orders = Order.query.filter_by(event_id=event.id).filter_by(status='completed').all()
fee_total = 0
for order in orders:
for order_ticket in order.tickets:
ticket = TicketingManager.get_ticket(order_ticket.ticket_id)
if order.paid_via != 'free' and order.amount > 0 and ticket.price > 0:
fee = ticket.price * (get_fee(order.event.payment_currency) / 100)
fee_total += fee
if fee_total > 0:
new_invoice = EventInvoice(amount=fee_total, event_id=event.id, user_id=event.creator_id)
save_to_db(new_invoice)
prev_month = monthdelta(new_invoice.created_at, 1).strftime("%b %Y") # Displayed as Aug 2016
send_email_for_monthly_fee_payment(new_invoice.user.email,
event.name,
prev_month,
new_invoice.amount,
url_for('event_invoicing.view_invoice',
invoice_identifier=new_invoice.identifier, _external=True))
def access_codes_delete(event_id, access_code_id=None):
access_code = TicketingManager.get_access_code(event_id, access_code_id)
if not access_code:
abort(404)
delete_from_db(access_code, "Access code deleted")
flash("The access code has been deleted.", "warning")
return redirect(url_for('.access_codes_view', event_id=event_id))
def display_ticket_stats(event_id):
event = DataGetter.get_event(event_id)
orders = TicketingManager.get_orders(event_id)
orders_summary = {
'completed': {
'class': 'success',
'tickets_count': 0,
'orders_count': 0,
'total_sales': 0
},
'pending': {
'class': 'warning',
'tickets_count': 0,
'orders_count': 0,
'total_sales': 0
},
'expired': {
'class': 'danger',
'tickets_count': 0,
'orders_count': 0,
'total_sales': 0
}
}
tickets_summary = {}
for ticket in event.tickets:
tickets_summary[str(ticket.id)] = {
'name': ticket.name,
'quantity': ticket.quantity,
'completed': {
'tickets_count': 0,
'sales': 0
},
'pending': {
'tickets_count': 0,
'sales': 0
},
'expired': {
'class': 'danger',
'tickets_count': 0,
'sales': 0
}
}
for order in orders:
if order.status == 'initialized':
order.status = 'pending'
orders_summary[str(order.status)]['orders_count'] += 1
orders_summary[str(order.status)]['total_sales'] += order.amount
for order_ticket in order.tickets:
orders_summary[str(order.status)]['tickets_count'] += order_ticket.quantity
ticket = get_ticket(order_ticket.ticket_id)
tickets_summary[str(ticket.id)][str(order.status)]['tickets_count'] += order_ticket.quantity
if order.paid_via != 'free' and order.amount > 0:
tickets_summary[str(ticket.id)][str(order.status)]['sales'] += order_ticket.quantity * ticket.price
return render_template('gentelella/admin/event/tickets/tickets.html', event=event, event_id=event_id,
orders_summary=orders_summary, tickets_summary=tickets_summary)
def export(event_id):
orders = TicketingManager.get_orders(event_id)
headers = [
'Order#', 'Order Date', 'Status', 'Payment Type', 'Total Amount',
'Quantity', 'Discount Code', 'First Name', 'Last Name', 'Email'
]
rows = [headers]
for order in orders:
if order.status != "deleted":
column = []
column.append(str(order.get_invoice_number()))
column.append(
str(order.created_at) if order.created_at else '')
column.append(str(order.status) if order.status else '')
column.append(str(order.paid_via) if order.paid_via else '')
column.append(str(order.amount) if order.amount else '')
column.append(str(order.get_tickets_count()))
column.append(
str(order.discount_code.code) if order.
discount_code else '')
column.append(
str(order.user.user_detail.firstname.encode('utf-8')
) if order.user.user_detail
and order.user.user_detail.firstname else '')
column.append(
str(order.user.user_detail.lastname.encode('utf-8')
) if order.user.user_detail
and order.user.user_detail.lastname else '')
column.append(
str(order.user.email) if order.user.email else '')
rows.append(column)
return rows
def charge_stripe_order_payment(self):
status, result = TicketingManager.charge_stripe_order_payment(
request.form)
if status:
return jsonify({"status": "ok", "message": result.transaction_id})
else:
return jsonify({"status": "error", "message": result})
def discount_codes_delete(event_id, discount_code_id=None):
discount_code = TicketingManager.get_discount_code(event_id, discount_code_id)
if not discount_code:
abort(404)
delete_from_db(discount_code, "Discount code deleted")
flash("The discount code has been deleted.", "warning")
return redirect(url_for('.discount_codes_view', event_id=event_id))
def add_order(event_id):
if request.method == 'POST':
order = TicketingManager.create_order(request.form, True)
return redirect(url_for('.proceed_order', event_id=event_id, order_identifier=order.identifier))
event = DataGetter.get_event(event_id)
return render_template('gentelella/users/events/tickets/add_order.html', event=event, event_id=event_id)
def export(event_id):
(_, event_id, holders, _, _) = TicketingManager.get_attendee_export_info(event_id=event_id)
if event_id == 275:
headers = ['Order#', 'Order Date', 'Status', 'First Name', 'Last Name', 'Email', 'Country',
'Occupation', 'Company/Instt', 'Gender', 'Expertise', 'Welcome Reception', 'Recruitment',
'Unesco Hackathon', 'Payment Type', 'Ticket Name', 'Ticket Price', 'Ticket Type']
fields = ('order_invoice', 'created_at', 'status', 'firstname', 'lastname', 'email', 'country',
'occupation', 'occupation_detail', 'gender', 'expertise', 'welcome_reception', 'recruitment',
'unesco_hackathon', 'paid_via', 'ticket_name', 'ticket_price', 'ticket_type')
else:
headers = ['Order#', 'Order Date', 'Status', 'First Name', 'Last Name', 'Email',
'Country', 'Payment Type', 'Ticket Name', 'Ticket Price', 'Ticket Type']
fields = (
'order_invoice', 'created_at', 'status', 'firstname', 'lastname',
'email', 'country', 'paid_via', 'ticket_name', 'ticket_price', 'ticket_type')
rows = [headers]
for holder in holders:
if holder['status'] != "deleted":
columns = []
for f in fields:
if type(holder.get(f, '')) == unicode:
columns.append(str(holder.get(f, '').encode('utf-8')))
else:
columns.append(str(holder.get(f, '')))
rows.append(columns)
return rows
def test_discounts_edit(self):
with app.test_request_context():
event, discount_code = create_discount_code(self)
response = self.app.get(url_for(
'event_ticket_sales.discount_codes_edit',
event_id=event.id,
discount_code_id=discount_code.id),
follow_redirects=True)
self.assertTrue(str(discount_code.code) in response.data,
msg=response.data)
data = {
"code": "ABC_123",
"value": "100",
"value_type": "percent",
"min_quantity": "1",
"max_quantity": "2",
"tickets_number": "30",
"tickets[]": ["1", "2"]
}
response = self.app.post(url_for(
'event_ticket_sales.discount_codes_edit',
event_id=event.id,
discount_code_id=discount_code.id),
data=data,
follow_redirects=True)
self.assertTrue(TicketingManager.get_discount_code(
event.id, discount_code.id).type == 'percent',
msg=response.data)
def create_order():
order = TicketingManager.create_order(request.form)
if request.form.get('promo_code', '') != '':
flash(
'The promotional code entered is valid. No offer has been applied to this order.',
'danger')
return redirect(url_for('.view_order', order_identifier=order.identifier))
def access_codes_view(event_id):
event = DataGetter.get_event(event_id)
access_codes = TicketingManager.get_access_codes(event_id)
return render_template('gentelella/users/events/tickets/access_codes.html',
event=event,
access_codes=access_codes,
event_id=event_id)
def export(event_id):
orders = TicketingManager.get_orders(event_id)
headers = 'Order#,Order Date, Status, Payment Type, Total Amount, Quantity, Discount Code,' \
'First Name, Last Name, Email \n'
rows = [headers]
for order in orders:
if order.status != "deleted":
column = []
column.append(str(order.get_invoice_number()))
column.append(str(order.created_at) if order.created_at else '')
column.append(str(order.status) if order.status else '')
column.append(str(order.paid_via) if order.paid_via else '')
column.append(str(order.amount) if order.amount else '')
column.append(str(order.get_tickets_count()))
column.append(str(order.discount_code.code) if order.discount_code else '')
column.append(str(order.user.user_detail.firstname.encode('utf-8'))
if order.user.user_detail and order.user.user_detail.firstname else '')
column.append(str(order.user.user_detail.lastname.encode('utf-8'))
if order.user.user_detail and order.user.user_detail.lastname else '')
column.append(str(order.user.email) if order.user.email else '')
rows.append(','.join(column))
csv_content = '\n'.join(rows)
return csv_content
def display_orders(self, event_id):
event = DataGetter.get_event(event_id)
orders = TicketingManager.get_orders(event_id)
return self.render('/gentelella/admin/event/tickets/orders.html',
event=event,
event_id=event_id,
orders=orders)
def export(event_id):
orders = TicketingManager.get_orders(event_id)
headers = 'Order#,Order Date, Status, Payment Type, Total Amount, Quantity, Discount Code,' \
'First Name, Last Name, Email \n'
rows = [headers]
for order in orders:
if order.status != "deleted":
column = []
column.append(str(order.get_invoice_number()))
column.append(
str(order.created_at) if order.created_at else '')
column.append(str(order.status) if order.status else '')
column.append(str(order.paid_via) if order.paid_via else '')
column.append(str(order.amount) if order.amount else '')
column.append(str(order.get_tickets_count()))
column.append(
str(order.discount_code.code) if order.
discount_code else '')
column.append(
str(order.user.user_detail.firstname) if order.user.
user_detail and order.user.user_detail.firstname else '')
column.append(
str(order.user.user_detail.lastname) if order.user.
user_detail and order.user.user_detail.lastname else '')
column.append(
str(order.user.email) if order.user.email else '')
rows.append(','.join(column))
csv_content = '\n'.join(rows)
return csv_content
def display_attendees(self, event_id):
event = DataGetter.get_event(event_id)
orders = TicketingManager.get_orders(event_id, status='completed')
return self.render('/gentelella/admin/event/tickets/attendees.html',
event=event,
event_id=event_id,
orders=orders)
def access_codes_delete(event_id, access_code_id=None):
access_code = TicketingManager.get_access_code(event_id, access_code_id)
if not access_code:
abort(404)
delete_from_db(access_code, "Access code deleted")
flash("The access code has been deleted.", "warning")
return redirect(url_for('.access_codes_view', event_id=event_id))
def test_discounts_toggle(self):
with app.test_request_context():
event, discount_code = create_discount_code(self)
response = self.app.get(url_for('event_ticket_sales.discount_codes_toggle', event_id=event.id,
discount_code_id=discount_code.id), follow_redirects=True)
self.assertFalse(TicketingManager.get_discount_code(event.id, discount_code.id).is_active,
msg=response.data)
def paypal_callback(order_identifier, function):
order = TicketingManager.get_order_by_identifier(order_identifier)
if not order or order.status == 'expired':
abort(404)
if function == 'cancel':
order.status = 'expired'
save_to_db(order)
return redirect(url_for('event_detail.display_event_detail_home', identifier=order.event.identifier))
elif function == 'success':
status, result = TicketingManager.charge_paypal_order_payment(order)
if status:
return redirect(url_for('.view_order', order_identifier=order_identifier))
else:
flash("An error occurred while processing your transaction. " + str(result), "danger")
return redirect(url_for('.show_transaction_error', order_identifier=order_identifier))
abort(404)
def initiate_order_payment():
paid_via = request.form.get('pay_via_service', 'stripe')
result = TicketingManager.initiate_order_payment(request.form, paid_via)
if result:
if request.form.get('pay_via_service', 'stripe') != 'paypal':
return jsonify({
"status":
"ok",
"email":
result.user.email,
"action":
"start_stripe" if result.status == 'initialized'
and paid_via == 'stripe' else "show_completed"
})
else:
return jsonify({
"status":
"ok",
"email":
result.user.email,
"action":
"start_paypal",
"redirect_url":
PayPalPaymentsManager.get_checkout_url(result)
})
else:
return jsonify({"status": "error"})
def discount_codes_view(self, event_id):
event = DataGetter.get_event(event_id)
discount_codes = TicketingManager.get_discount_codes(event_id)
return self.render(
'/gentelella/admin/event/tickets/discount_codes.html',
event=event,
discount_codes=discount_codes,
event_id=event_id)
def view_order_after_payment(order_identifier):
order = TicketingManager.get_and_set_expiry(order_identifier)
if not order or (order.status != 'completed' and order.status != 'placed'):
abort(404)
return render_template(
'gentelella/guest/ticketing/order_post_payment.html',
order=order,
event=order.event)
def test_order_payment_paypal_cancel(self):
with app.test_request_context():
event, ticket, identifier = create_order(self)
response = self.app.get(
url_for('ticketing.paypal_callback', order_identifier=identifier, function="cancel"),
follow_redirects=True)
order = TicketingManager.get_order_by_identifier(identifier)
self.assertTrue(order.status == 'expired', msg=order.status)
def discount_codes_view(event_id):
event = DataGetter.get_event(event_id)
discount_codes = TicketingManager.get_discount_codes(event_id)
return render_template(
'gentelella/users/events/tickets/discount_codes.html',
event=event,
discount_codes=discount_codes,
event_id=event_id)
def test_order_payment_paypal(self):
with app.test_request_context():
event, ticket, identifier = create_order(self)
data = {
"identifier": identifier,
"email": "*****@*****.**",
"firstname": "John",
"lastname": "Doe",
"address": "ACME Lane",
"city": "Loony",
"state": "Tunes",
"zipcode": "1451145",
"country": "Warner",
"pay_via_service": "paypal"
}
response = self.app.post(
url_for('ticketing.initiate_order_payment'),
data=data,
follow_redirects=True)
response_json = json.loads(response.data)
self.assertEqual(data['email'],
response_json['email'],
msg=response.data)
self.assertEqual("start_paypal",
response_json['action'],
msg=response.data)
self.assertTrue("redirect_url" in response_json, msg=response.data)
order = TicketingManager.get_order_by_identifier(identifier)
self.assertEqual(order.status, 'initialized', msg=response.data)
order.brand = "Visa"
order.completed_at = datetime.now()
order.status = "completed"
order.paid_via = "paypal"
order.transaction_id = "87906533255"
save_to_db(order)
response = self.app.get(url_for(
'ticketing.view_order_after_payment',
order_identifier=identifier),
follow_redirects=True)
self.assertTrue("ACME Lane" in response.data, msg=response.data)
self.assertTrue("87906533255" in response.data, msg=response.data)
self.assertTrue(str(event.name) in response.data,
msg=response.data)
self.assertTrue(str(ticket.name) in response.data,
msg=response.data)
response = self.app.get(url_for('ticketing.view_order',
order_identifier=identifier),
follow_redirects=False)
self.assertEqual(response.status_code,
302,
msg=response.status_code)
response = self.app.get(url_for(
'ticketing.view_order_after_payment_pdf',
order_identifier=identifier),
follow_redirects=False)
self.assertEqual(response.status_code,
200,
msg=response.status_code)
def access_codes_toggle(event_id, access_code_id=None):
access_code = TicketingManager.get_access_code(event_id, access_code_id)
if not access_code:
abort(404)
access_code.is_active = not access_code.is_active
save_to_db(access_code)
message = "Activated." if access_code.is_active else "Deactivated."
flash("The access code has been " + message, "success")
return redirect(url_for('.access_codes_view', event_id=event_id))
def access_codes_toggle(event_id, access_code_id=None):
access_code = TicketingManager.get_access_code(event_id, access_code_id)
if not access_code:
abort(404)
access_code.is_active = not access_code.is_active
save_to_db(access_code)
message = "Activated." if access_code.is_active else "Deactivated."
flash("The access code has been " + message, "success")
return redirect(url_for('.access_codes_view', event_id=event_id))
def discount_codes_toggle(self, event_id, discount_code_id=None):
discount_code = TicketingManager.get_discount_code(event_id, discount_code_id)
if not discount_code:
abort(404)
discount_code.is_active = not discount_code.is_active
save_to_db(discount_code)
message = "Activated." if discount_code.is_active else "Deactivated."
flash("The discount code has been " + message, "success")
return redirect(url_for('.discount_codes_view', event_id=event_id))
def view_order_after_payment(order_identifier):
order = TicketingManager.get_and_set_expiry(order_identifier)
if not order or (order.status != 'completed' and order.status != 'placed'):
abort(404)
flash("An email with the ticket has also been sent to your email account.")
return render_template(
'gentelella/guest/ticketing/order_post_payment.html',
order=order,
event=order.event)
def view_order_after_payment(order_identifier):
order = TicketingManager.get_and_set_expiry(order_identifier)
if not order or (order.status != 'completed' and order.status != 'placed'):
abort(404)
flash("An email with the ticket has also been sent to your email account.")
fees = DataGetter.get_fee_settings_by_currency(order.event.payment_currency)
return render_template('gentelella/guest/ticketing/order_post_payment.html',
order=order,
event=order.event,
fees=fees)
def view_order_tickets_after_payment_pdf(order_identifier):
order = TicketingManager.get_and_set_expiry(order_identifier)
if not order or order.status != 'completed':
abort(404)
pdf = create_pdf(render_template('gentelella/guest/ticketing/pdf/ticket.html', order=order))
response = make_response(pdf.getvalue())
response.headers['Content-Type'] = 'application/pdf'
response.headers['Content-Disposition'] = \
'inline; filename=%s-Ticket.pdf' % order.event.name
return response
def test_order_expire(self):
with app.test_request_context():
event, ticket, identifier = create_order(self)
response = self.app.get(url_for('ticketing.view_order', order_identifier=identifier), follow_redirects=True)
self.assertEqual(response.status_code, 200, msg=response.status_code)
self.assertTrue(str(event.name) in response.data, msg=response.data)
order = TicketingManager.get_order_by_identifier(identifier)
order.created_at = datetime.utcnow() - timedelta(minutes=11)
save_to_db(order)
response = self.app.get(url_for('ticketing.view_order', order_identifier=identifier), follow_redirects=True)
self.assertEqual(response.status_code, 404, msg=response.status_code)
def view_order_after_payment(order_identifier):
order = TicketingManager.get_and_set_expiry(order_identifier)
email = request.args.get('email', '')
if not order or (order.status != 'completed' and order.status != 'placed'):
abort(404)
fees = DataGetter.get_fee_settings_by_currency(order.event.payment_currency)
return render_template('gentelella/guest/ticketing/order_post_payment.html',
order=order,
event=order.event,
fees=fees,
email=email)
def view_order_after_payment_pdf(self, order_identifier):
order = TicketingManager.get_and_set_expiry(order_identifier)
if not order or order.status != 'completed':
abort(404)
pdf = create_pdf(self.render('/gentelella/guest/ticketing/invoice_pdf.html',
order=order, event=order.event))
response = make_response(pdf.getvalue())
response.headers['Content-Type'] = 'application/pdf'
response.headers['Content-Disposition'] = \
'inline; filename=%s.pdf' % order.get_invoice_number()
return response
def attendee_check_in_toggle(event_id, holder_id):
holder = TicketingManager.attendee_check_in_out(event_id, holder_id)
if holder:
return jsonify({
'status': 'ok',
'checked_in': holder.checked_in
})
return jsonify({
'status': 'invalid_holder_id'
})
def charge_stripe_order_payment():
status, result = TicketingManager.charge_stripe_order_payment(request.form)
if status:
return jsonify({
"status": "ok",
"message": result.transaction_id
})
else:
return jsonify({
"status": "error",
"message": result
})
def index_view(self):
live_events = DataGetter.get_live_events()
draft_events = DataGetter.get_draft_events()
past_events = DataGetter.get_past_events()
all_events = DataGetter.get_all_events()
imported_events = DataGetter.get_imports_by_user()
free_ticket_count = {}
paid_ticket_count = {}
donation_ticket_count = {}
max_free_ticket = {}
max_paid_ticket = {}
max_donation_ticket = {}
for event in all_events:
free_ticket_count[event.id] = TicketingManager.get_orders_count_by_type(event.id, type='free')
max_free_ticket[event.id] = TicketingManager.get_max_orders_count(event.id, type='free')
paid_ticket_count[event.id] = TicketingManager.get_orders_count_by_type(event.id, type='paid')
max_paid_ticket[event.id] = TicketingManager.get_max_orders_count(event.id, type='paid')
donation_ticket_count[event.id] = TicketingManager.get_orders_count_by_type(event.id, type='donation')
max_donation_ticket[event.id] = TicketingManager.get_max_orders_count(event.id, type='donation')
if not is_verified_user():
flash(Markup('Your account is unverified. '
'Please verify by clicking on the confirmation link that has been emailed to you.<br>'
'Did not get the email? Please <a href="/resend_email/" class="alert-link"> click here to resend the confirmation.</a>'))
return self.render('/gentelella/admin/event/index.html',
live_events=live_events,
draft_events=draft_events,
past_events=past_events,
all_events=all_events,
free_ticket_count=free_ticket_count,
paid_ticket_count=paid_ticket_count,
donation_ticket_count=donation_ticket_count,
max_free_ticket=max_free_ticket,
max_paid_ticket=max_paid_ticket,
max_donation_ticket=max_donation_ticket,
imported_events=imported_events)
def index_view():
live_events = DataGetter.get_all_live_events()
draft_events = DataGetter.get_all_draft_events()
past_events = DataGetter.get_all_past_events()
all_events = DataGetter.get_all_events()
trash_events = DataGetter.get_trash_events()
free_ticket_count = {}
paid_ticket_count = {}
donation_ticket_count = {}
max_free_ticket = {}
max_paid_ticket = {}
max_donation_ticket = {}
for event in all_events:
free_ticket_count[event.id] = TicketingManager.get_orders_count_by_type(event.id, type='free')
max_free_ticket[event.id] = TicketingManager.get_max_orders_count(event.id, type='free')
paid_ticket_count[event.id] = TicketingManager.get_orders_count_by_type(event.id, type='paid')
max_paid_ticket[event.id] = TicketingManager.get_max_orders_count(event.id, type='paid')
donation_ticket_count[event.id] = TicketingManager.get_orders_count_by_type(event.id, type='donation')
max_donation_ticket[event.id] = TicketingManager.get_max_orders_count(event.id, type='donation')
return render_template('gentelella/admin/super_admin/events/events.html',
live_events=live_events,
draft_events=draft_events,
past_events=past_events,
all_events=all_events,
trash_events=trash_events,
free_ticket_count=free_ticket_count,
paid_ticket_count=paid_ticket_count,
donation_ticket_count=donation_ticket_count,
max_free_ticket=max_free_ticket,
max_paid_ticket=max_paid_ticket,
max_donation_ticket=max_donation_ticket,
navigation_bar=list_navbar())
def proceed_order(event_id, order_identifier):
order = TicketingManager.get_order_by_identifier(order_identifier)
if order:
if order.status == 'completed':
return redirect(url_for('ticketing.view_order_after_payment', order_identifier=order_identifier))
return render_template('gentelella/guest/ticketing/order_pre_payment.html', order=order, event=order.event,
countries=list(pycountry.countries),
from_organizer=True,
pay_via=order.paid_via,
stripe_publishable_key=get_settings()['stripe_publishable_key'])
else:
abort(404)
return redirect(url_for('.display_ticket_stats', event_id=event_id))
def user_tickets(user_id):
page_content = {"tab_upcoming_events": "Upcoming Events",
"tab_past_events": "Past Events",
"title": "My Tickets"}
upcoming_events_orders = TicketingManager.get_orders_of_user(user_id=user_id, upcoming_events=True)
past_events_orders = TicketingManager.get_orders_of_user(user_id=user_id, upcoming_events=False)
placeholder_images = DataGetter.get_event_default_images()
custom_placeholder = DataGetter.get_custom_placeholders()
im_config = DataGetter.get_image_configs()
im_size = ''
for config in im_config:
if config.page == 'mysession':
im_size = config.size
return render_template('gentelella/users/mytickets/mytickets_list.html',
page_content=page_content,
upcoming_events_orders=upcoming_events_orders,
past_events_orders=past_events_orders,
placeholder_images=placeholder_images,
custom_placeholder=custom_placeholder,
im_size=im_size)
def check_duplicate_access_code(event_id):
code = request.args.get('code')
current = request.args.get('current')
if not current:
current = ''
access_code = TicketingManager.get_access_code(event_id, code)
if (current == "" and access_code) or (current != "" and access_code and access_code.id != int(current)):
return jsonify({
"status": "invalid"
}), 404
return jsonify({
"status": "valid"
}), 200
