def mail_last_30_days(self, obj):
all_mails = get_count(
Mail.query.filter_by(time=datetime.now(pytz.utc)))
mails_till_last_30_day = get_count(
Mail.query.filter(
Mail.time <= datetime.now(pytz.utc) - timedelta(days=30)))
return all_mails - mails_till_last_30_day
def before_post(self, args, kwargs, data):
"""
before post method to check for required relationship and proper permission
:param args:
:param kwargs:
:param data:
:return:
"""
require_relationship(['event'], data)
if not has_access('is_coorganizer', event_id=data['event']):
raise ObjectNotFound({'parameter': 'event_id'},
"Event: {} not found".format(data['event']))
if get_count(
db.session.query(Ticket.id).filter_by(name=data['name'],
event_id=int(
data['event']),
deleted_at=None)) > 0:
raise ConflictException({'pointer': '/data/attributes/name'},
"Ticket already exists")
if get_count(
db.session.query(Event).filter_by(
id=int(data['event']), is_ticketing_enabled=False)) > 0:
raise MethodNotAllowed({'parameter': 'event_id'},
"Ticketing is disabled for this Event")
def total_requests_past_minute(self, obj):
all_processes = get_count(
Process.query.filter_by(time=datetime.now(pytz.utc)))
processes_till_last_1_min = get_count(
Process.query.filter(
Process.time <= datetime.now(pytz.utc) - timedelta(minutes=1)))
return all_processes - processes_till_last_1_min
def before_post(self, args, kwargs, data=None):
"""
method to add user_id to view_kwargs before post
:param args:
:param kwargs:
:param data:
:return:
"""
require_relationship(['event', 'user'], data)
if not has_access('is_coorganizer', event_id=data['event']):
event = db.session.query(Event).filter_by(id=data['event']).one()
if event.state == "draft":
raise ObjectNotFound({'parameter': 'event_id'},
"Event: {} not found".format(data['event_id']))
if get_count(db.session.query(Event).filter_by(id=int(data['event']), is_sessions_speakers_enabled=False)) > 0:
raise ForbiddenException({'pointer': ''}, "Speakers are disabled for this Event")
if get_count(db.session.query(Speaker).filter_by(event_id=int(data['event']), email=data['email'],
deleted_at=None)) > 0:
raise ForbiddenException({'pointer': ''}, 'Speaker with this Email ID already exists')
if 'sessions' in data:
session_ids = data['sessions']
for session_id in session_ids:
if not has_access('is_session_self_submitted', session_id=session_id):
raise ObjectNotFound({'parameter': 'session_id'},
"Session: {} not found".format(session_id))
def before_post(self, args, kwargs, data=None):
"""
method to add user_id to view_kwargs before post
:param args:
:param kwargs:
:param data:
:return:
"""
data['user'] = current_user.id
require_relationship(['event', 'user'], data)
if not has_access('is_coorganizer', event_id=data['event']):
event = db.session.query(Event).filter_by(id=data['event']).one()
if event.state == "draft":
raise ObjectNotFound(
{'parameter': 'event_id'},
"Event: {} not found".format(data['event']),
)
if (get_count(
db.session.query(Event).filter_by(
id=int(data['event']), is_sessions_speakers_enabled=False))
> 0):
raise ForbiddenError({'pointer': ''},
"Speakers are disabled for this Event")
if (not data.get('is_email_overridden') and get_count(
db.session.query(Speaker).filter_by(event_id=int(
data['event']),
email=data['email'],
deleted_at=None)) > 0):
raise ForbiddenError({'pointer': ''},
'Speaker with this Email ID already exists')
if data.get('is_email_overridden') and not has_access(
'is_organizer', event_id=data['event']):
raise ForbiddenError(
{'pointer': 'data/attributes/is_email_overridden'},
'Organizer access required to override email',
)
if (data.get('is_email_overridden')
and has_access('is_organizer', event_id=data['event'])
and not data.get('email')):
data['email'] = current_user.email
if 'sessions' in data:
session_ids = data['sessions']
for session_id in session_ids:
if not has_access('is_session_self_submitted',
session_id=session_id):
raise ObjectNotFound(
{'parameter': 'session_id'},
f"Session: {session_id} not found",
)
data[
'complex_field_values'] = validate_custom_form_constraints_request(
'speaker', self.schema, Speaker(event_id=data['event']), data)
def is_email_available():
email = request.json.get('email', None)
if email:
if get_count(db.session.query(User).filter_by(email=email)):
return jsonify(result="False")
return jsonify(result="True")
abort(make_response(jsonify(error="Email field missing"), 422))
def get_new_slug(name):
slug = name.lower().replace("& ", "").replace(",", "").replace("/","-").replace(" ","-")
count = get_count(EventTopic.query.filter_by(slug=slug))
if count == 0:
return slug
else:
return '{}-{}'.format(slug, uuid.uuid4().hex)
def get_new_identifier():
identifier = str(uuid.uuid4())
count = get_count(EventInvoice.query.filter_by(identifier=identifier))
if count == 0:
return identifier
else:
return get_new_identifier()
def test_get_count(self):
"""Check DBHelper: get count"""
with app.test_request_context():
with mixer.ctx(commit=False):
user = mixer.blend(User)
save_to_db(user)
self.assertEqual(get_count(User.query), 1)
def test_get_count(self):
"""Method to test the number of queries concerning a Model"""
with self.app.test_request_context():
attendee = AttendeeFactory()
save_to_db(attendee)
self.assertEqual(get_count(TicketHolder.query), 1)
def get_new_order_identifier():
identifier = str(uuid.uuid4())
count = get_count(Order.query.filter_by(identifier=identifier))
if count == 0:
return identifier
else:
return get_new_order_identifier()
def get_new_event_identifier(length=8):
identifier = str(binascii.b2a_hex(os.urandom(int(length / 2))), 'utf-8')
if (not identifier.isdigit()
and get_count(Event.query.filter_by(identifier=identifier)) == 0):
return identifier
else:
return get_new_event_identifier(length)
def get_new_order_identifier():
identifier = str(uuid.uuid4())
count = get_count(Order.query.filter_by(identifier=identifier))
if count == 0:
return identifier
else:
return get_new_order_identifier()
def get_new_event_identifier(length=8):
identifier = str(binascii.b2a_hex(os.urandom(int(length / 2))), 'utf-8')
count = get_count(Event.query.filter_by(identifier=identifier))
if count == 0:
return identifier
else:
return get_new_event_identifier(length)
def test_should_create_attendee_forms(self):
"""Method to test custom forms for attendees of an event."""
with app.test_request_context():
event = EventFactoryBasic()
save_to_db(event)
create_custom_forms_for_attendees(event)
self.assertEqual(get_count(CustomForms.query), 3)
def test_should_create_attendee_forms(self):
"""Method to test custom forms for attendees of an event."""
with app.test_request_context():
event = EventFactoryBasic()
save_to_db(event)
create_custom_forms_for_attendees(event)
self.assertEqual(get_count(CustomForms.query), 3)
def get_new_identifier():
identifier = str(uuid.uuid4())
count = get_count(EventInvoice.query.filter_by(identifier=identifier))
if count == 0:
return identifier
else:
return get_new_identifier()
def get_new_event_identifier(length=8):
identifier = str(binascii.b2a_hex(os.urandom(int(length / 2))), 'utf-8')
count = get_count(Event.query.filter_by(identifier=identifier))
if count == 0:
return identifier
else:
return get_new_event_identifier(length)
def create_onsite_attendees_for_order(data):
"""
Creates on site ticket holders for an order and adds it into the request data.
:param data: data initially passed in the POST request for order.
:return:
"""
on_site_tickets = data.get('on_site_tickets')
if not on_site_tickets:
raise UnprocessableEntityError(
{'pointer': 'data/attributes/on_site_tickets'},
'on_site_tickets info missing')
data['ticket_holders'] = []
for on_site_ticket in on_site_tickets:
ticket_id = on_site_ticket['id']
quantity = int(on_site_ticket['quantity'])
ticket = safe_query_without_soft_deleted_entries(
Ticket, 'id', ticket_id, 'ticket_id')
ticket_sold_count = get_count(
db.session.query(TicketHolder.id).filter_by(ticket_id=int(
ticket.id),
deleted_at=None))
# Check if the ticket is already sold out or not.
if ticket_sold_count + quantity > ticket.quantity:
# delete the already created attendees.
for holder in data['ticket_holders']:
ticket_holder = (db.session.query(TicketHolder).filter(
id == int(holder)).one())
db.session.delete(ticket_holder)
try:
db.session.commit()
except Exception:
logging.exception('DB Exception!')
db.session.rollback()
raise ConflictError(
{'pointer': '/data/attributes/on_site_tickets'},
"Ticket with id: {} already sold out. You can buy at most {} tickets"
.format(ticket_id, ticket.quantity - ticket_sold_count),
)
for _ in range(1, quantity):
ticket_holder = TicketHolder(
firstname='onsite',
lastname='attendee',
email='*****@*****.**',
ticket_id=ticket.id,
event_id=data.get('event'),
)
save_to_db(ticket_holder)
data['ticket_holders'].append(ticket_holder.id)
# delete from the data.
del data['on_site_tickets']
def orders_count(self, obj):
obj_id = obj.id
total = get_count(db.session.query(Order).join(Order.order_tickets).filter(OrderTicket.ticket_id == obj_id))
draft = get_count(db.session.query(Order).join(Order.order_tickets).filter(OrderTicket.ticket_id == obj_id,
Order.status == 'draft'))
cancelled = get_count(db.session.query(Order).join(Order.order_tickets).filter(OrderTicket.ticket_id == obj_id,
Order.status == 'cancelled'))
pending = get_count(db.session.query(Order).join(Order.order_tickets).filter(OrderTicket.ticket_id == obj_id,
Order.status == 'pending'))
expired = get_count(db.session.query(Order).join(Order.order_tickets).filter(OrderTicket.ticket_id == obj_id,
Order.status == 'expired'))
placed = get_count(db.session.query(Order).join(Order.order_tickets).filter(OrderTicket.ticket_id == obj_id,
Order.status == 'placed'))
completed = get_count(db.session.query(Order).join(Order.order_tickets).filter(OrderTicket.ticket_id == obj_id,
Order.status == 'completed'))
result = {
'total': total or 0,
'draft': draft or 0,
'cancelled': cancelled or 0,
'pending': pending or 0,
'expired': expired or 0,
'placed': placed or 0,
'completed': completed or 0
}
return result
def orders_count(self, obj):
obj_id = obj.id
total = get_count(
db.session.query(Order).join(
Order.order_tickets).filter(OrderTicket.ticket_id == obj_id))
draft = get_count(
db.session.query(Order).join(Order.order_tickets).filter(
OrderTicket.ticket_id == obj_id, Order.status == 'draft'))
cancelled = get_count(
db.session.query(Order).join(Order.order_tickets).filter(
OrderTicket.ticket_id == obj_id, Order.status == 'cancelled'))
pending = get_count(
db.session.query(Order).join(Order.order_tickets).filter(
OrderTicket.ticket_id == obj_id, Order.status == 'pending'))
expired = get_count(
db.session.query(Order).join(Order.order_tickets).filter(
OrderTicket.ticket_id == obj_id, Order.status == 'expired'))
placed = get_count(
db.session.query(Order).join(Order.order_tickets).filter(
OrderTicket.ticket_id == obj_id, Order.status == 'placed'))
completed = get_count(
db.session.query(Order).join(Order.order_tickets).filter(
OrderTicket.ticket_id == obj_id, Order.status == 'completed'))
result = {
'total': total or 0,
'draft': draft or 0,
'cancelled': cancelled or 0,
'pending': pending or 0,
'expired': expired or 0,
'placed': placed or 0,
'completed': completed or 0
}
return result
def has_order_tickets(self):
"""Returns True if ticket has already placed orders.
Else False.
"""
from app.api.helpers.db import get_count
orders = Order.id.in_(OrderTicket.query.with_entities(OrderTicket.order_id).filter_by(ticket_id=self.id).all())
count = get_count(Order.query.filter(orders).filter(Order.status != 'deleted'))
# Count is zero if no completed orders are present
return bool(count > 0)
def has_order_tickets(self):
"""Returns True if ticket has already placed orders.
Else False.
"""
from app.api.helpers.db import get_count
orders = Order.id.in_(OrderTicket.query.with_entities(OrderTicket.order_id).filter_by(ticket_id=self.id).all())
count = get_count(Order.query.filter(orders).filter(Order.status != 'deleted'))
# Count is zero if no completed orders are present
return bool(count > 0)
def before_create_object(self, data, view_kwargs):
if data.get('used_for') == 'ticket' and (event_id :=
data.get('event')):
discount_codes = DiscountCode.query.filter_by(event_id=event_id,
code=data['code'],
deleted_at=None)
if get_count(discount_codes) > 0:
raise ConflictError({'pointer': '/data/attributes/code'},
'Discount Code already exists')
def is_email_available():
email = request.json.get('email', None)
if email:
if get_count(
db.session.query(User).filter_by(deleted_at=None,
email=email)):
return jsonify(exists=True)
return jsonify(exists=False)
abort(make_response(jsonify(error="Email field missing"), 422))
def before_post(self, args, kwargs, data):
"""
before post method to check for required relationship and proper permission
:param args:
:param kwargs:
:param data:
:return:
"""
require_relationship(['event'], data)
if not has_access('is_coorganizer', event_id=data['event']):
raise ObjectNotFound({'parameter': 'event_id'},
"Event: {} not found".format(data['event']))
if get_count(db.session.query(Ticket.id).filter_by(name=data['name'], event_id=int(data['event']),
deleted_at=None)) > 0:
raise ConflictException({'pointer': '/data/attributes/name'}, "Ticket already exists")
if get_count(db.session.query(Event).filter_by(id=int(data['event']), is_ticketing_enabled=False)) > 0:
raise MethodNotAllowed({'parameter': 'event_id'}, "Ticketing is disabled for this Event")
def get_new_social_link_identifier(length=8):
"""
returns a new social link identifier.
:param length:
:return:
"""
identifier = str(binascii.b2a_hex(os.urandom(int(length / 2))), 'utf-8')
count = get_count(SocialLink.query.filter_by(identifier=identifier))
if count == 0:
return identifier
return get_new_social_link_identifier(length)
def before_post(self, args, kwargs, data):
"""
before post method to check for required relationship and proper permission
:param args:
:param kwargs:
:param data:
:return:
"""
require_relationship(['event', 'track'], data)
data['creator_id'] = current_identity.id
if get_count(db.session.query(Event).filter_by(id=int(data['event']), is_sessions_speakers_enabled=False)) > 0:
raise ForbiddenException({'pointer': ''}, "Sessions are disabled for this Event")
def get_new_social_link_identifier(length=8):
"""
returns a new social link identifier.
:param length:
:return:
"""
identifier = str(binascii.b2a_hex(os.urandom(int(length / 2))), 'utf-8')
count = get_count(SocialLink.query.filter_by(identifier=identifier))
if count == 0:
return identifier
else:
return get_new_social_link_identifier(length)
def before_post(self, args, kwargs, data):
"""
before post method to check for required relationship and proper permission
:param args:
:param kwargs:
:param data:
:return:
"""
require_relationship(['event', 'track'], data)
data['creator_id'] = current_user.id
if get_count(db.session.query(Event).filter_by(id=int(data['event']), is_sessions_speakers_enabled=False)) > 0:
raise ForbiddenException({'pointer': ''}, "Sessions are disabled for this Event")
def before_post(self, args, kwargs, data):
"""
before post method to check for required relationship and proper permission
:param args:
:param kwargs:
:param data:
:return:
"""
require_relationship(['user'], data)
if get_count(db.session.query(UserEmail.id).filter_by(email_address=data.get('email-address'),
user_id=int(data['user']), deleted_at=None)) > 0:
raise ConflictException({'pointer': '/data/attributes/name'}, "Email already exists")
def before_post(self, args, kwargs, data):
"""
before post method to check for required relationship and proper permission
:param args:
:param kwargs:
:param data:
:return:
"""
require_relationship(['event'], data)
if not has_access('is_coorganizer', event_id=data['event']):
raise ForbiddenException({'source': ''}, 'Co-organizer access is required.')
if get_count(db.session.query(Event).filter_by(id=int(data['event']), is_tax_enabled=False)) > 0:
raise MethodNotAllowed({'parameter': 'event_id'}, "Tax is disabled for this Event")
def match_discount_quantity(discount_code, ticket_holders=None):
qty = 0
old_holders = get_count(TicketHolder.query.filter(TicketHolder.ticket_id.in_(discount_code.tickets.split(","))))
for holder in ticket_holders:
ticket_holder = TicketHolder.query.filter_by(id=holder).one()
if ticket_holder.ticket.id in discount_code.tickets.split(","):
qty += 1
if (qty+old_holders) <= discount_code.tickets_number and \
discount_code.min_quantity <= qty <= discount_code.max_quantity:
return True
return False
def before_post(self, args, kwargs, data):
"""
before post method to check for required relationship and proper permission
:param args:
:param kwargs:
:param data:
:return:
"""
require_relationship(['event'], data)
if not has_access('is_organizer', event_id=data['event']):
raise ForbiddenException({'source': ''}, "Minimum Organizer access required")
if get_count(db.session.query(Event).filter_by(id=int(data['event']), can_pay_by_stripe=False)) > 0:
raise ForbiddenException({'pointer': ''}, "Stripe payment is disabled for this Event")
def before_post(self, args, kwargs, data):
"""
Before post method to check for required relationship and proper permissions
:param args:
:param kwargs:
:param data:
:return:
"""
require_relationship(['ticket', 'event'], data)
ticket = db.session.query(Ticket).filter_by(
id=int(data['ticket']), deleted_at=None
).first()
if ticket is None:
raise UnprocessableEntity(
{'pointer': '/data/relationships/ticket'}, "Invalid Ticket"
)
if ticket.event_id != int(data['event']):
raise UnprocessableEntity(
{'pointer': '/data/relationships/ticket'},
"Ticket belongs to a different Event"
)
# Check if the ticket is already sold out or not.
if get_count(db.session.query(TicketHolder.id).
filter_by(ticket_id=int(data['ticket']), deleted_at=None)) >= ticket.quantity:
raise ConflictException(
{'pointer': '/data/attributes/ticket_id'},
"Ticket already sold out"
)
if 'device_name_checkin' in data and data['device_name_checkin'] is not None:
if 'is_checked_in' not in data or not data['is_checked_in']:
raise UnprocessableEntity(
{'pointer': '/data/attributes/device_name_checkin'},
"Attendee needs to be checked in first"
)
elif 'checkin_times' not in data or data['checkin_times'] is None:
raise UnprocessableEntity(
{'pointer': '/data/attributes/device_name_checkin'},
"Check in Times missing"
)
elif len(data['checkin_times'].split(",")) != len(data['device_name_checkin'].split(",")):
raise UnprocessableEntity(
{'pointer': '/data/attributes/device_name_checkin'},
"Check in Times missing for the corresponding device name"
)
if 'checkin_times' in data:
if 'device_name_checkin' not in data or data['device_name_checkin'] is None:
data['device_name_checkin'] = '-'
def before_post(self, args, kwargs, data):
"""
Before post method to check for required relationship and proper permissions
:param args:
:param kwargs:
:param data:
:return:
"""
require_relationship(['ticket', 'event'], data)
ticket = db.session.query(Ticket).filter_by(
id=int(data['ticket']), deleted_at=None
).first()
if ticket is None:
raise UnprocessableEntity(
{'pointer': '/data/relationships/ticket'}, "Invalid Ticket"
)
if ticket.event_id != int(data['event']):
raise UnprocessableEntity(
{'pointer': '/data/relationships/ticket'},
"Ticket belongs to a different Event"
)
# Check if the ticket is already sold out or not.
if get_count(db.session.query(TicketHolder.id).
filter_by(ticket_id=int(data['ticket']), deleted_at=None)) >= ticket.quantity:
raise ConflictException(
{'pointer': '/data/attributes/ticket_id'},
"Ticket already sold out"
)
if 'device_name_checkin' in data and data['device_name_checkin'] is not None:
if 'is_checked_in' not in data or not data['is_checked_in']:
raise UnprocessableEntity(
{'pointer': '/data/attributes/device_name_checkin'},
"Attendee needs to be checked in first"
)
elif 'checkin_times' not in data or data['checkin_times'] is None:
raise UnprocessableEntity(
{'pointer': '/data/attributes/device_name_checkin'},
"Check in Times missing"
)
elif len(data['checkin_times'].split(",")) != len(data['device_name_checkin'].split(",")):
raise UnprocessableEntity(
{'pointer': '/data/attributes/device_name_checkin'},
"Check in Times missing for the corresponding device name"
)
if 'checkin_times' in data:
if 'device_name_checkin' not in data or data['device_name_checkin'] is None:
data['device_name_checkin'] = '-'
def create_onsite_attendees_for_order(data):
"""
Creates on site ticket holders for an order and adds it into the request data.
:param data: data initially passed in the POST request for order.
:return:
"""
on_site_tickets = data.get('on_site_tickets')
if not on_site_tickets:
raise UnprocessableEntity({'pointer': 'data/attributes/on_site_tickets'}, 'on_site_tickets info missing')
data['ticket_holders'] = []
for on_site_ticket in on_site_tickets:
ticket_id = on_site_ticket['id']
quantity = int(on_site_ticket['quantity'])
ticket = safe_query_without_soft_deleted_entries(db, Ticket, 'id', ticket_id, 'ticket_id')
ticket_sold_count = get_count(db.session.query(TicketHolder.id).
filter_by(ticket_id=int(ticket.id), deleted_at=None))
# Check if the ticket is already sold out or not.
if ticket_sold_count + quantity > ticket.quantity:
# delete the already created attendees.
for holder in data['ticket_holders']:
ticket_holder = db.session.query(TicketHolder).filter(id == int(holder)).one()
db.session.delete(ticket_holder)
try:
db.session.commit()
except Exception as e:
logging.error('DB Exception! %s' % e)
db.session.rollback()
raise ConflictException(
{'pointer': '/data/attributes/on_site_tickets'},
"Ticket with id: {} already sold out. You can buy at most {} tickets".format(ticket_id,
ticket.quantity -
ticket_sold_count)
)
for _ in range(1, quantity):
ticket_holder = TicketHolder(firstname='onsite', lastname='attendee', email='*****@*****.**',
ticket_id=ticket.id, event_id=data.get('event'))
save_to_db(ticket_holder)
data['ticket_holders'].append(ticket_holder.id)
# delete from the data.
del data['on_site_tickets']
def match_discount_quantity(discount_code, ticket_holders=None):
qty = 0
old_holders = get_count(
TicketHolder.query.filter(
TicketHolder.ticket_id.in_(discount_code.tickets.split(","))))
for holder in ticket_holders:
ticket_holder = TicketHolder.query.filter_by(id=holder).one()
if ticket_holder.ticket.id in discount_code.tickets.split(","):
qty += 1
if (qty + old_holders) <= discount_code.tickets_number and \
discount_code.min_quantity <= qty <= discount_code.max_quantity:
return True
return False
def is_email_available():
email = request.json.get('email', None)
if email:
if get_count(db.session.query(User).filter_by(email=email)):
return jsonify(
result="False"
)
else:
return jsonify(
result="True"
)
else:
abort(
make_response(jsonify(error="Email field missing"), 422)
)
def before_post(self, args, kwargs, data):
"""
before post method to check for required relationship and proper permission
:param args:
:param kwargs:
:param data:
:return:
"""
require_relationship(['event'], data)
if not has_access('is_coorganizer', event_id=data['event']):
raise ForbiddenException({'source': ''},
'Co-organizer access is required.')
if get_count(
db.session.query(Event).filter_by(
id=int(data['event']), is_sponsors_enabled=False)) > 0:
raise ForbiddenException({'pointer': ''},
"Sponsors are disabled for this Event")
def before_post(self, args, kwargs, data):
"""
before post method to check for required relationship and proper permission
:param args:
:param kwargs:
:param data:
:return:
"""
require_relationship(['event'], data)
if not has_access('is_organizer', event_id=data['event']):
raise ForbiddenError({'source': ''},
"Minimum Organizer access required")
if (get_count(
db.session.query(Event).filter_by(
id=int(data['event']), can_pay_by_stripe=False)) > 0):
raise ForbiddenError({'pointer': ''},
"Stripe payment is disabled for this Event")
def before_post(self, args, kwargs, data):
"""
before post method to check for required relationship and proper permission
:param args:
:param kwargs:
:param data:
:return:
"""
require_relationship(['event'], data)
if not has_access('is_coorganizer', event_id=data['event']):
raise ForbiddenError({'source': ''},
'Co-organizer access is required.')
if (get_count(
db.session.query(Event).filter_by(id=int(data['event']),
is_tax_enabled=False)) > 0):
raise MethodNotAllowed({'parameter': 'event_id'},
"Tax is disabled for this Event")
def before_post(self, args, kwargs, data):
"""
before post method to check for required relationship and proper permission
:param args:
:param kwargs:
:param data:
:return:
"""
require_relationship(['user'], data)
if (get_count(
db.session.query(UserEmail.id).filter_by(
email_address=data.get('email-address'),
user_id=int(data['user']),
deleted_at=None,
)) > 0):
raise ConflictError({'pointer': '/data/attributes/name'},
"Email already exists")
def before_post(self, args, kwargs, data):
"""
before post method to check for required relationship and proper permission
:param args:
:param kwargs:
:param data:
:return:
"""
require_relationship(['event', 'track'], data)
data['creator_id'] = current_user.id
if (get_count(
db.session.query(Event).filter_by(
id=int(data['event']), is_sessions_speakers_enabled=False))
> 0):
raise ForbiddenError({'pointer': ''},
"Sessions are disabled for this Event")
data[
'complex_field_values'] = validate_custom_form_constraints_request(
'session', self.schema, Session(event_id=data['event']), data)
def is_discount_available(discount_code, tickets=None, ticket_holders=None):
"""
Validation of discount code belonging to the tickets and events should be done
before calling this method
"""
qty = 0
# TODO(Areeb): Extremely confusing here what should we do about deleted tickets here
ticket_ids = [ticket.id for ticket in discount_code.tickets]
old_holders = discount_code.confirmed_attendees_count
if ticket_holders:
# pytype: disable=attribute-error
qty = get_count(
TicketHolder.query.filter(
TicketHolder.id.in_(ticket_holders),
TicketHolder.ticket_id.in_(ticket_ids),
)
)
# pytype: enable=attribute-error
elif tickets:
for ticket in tickets:
if int(ticket['id']) in ticket_ids:
qty += ticket.get('quantity', 1)
max_quantity = qty if discount_code.max_quantity < 0 else discount_code.max_quantity
available = (
(qty + old_holders) <= discount_code.tickets_number
and discount_code.min_quantity <= qty <= max_quantity
)
if not available:
logger.warning(
"Discount code usage exhausted",
extra=dict(
discount_code=discount_code,
ticket_ids=ticket_ids,
ticket_holders=ticket_holders,
quantity=qty,
old_holders=old_holders,
),
)
return available
def match_discount_quantity(discount_code,
tickets=None,
ticket_holders=None):
qty = 0
ticket_ids = [ticket.id for ticket in discount_code.tickets]
old_holders = get_count(
TicketHolder.query.filter(
TicketHolder.ticket_id.in_(ticket_ids)).join(Order).filter(
Order.status.in_(['completed', 'placed'])))
if ticket_holders:
for holder in ticket_holders:
ticket_holder = TicketHolder.query.filter_by(id=holder).one()
if ticket_holder.ticket.id in ticket_ids:
qty += 1
elif tickets:
for ticket in tickets:
if int(ticket['id']) in ticket_ids:
qty += ticket['quantity']
if (qty + old_holders) <= discount_code.tickets_number and \
discount_code.min_quantity <= qty <= discount_code.max_quantity:
return True
return False
def track_organizer_count(self, obj):
return get_count(self.get_all_user_roles('track_organizer'))
def coorganizer_count(self, obj):
return get_count(self.get_all_user_roles('coorganizer'))
def mail_last_30_days(self, obj):
all_mails = get_count(Mail.query.filter_by(time=datetime.now(pytz.utc)))
mails_till_last_30_day = get_count(Mail.query.filter(Mail.time <= datetime.now(pytz.utc) - timedelta(days=30)))
return all_mails - mails_till_last_30_day
def unverified_count(self, obj):
return get_count(User.query.filter_by(is_verified=False))
def verified_count(self, obj):
return get_count(User.query.filter_by(is_verified=True))
def get_unread_notif_count(self):
return get_count(Notification.query.filter_by(user=self, is_read=False))
def mail_last_30_days(self, obj):
return get_count(Mail.query.filter(datetime.now(pytz.utc) - Mail.time <= timedelta(days=30)))
def test_get_count(self):
with app.test_request_context():
attendee = AttendeeFactory()
save_to_db(attendee)
self.assertEqual(get_count(TicketHolder.query), 1)
def admin_count(self, obj):
return get_count(User.query.filter_by(is_admin=True))
def events_past_count(self, obj):
return get_count(Event.query.filter(Event.ends_at < datetime.now(pytz.utc)))
def events_published_count(self, obj):
return get_count(Event.query.filter_by(state='published'))
def events_draft_count(self, obj):
return get_count(Event.query.filter_by(state='draft'))
def attendee_count(self, obj):
return get_count(self.get_all_user_roles('attendee'))
