class AdminStatisticsGroupSchema(Schema): """ Api schema """ class Meta: """ Meta class """ type_ = 'admin-statistics-group' self_view = 'v1.admin_statistics_group_detail' inflect = dasherize id = fields.String() groups = fields.Method("number_of_groups") group_events = fields.Method("number_of_group_events") followers = fields.Method("number_of_followers") def number_of_groups(self, obj): all_group = db.session.query(Group).all() return len(all_group) def number_of_group_events(self, obj): unique_group = Event.query.filter(Event.group_id.isnot(None)).all() return len(unique_group) def number_of_followers(self, obj): unique_follower = db.session.query(UserFollowGroup.user_id).distinct() return unique_follower.count()
class AdminSalesInvoicesSchema(Schema): """ Sales invoices """ class Meta: type_ = 'admin-sales-invoices' self_view = 'v1.admin_sales_invoices' inflect = dasherize id = fields.String() identifier = fields.String() status = fields.String() amount = fields.Float() created_at = fields.DateTime() completed_at = fields.DateTime() event_name = fields.Method('format_event_name') sent_to = fields.Method('format_sent_to') @staticmethod def format_event_name(self): return f'{self.event.name}' @staticmethod def format_sent_to(self): return f'{self.user.fullname} <{self.user.email}>'
class AdminStatisticsMailSchema(Schema): """ Api schema """ class Meta: """ Meta class """ type_ = 'admin-statistics-mail' self_view = 'v1.admin_statistics_mail_detail' inflect = dasherize id = fields.String() one_day = fields.Method("mail_last_1_day") three_days = fields.Method("mail_last_3_days") seven_days = fields.Method("mail_last_7_days") thirty_days = fields.Method("mail_last_30_days") def mail_last_1_day(self, obj): return get_count(Mail.query.filter(datetime.now(pytz.utc) - Mail.time <= timedelta(days=1))) def mail_last_3_days(self, obj): return get_count(Mail.query.filter(datetime.now(pytz.utc) - Mail.time <= timedelta(days=3))) def mail_last_7_days(self, obj): return get_count(Mail.query.filter(datetime.now(pytz.utc) - Mail.time <= timedelta(days=7))) def mail_last_30_days(self, obj): return get_count(Mail.query.filter(datetime.now(pytz.utc) - Mail.time <= timedelta(days=30)))
class AdminSalesFeesSchema(Schema): """ Sales fees and revenue for all events """ class Meta: type_ = 'admin-sales-fees' self_view = 'v1.admin_sales_fees' inflect = dasherize id = fields.String() name = fields.String() payment_currency = fields.String() fee_percentage = fields.Float(attribute='fee') maximum_fee = fields.Float(attribute='maximum_fee') revenue = fields.Method('calc_revenue') ticket_count = fields.Method('calc_ticket_count') event_date = fields.Method('get_event_date') @staticmethod def calc_ticket_count(obj): """Count all tickets in all orders of this event""" return sum( [o.tickets_count for o in obj.orders if o.status == 'completed']) @staticmethod def calc_revenue(obj): """Returns total revenues of all completed orders for the given event""" return sum( [o.get_revenue() for o in obj.orders if o.status == 'completed']) @staticmethod def get_event_date(obj): return obj.starts_at.isoformat()
class AdminStatisticsEventSchema(Schema): """ Api schema """ class Meta: """ Meta class """ type_ = 'admin-statistics-event' self_view = 'v1.admin_statistics_event_detail' inflect = dasherize id = fields.String() draft = fields.Method("events_draft_count") published = fields.Method("events_published_count") past = fields.Method("events_past_count") def events_draft_count(self, obj): events = Event.query.filter(Event.ends_at > datetime.now(pytz.utc)) return get_count(events.filter_by(state='draft', deleted_at=None)) def events_published_count(self, obj): events = Event.query.filter(Event.ends_at > datetime.now(pytz.utc)) return get_count(events.filter_by(state='published', deleted_at=None)) def events_past_count(self, obj): return get_count(Event.query.filter(Event.ends_at < datetime.now(pytz.utc)))
class AdminSalesByEventsSchema(Schema): """ Sales summarized by event Provides event(name), date, count of tickets and total sales for orders grouped by status """ class Meta: type_ = 'admin-sales-by-events' self_view = 'v1.admin_sales_by_events' inflect = dasherize id = fields.String() identifier = fields.String() name = fields.String() created_at = fields.DateTime() deleted_at = fields.DateTime() starts_at = fields.DateTime() ends_at = fields.DateTime() payment_currency = fields.String() payment_country = fields.String() completed_order_sales = fields.Integer(dump_only=True) placed_order_sales = fields.Integer(dump_only=True) pending_order_sales = fields.Integer(dump_only=True) completed_order_tickets = fields.Integer(dump_only=True) placed_order_tickets = fields.Integer(dump_only=True) pending_order_tickets = fields.Integer(dump_only=True) type = fields.Method('event_type') owner = fields.Method('event_owner') owner_id = fields.Method('event_owner_id') def event_owner(self, obj): return str(obj.owner.email) def event_owner_id(self, obj): return obj.owner.id def event_type(self, obj): t = 'To be announced' if obj.online: if obj.location_name: t = 'Hybrid' else: t = 'Online' elif obj.location_name: t = 'Venue' return str(t)
class AdminStatisticsUserSchema(Schema): """ Api schema """ class Meta: """ Meta class """ type_ = 'admin-statistics-user' self_view = 'v1.admin_statistics_user_detail' inflect = dasherize id = fields.String() super_admin = fields.Method("super_admin_count") admin = fields.Method("admin_count") verified = fields.Method("verified_count") unverified = fields.Method("unverified_count") organizer = fields.Method("organizer_count") coorganizer = fields.Method("coorganizer_count") attendee = fields.Method("attendee_count") track_organizer = fields.Method("track_organizer_count") def super_admin_count(self, obj): return get_count(User.query.filter_by(is_super_admin=True)) def admin_count(self, obj): return get_count( User.query.filter_by(is_admin=True, is_super_admin=False)) def verified_count(self, obj): return get_count( User.query.filter_by(is_verified=True, is_super_admin=False, is_admin=False)) def unverified_count(self, obj): return get_count( User.query.filter_by(is_verified=False, is_super_admin=False, is_admin=False)) def get_all_user_roles(self, role_name): role = Role.query.filter_by(name=role_name).first() newquery = User.query.join(UsersEventsRoles.user).join( UsersEventsRoles.role).filter( UsersEventsRoles.role == role).distinct() return newquery def organizer_count(self, obj): return self.get_all_user_roles('organizer').count() def coorganizer_count(self, obj): return self.get_all_user_roles('coorganizer').count() def track_organizer_count(self, obj): return self.get_all_user_roles('track_organizer').count() def attendee_count(self, obj): unique_attendee_query = db.session.query(TicketHolder.email).distinct() return unique_attendee_query.count()
class AdminStatisticsUserSchema(Schema): """ Api schema """ class Meta: """ Meta class """ type_ = 'admin-statistics-user' self_view = 'v1.admin_statistics_user_detail' inflect = dasherize id = fields.String() super_admin = fields.Method("super_admin_count") admin = fields.Method("admin_count") verified = fields.Method("verified_count") unverified = fields.Method("unverified_count") organizer = fields.Method("organizer_count") coorganizer = fields.Method("coorganizer_count") attendee = fields.Method("attendee_count") track_organizer = fields.Method("track_organizer_count") def super_admin_count(self, obj): return get_count(User.query.filter_by(is_super_admin=True)) def admin_count(self, obj): return get_count( User.query.filter_by(is_admin=True, is_super_admin=False)) def verified_count(self, obj): return get_count( User.query.filter_by(is_verified=True, is_super_admin=False, is_admin=False)) def unverified_count(self, obj): return get_count( User.query.filter_by(is_verified=False, is_super_admin=False, is_admin=False)) def get_all_user_roles(self, role_name): role = Role.query.filter_by(name=role_name).first() uers = UsersEventsRoles.query.join(UsersEventsRoles.event).join( UsersEventsRoles.role).filter(Event.deleted_at.is_(None), UsersEventsRoles.role == role) return uers def organizer_count(self, obj): return get_count(self.get_all_user_roles('organizer')) def coorganizer_count(self, obj): return get_count(self.get_all_user_roles('coorganizer')) def track_organizer_count(self, obj): return get_count(self.get_all_user_roles('track_organizer')) def attendee_count(self, obj): return get_count(self.get_all_user_roles('attendee'))
class AdvertSchema(Schema): id = fields.Integer(dump_only=True) title = fields.String() images_set = fields.Relationship(schema=ImageSchema, many=True, dump_only=True, dump_to='images') description = fields.String() author = fields.Relationship( schema=UserSchema, type_='user', related_url='/api/v1/users/{author_id}', related_url_kwargs={'author_id': '<author.id>'}, include_resource_linkage=False) # timestamp = TimeStampConvertedField() price = fields.Float() timestamp = fields.LocalDateTime('%Y%m%d%H%M%S', dump_only=True) key = fields.Method('ExampleKeyGenerated', dump_only=True) class Meta: type_ = 'advert' additional = ('id', ) def ExampleKeyGenerated(self, obj): return ''.join(('@', str(obj.item))) @post_load def make_advert(self, data): return Adverts(**data)
class AdminSalesByLocationSchema(Schema): """ Sales summarized by location Provides location name, count of tickets and total sales for orders grouped by status """ class Meta: type_ = 'admin-sales-by-location' self_view = 'v1.admin_sales_by_location' inflect = dasherize id = fields.String() location_name = fields.String() sales = fields.Method('calc_sales') @staticmethod def calc_sales(obj): """ Returns sales (dictionary with total sales and ticket count) for placed, completed and pending orders """ res = {'placed': {}, 'completed': {}, 'pending': {}} res['placed']['sales_total'] = obj.placed_sales or 0 res['placed']['ticket_count'] = obj.placed_tickets or 0 res['completed']['sales_total'] = obj.completed_sales or 0 res['completed']['ticket_count'] = obj.completed_tickets or 0 res['pending']['sales_total'] = obj.pending_sales or 0 res['pending']['ticket_count'] = obj.pending_tickets or 0 return res
class AdminSalesByEventsSchema(Schema): """ Sales summarized by event Provides event(name), date, count of tickets and total sales for orders grouped by status """ class Meta: type_ = 'admin-sales-by-events' self_view = 'v1.admin_sales_by_events' inflect = dasherize id = fields.String() identifier = fields.String() name = fields.String() created_at = fields.DateTime() deleted_at = fields.DateTime() starts_at = fields.DateTime() ends_at = fields.DateTime() payment_currency = fields.String() payment_country = fields.String() sales = fields.Method('calc_sales') @staticmethod def calc_sales(obj): """ Returns sales (dictionary with total sales and ticket count) for placed, completed and pending orders """ return summary(obj)
class AdminSalesByMarketerSchema(Schema): """ Sales summarized by marketer Provides marketer name, count of tickets and total sales for orders grouped by status """ class Meta: type_ = 'admin-sales-by-marketer' self_view = 'v1.admin_sales_by_marketer' id = fields.String() fullname = fields.String() email = fields.String() sales = fields.Method('calc_sales') @staticmethod def calc_sales(obj): """ Returns sales (dictionary with total sales and ticket count) for placed, completed and pending orders """ return summary(obj.orders)
class AdminSalesByOrganizersSchema(Schema): """ Sales summarized by organizer Provides organizer (first name, last name and email), count of tickets and total sales for orders grouped by status """ class Meta: type_ = 'admin-sales-by-organizers' self_view = 'v1.admin_sales_by_organizers' inflect = dasherize id = fields.String() first_name = fields.String() last_name = fields.String() email = fields.String() starts_at = fields.DateTime() ends_at = fields.DateTime() sales = fields.Method('calc_sales') @staticmethod def calc_sales(obj): """ Returns sales (dictionary with total sales and ticket count) for placed, completed and pending orders """ return summary(obj.orders)
class EventStatisticsGeneralSchema(Schema): """ Api schema for general statistics of event """ class Meta: """ Meta class """ type_ = 'event-statistics-general' self_view = 'v1.event_statistics_general_detail' self_view_kwargs = {'id': '<id>'} inflect = dasherize id = fields.Str() identifier = fields.Str() sessions_draft = fields.Method("sessions_draft_count") sessions_submitted = fields.Method("sessions_submitted_count") sessions_accepted = fields.Method("sessions_accepted_count") sessions_confirmed = fields.Method("sessions_confirmed_count") sessions_pending = fields.Method("sessions_pending_count") sessions_rejected = fields.Method("sessions_rejected_count") speakers = fields.Method("speakers_count") sessions = fields.Method("sessions_count") sponsors = fields.Method("sponsors_count") def sessions_draft_count(self, obj): return Session.query.filter_by(event_id=obj.id, state='draft').count() def sessions_submitted_count(self, obj): return Session.query.filter_by(event_id=obj.id, state='submitted').count() def sessions_accepted_count(self, obj): return Session.query.filter_by(event_id=obj.id, state='accepted').count() def sessions_confirmed_count(self, obj): return Session.query.filter_by(event_id=obj.id, state='confirmed').count() def sessions_pending_count(self, obj): return Session.query.filter_by(event_id=obj.id, state='pending').count() def sessions_rejected_count(self, obj): return Session.query.filter_by(event_id=obj.id, state='rejected').count() def speakers_count(self, obj): return Speaker.query.filter_by(event_id=obj.id).count() def sessions_count(self, obj): return Session.query.filter_by(event_id=obj.id).count() def sponsors_count(self, obj): return Sponsor.query.filter_by(event_id=obj.id).count()
class ContextTestSchema(Schema): id = fields.Str() from_context = fields.Method("get_from_context") def get_from_context(self, obj): return self.context["some_value"] class Meta: type_ = "people"
class ContextTestSchema(Schema): id = fields.Str() from_context = fields.Method('get_from_context') def get_from_context(self, obj): return self.context['some_value'] class Meta: type_ = 'people'
class EventOrgaSchema(Schema): """ Schema for Orga Events - a minified version of Events for the Organizer App """ class Meta: type_ = 'event-orga' self_view = 'v1.events_orga' self_view_kwargs = {'id': '<id>'} inflect = dasherize id = fields.Str(dump_only=True) name = fields.Str(required=True) starts_at = fields.DateTime(required=True, timezone=True) tickets_available = fields.Method('calc_total_tickets_count') tickets_sold = fields.Method('calc_tickets_sold_count') revenue = fields.Method('calc_revenue') payment_currency = fields.Str(allow_none=True) @staticmethod def calc_tickets_sold_count(obj): """Calculate total number of tickets sold for the event""" return db.session.query(Order.event_id).filter_by(event_id=obj.id, status='completed').join(TicketHolder)\ .count() @staticmethod def calc_total_tickets_count(obj): """Calculate total available tickets for all types of tickets""" total_available = db.session.query(func.sum( Ticket.quantity)).filter_by(event_id=obj.id).scalar() if total_available is None: total_available = 0 return total_available @staticmethod def calc_revenue(obj): """Returns total revenues of all completed orders for the given event""" revenue = db.session.query(func.sum(Order.amount)).filter_by( event_id=obj.id, status='completed').scalar() if revenue is None: revenue = 0 return revenue
class BundleDependencySchema(PlainSchema): """ Plain (non-JSONAPI) Marshmallow schema for a single bundle dependency. Not defining this as a separate resource with Relationships because we only create a set of dependencies once at bundle creation. """ child_uuid = fields.String(validate=validate_uuid, dump_only=True) child_path = fields.String() # Validated in Bundle ORMObject parent_uuid = fields.String(validate=validate_uuid) parent_path = fields.String(missing="") parent_name = fields.Method('get_parent_name', dump_only=True) # for convenience def get_parent_name(self, dep): uuid = dep['parent_uuid'] return local.model.get_bundle_names([uuid]).get(uuid)
class AdminSalesDiscountedSchema(Schema): """ Discounted sales by event Provides Event name, discount code, marketer mail, count of tickets and total sales for orders grouped by status """ class Meta: type_ = 'admin-sales-discounted' self_view = 'v1.admin_sales_discounted' inflect = dasherize id = fields.String() code = fields.String() email = fields.String() event_name = fields.String() payment_currency = fields.String() sales = fields.Method('calc_sales') @staticmethod def calc_sales(obj): """ Returns sales (dictionary with total sales and ticket count) for placed, completed and pending orders """ res = {'placed': {}, 'completed': {}, 'pending': {}} res['placed']['sales_total'] = obj.placed_sales or 0 res['placed']['ticket_count'] = obj.placed_tickets or 0 res['completed']['sales_total'] = obj.completed_sales or 0 res['completed']['ticket_count'] = obj.completed_tickets or 0 res['pending']['sales_total'] = obj.pending_sales or 0 res['pending']['ticket_count'] = obj.pending_tickets or 0 return res
class AdminStatisticsSessionSchema(Schema): """ Api schema """ class Meta: """ Meta class """ type_ = 'admin-statistics-session' self_view = 'v1.admin_statistics_session_detail' inflect = dasherize id = fields.String() draft = fields.Method("sessions_draft_count") submitted = fields.Method("sessions_submitted_count") accepted = fields.Method("sessions_accepted_count") confirmed = fields.Method("sessions_confirmed_count") pending = fields.Method("sessions_pending_count") rejected = fields.Method("sessions_rejected_count") def sessions_draft_count(self, obj): return get_count(Session.query.filter_by(state='draft')) def sessions_submitted_count(self, obj): return get_count(Session.query.filter_by(state='submitted')) def sessions_accepted_count(self, obj): return get_count(Session.query.filter_by(state='accepted')) def sessions_confirmed_count(self, obj): return get_count(Session.query.filter_by(state='confirmed')) def sessions_pending_count(self, obj): return get_count(Session.query.filter_by(state='pending')) def sessions_rejected_count(self, obj): return get_count(Session.query.filter_by(state='rejected'))
class ProcessStatisticsSchema(Schema): """ Api schema """ class Meta: """ Meta class """ type_ = 'process-statistics' self_view = 'v1.process_statistics_detail' inflect = dasherize id = fields.String() total_requests = fields.Method("total_requests") active_get_requests = fields.Method("active_get_requests") active_post_requests = fields.Method("active_post_requests") active_put_requests = fields.Method("active_put_requests") total_requests_past_hour = fields.Method("total_requests_past_hour") total_requests_past_minute = fields.Method("total_requests_past_minute") avg_response_time_past_minute = fields.Method( "avg_response_time_past_minute") avg_response_time_past_hour = fields.Method("avg_response_time_past_hour") def total_requests(self, obj): return get_count(Process.query.all()) def active_get_requests(self, obj): return get_count(Process.query.filter_by(method="GET")) def active_post_requests(self, obj): return get_count(Process.query.filter_by(method="POST")) def active_put_requests(self, obj): return get_count(Process.query.filter_by(method="PUT")) def total_requests_past_hour(self, obj): all_processes = get_count( Process.query.filter_by(time=datetime.now(pytz.utc))) processes_till_last_1_hour = get_count( Process.query.filter( Process.time <= datetime.now(pytz.utc) - timedelta(hours=1))) return all_processes - processes_till_last_1_hour 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 avg_response_time_past_minute(self, obj): requests = self.total_requests_past_minute() total_time = 0 for process in Process.query.order_by( Process.id.desc()).limit(requests): total_time += process.duration return total_time // requests def avg_response_time_past_hour(self, obj): requests = self.total_requests_past_hour() total_time = 0 for process in Process.query.order_by( Process.id.desc()).limit(requests): total_time += process.duration return total_time // requests
class EventStatisticsGeneralSchema(Schema): """ Api schema for general statistics of event """ class Meta: """ Meta class """ type_ = 'event-statistics-general' self_view = 'v1.event_statistics_general_detail' self_view_kwargs = {'id': '<id>'} inflect = dasherize id = fields.Str() identifier = fields.Str() sessions_draft = fields.Method("sessions_draft_count") sessions_submitted = fields.Method("sessions_submitted_count") sessions_accepted = fields.Method("sessions_accepted_count") sessions_confirmed = fields.Method("sessions_confirmed_count") sessions_pending = fields.Method("sessions_pending_count") sessions_rejected = fields.Method("sessions_rejected_count") speakers = fields.Method("speakers_count") sessions = fields.Method("sessions_count") sponsors = fields.Method("sponsors_count") def sessions_draft_count(self, obj): return Session.query.filter_by(event_id=obj.id, state='draft', deleted_at=None).count() def sessions_submitted_count(self, obj): return Session.query.filter_by(event_id=obj.id, deleted_at=None).count() def sessions_accepted_count(self, obj): return Session.query.filter_by(event_id=obj.id, state='accepted', deleted_at=None).count() def sessions_confirmed_count(self, obj): return Session.query.filter_by(event_id=obj.id, state='confirmed', deleted_at=None).count() def sessions_pending_count(self, obj): return Session.query.filter_by(event_id=obj.id, state='pending', deleted_at=None).count() def sessions_rejected_count(self, obj): return Session.query.filter_by(event_id=obj.id, state='rejected', deleted_at=None).count() def speakers_count_type(self, obj, state='pending'): return SessionsSpeakersLink.query.filter_by(event_id=obj.id, session_state=state, deleted_at=None).count() def speakers_count(self, obj): accepted = self.speakers_count_type(obj=obj, state='accepted') confirmed = self.speakers_count_type(obj=obj, state='confirmed') pending = self.speakers_count_type(obj=obj, state='pending') rejected = self.speakers_count_type(obj=obj, state='rejected') total = Speaker.query.filter_by(event_id=obj.id, deleted_at=None).count() serial_data = { 'accepted': accepted, 'confirmed': confirmed, 'pending': pending, 'rejected': rejected, 'total': total } return serial_data def sessions_count(self, obj): return Session.query.filter_by(event_id=obj.id, deleted_at=None).count() def sponsors_count(self, obj): return Sponsor.query.filter_by(event_id=obj.id, deleted_at=None).count()
class EventStatisticsGeneralSchema(Schema): """ Api schema for general statistics of event """ class Meta: """ Meta class """ type_ = 'event-statistics-general' self_view = 'v1.event_statistics_general_detail' self_view_kwargs = {'id': '<id>'} inflect = dasherize id = fields.Str() identifier = fields.Str() sessions_draft = fields.Method("sessions_draft_count") sessions_submitted = fields.Method("sessions_submitted_count") sessions_accepted = fields.Method("sessions_accepted_count") sessions_confirmed = fields.Method("sessions_confirmed_count") sessions_pending = fields.Method("sessions_pending_count") sessions_rejected = fields.Method("sessions_rejected_count") sessions_withdrawn = fields.Method("sessions_withdrawn_count") sessions_canceled = fields.Method("sessions_canceled_count") speakers = fields.Method("speakers_count") sessions = fields.Method("sessions_count") sponsors = fields.Method("sponsors_count") speaker_without_session = fields.Method("speaker_without_session_count") @cache.memoize(50) def get_session_stats(self, event): stats = (Session.query.filter_by( event_id=event.id, deleted_at=None).with_entities( Session.state, func.count()).group_by(Session.state).all()) data = dict(stats) data['all'] = sum([x for _, x in stats]) return data def sessions_draft_count(self, obj): return self.get_session_stats(obj).get('draft', 0) def sessions_submitted_count(self, obj): return self.get_session_stats(obj).get('all', 0) def sessions_accepted_count(self, obj): return self.get_session_stats(obj).get('accepted', 0) def sessions_confirmed_count(self, obj): return self.get_session_stats(obj).get('confirmed', 0) def sessions_pending_count(self, obj): return self.get_session_stats(obj).get('pending', 0) def sessions_rejected_count(self, obj): return self.get_session_stats(obj).get('rejected', 0) def sessions_withdrawn_count(self, obj): return self.get_session_stats(obj).get('withdrawn', 0) def sessions_canceled_count(self, obj): return self.get_session_stats(obj).get('canceled', 0) def get_speaker_stats(self, event): stats = (Speaker.query.join(Speaker.sessions).filter( Speaker.event_id == event.id, Speaker.deleted_at == None, Session.deleted_at == None, ).with_entities(Session.state, func.count(distinct( Speaker.id))).group_by(Session.state).all()) data = dict(stats) data['total'] = sum([x for _, x in stats]) return data def speaker_without_session_count(self, obj): return Speaker.query.filter( Speaker.sessions == None, Speaker.event_id == obj.id, Speaker.deleted_at == None, ).count() @cache.memoize(50) def speakers_count(self, obj): stats = self.get_speaker_stats(obj) serial_data = { 'accepted': 0, 'confirmed': 0, 'pending': 0, 'rejected': 0, 'withdrawn': 0, 'canceled': 0, 'total': 0, **stats, } return serial_data @cache.memoize(50) def sessions_count(self, obj): return Session.query.filter_by(event_id=obj.id, deleted_at=None).count() @cache.memoize(50) def sponsors_count(self, obj): return Sponsor.query.filter_by(event_id=obj.id, deleted_at=None).count()
class OrderStatisticsEventSchema(Schema): """ Api schema for general statistics of event """ class Meta: """ Meta class """ type_ = 'order-statistics-event' self_view = 'v1.order_statistics_event_detail' self_view_kwargs = {'id': '<id>'} inflect = dasherize id = fields.Str() identifier = fields.Str() tickets = fields.Method("tickets_count") orders = fields.Method("orders_count") sales = fields.Method("sales_count") def tickets_count(self, obj): obj_id = obj.id total = db.session.query(func.sum(OrderTicket.quantity.label('sum'))).join(Order.order_tickets).filter( Order.event_id == obj_id).scalar() draft = db.session.query(func.sum(OrderTicket.quantity.label('sum'))).join(Order.order_tickets).filter( Order.event_id == obj_id, Order.status == 'draft').scalar() cancelled = db.session.query(func.sum(OrderTicket.quantity.label('sum'))).join(Order.order_tickets).filter( Order.event_id == obj_id, Order.status == 'cancelled').scalar() pending = db.session.query(func.sum(OrderTicket.quantity.label('sum'))).join(Order.order_tickets).filter( Order.event_id == obj_id, Order.status == 'pending').scalar() expired = db.session.query(func.sum(OrderTicket.quantity.label('sum'))).join(Order.order_tickets).filter( Order.event_id == obj_id, Order.status == 'expired').scalar() placed = db.session.query(func.sum(OrderTicket.quantity.label('sum'))).join(Order.order_tickets).filter( Order.event_id == obj_id, Order.status == 'placed').scalar() 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 } return result def orders_count(self, obj): obj_id = obj.id total = get_count(db.session.query(Order).filter(Order.event_id == obj_id)) draft = get_count(db.session.query(Order).filter(Order.event_id == obj_id, Order.status == 'draft')) cancelled = get_count(db.session.query(Order).filter(Order.event_id == obj_id, Order.status == 'cancelled')) pending = get_count(db.session.query(Order).filter(Order.event_id == obj_id, Order.status == 'pending')) expired = get_count(db.session.query(Order).filter(Order.event_id == obj_id, Order.status == 'expired')) placed = get_count(db.session.query(Order).filter(Order.event_id == obj_id, Order.status == 'placed')) 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 } return result def sales_count(self, obj): obj_id = obj.id total = db.session.query(func.sum(Order.amount.label('sum'))).filter(Order.event_id == obj_id).scalar() draft = db.session.query(func.sum(Order.amount.label('sum'))).filter(Order.event_id == obj_id, Order.status == 'draft').scalar() cancelled = db.session.query(func.sum(Order.amount.label('sum'))).filter(Order.event_id == obj_id, Order.status == 'cancelled').scalar() pending = db.session.query(func.sum(Order.amount.label('sum'))).filter(Order.event_id == obj_id, Order.status == 'pending').scalar() expired = db.session.query(func.sum(Order.amount.label('sum'))).filter(Order.event_id == obj_id, Order.status == 'expired').scalar() placed = db.session.query(func.sum(Order.amount.label('sum'))).filter(Order.event_id == obj_id, Order.status == 'placed').scalar() 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 } return result