'long_biography': fields.String(),
'email': fields.Email(),
'mobile': fields.String(),
'website': fields.Uri(),
'twitter': fields.String(), # not sure for now whether uri or string field
'facebook': fields.String(),
'github': fields.String(),
'linkedin': fields.String(),
'organisation': fields.String(),
'position': fields.String(),
'country': fields.String(),
'sessions': fields.List(fields.Nested(SPEAKER_SESSION)),
})
SPEAKER_PAGINATED = api.clone('SpeakerPaginated', PAGINATED_MODEL, {
'results': fields.List(fields.Nested(SPEAKER))
})
SPEAKER_POST = api.clone('SpeakerPost', SPEAKER)
del SPEAKER_POST['id']
del SPEAKER_POST['sessions'] # don't allow adding sessions
# Create DAO
class SpeakerDAO(ServiceDAO):
def create(self, event_id, data, url):
data = self.validate(data, event_id)
return ServiceDAO.create(self, event_id, data, url, validate=False)
def update(self, event_id, service_id, data):
data = self.validate(data, event_id)
'avatar': fields.Upload(),
'contact': fields.String(),
'facebook': fields.String(),
'twitter': fields.String()
})
USER = api.model('User', {
'id': fields.Integer(),
'email': fields.Email(required=True),
'signup_time': fields.DateTime(),
'last_access_time': fields.DateTime(),
'user_detail': fields.Nested(USER_DETAIL)
})
USER_PAGINATED = api.clone('UserPaginated', PAGINATED_MODEL, {
'results': fields.List(fields.Nested(USER))
})
USER_PUT = api.clone('UserPut', USER)
del USER_PUT['id']
del USER_PUT['signup_time']
del USER_PUT['last_access_time']
USER_POST = api.model('UserPost', {
'email': fields.Email(required=True),
'password': fields.String(required=True)
})
# Responses
USER_POST_RESPONSES = POST_RESPONSES.copy()
from open_event.models.event import Event as EventModel
from .helpers import get_object_list, get_object_or_404, get_object_in_event,\
get_paginated_list
from utils import PAGINATED_MODEL, PaginatedResourceBase
api = Namespace('languages', description='languages', path='/')
LANGUAGE = api.model('Language', {
'id': fields.Integer(required=True),
'name': fields.String,
'label_en': fields.String,
'label_de': fields.String,
})
LANGUAGE_PAGINATED = api.clone('LanguagePaginated', PAGINATED_MODEL, {
'results': fields.List(fields.Nested(LANGUAGE))
})
@api.route('/events/<int:event_id>/languages/<int:language_id>')
@api.response(404, 'Language not found')
@api.response(400, 'Object does not belong to event')
class Language(Resource):
@api.doc('get_language')
@api.marshal_with(LANGUAGE)
def get(self, event_id, language_id):
"""Fetch a language given its id"""
return get_object_in_event(LanguageModel, language_id, event_id)
@api.route('/events/<int:event_id>/languages')
'description': fields.String(),
'location_name': fields.String(),
'organizer_name': fields.String(),
'organizer_description': fields.String(),
'state': fields.String(),
'closing_datetime': fields.DateTime(),
'type': EventTypeField(),
'topic': EventTopicField(),
'privacy': fields.String(),
'ticket_url': fields.Uri(),
'creator': fields.Nested(EVENT_CREATOR, allow_null=True),
'schedule_published_on': fields.DateTime()
})
EVENT_PAGINATED = api.clone('EventPaginated', PAGINATED_MODEL, {
'results': fields.List(fields.Nested(EVENT))
})
EVENT_POST = api.clone('EventPost', EVENT)
del EVENT_POST['id']
del EVENT_POST['creator']
class EventDAO(BaseDAO):
"""
Event DAO
"""
def fix_payload(self, data):
"""
Fixes the payload data.
Here converts string time from datetime obj
'icon': fields.Upload(),
})
SESSION_MICROLOCATION = api.model('SessionMicrolocation', {
'id': fields.Integer(required=True),
'name': fields.String(),
})
SESSION_TYPE = api.model(
'SessionType', {
'id': fields.Integer(required=True),
'name': fields.String(required=True),
'length': fields.String(required=True)
})
SESSION_TYPE_POST = api.clone('SessionTypePost', SESSION_TYPE)
del SESSION_TYPE_POST['id']
SESSION = api.model(
'Session', {
'id': fields.Integer(required=True),
'title': fields.String(required=True),
'subtitle': fields.String(),
'level': fields.String(),
'short_abstract': fields.String(),
'long_abstract': fields.String(),
'comments': fields.String(),
'start_time': fields.DateTime(required=True),
'end_time': fields.DateTime(required=True),
'track': fields.Nested(SESSION_TRACK, allow_null=True),
'speakers': fields.List(fields.Nested(SESSION_SPEAKER)),
from app.api.helpers.utils import Resource, ETAG_HEADER_DEFN
api = Namespace('microlocations', description='Microlocations', path='/')
MICROLOCATION = api.model(
'Microlocation', {
'id': fields.Integer(required=True),
'name': fields.String(required=True),
'latitude': fields.Float(),
'longitude': fields.Float(),
'floor': fields.Integer(),
'room': fields.String(),
})
MICROLOCATION_PAGINATED = api.clone(
'MicrolocationPaginated', PAGINATED_MODEL,
{'results': fields.List(fields.Nested(MICROLOCATION))})
MICROLOCATION_POST = api.clone('MicrolocationPost', MICROLOCATION)
del MICROLOCATION_POST['id']
# Create DAO
class MicrolocationDAO(ServiceDAO):
version_key = 'microlocations_ver'
DAO = MicrolocationDAO(MicrolocationModel, MICROLOCATION_POST)
@api.route('/events/<int:event_id>/microlocations/<int:microlocation_id>')
from .helpers.utils import Resource
api = Namespace('notifications', description='Notifications', path='/')
NOTIFICATION = api.model(
'Notification', {
'id': fields.Integer(required=True),
'email': fields.String(required=True),
'title': fields.String(),
'message': fields.String(),
'action': fields.String(),
'received_at': fields.DateTime(),
})
NOTIFICATION_PAGINATED = api.clone(
'NotificationPaginated', PAGINATED_MODEL,
{'results': fields.List(fields.Nested(NOTIFICATION))})
NOTIFICATION_POST = api.clone('NotificationPost', NOTIFICATION)
del NOTIFICATION_POST['id']
# Create DAO
class NotificationDAO(ServiceDAO):
version_key = 'notifications_ver'
def create_user_notify(self, payload):
user = DataGetter.get_user_by_email(payload['email'])
DataManager().create_user_notification(user, payload['action'],
payload['title'],
payload['message'])
PAGE_PARAMS, POST_RESPONSES, PUT_RESPONSES, SERVICE_RESPONSES
from .helpers.utils import Resource, ETAG_HEADER_DEFN
api = Namespace('microlocations', description='Microlocations', path='/')
MICROLOCATION = api.model('Microlocation', {
'id': fields.Integer(required=True),
'name': fields.String(required=True),
'latitude': fields.Float(),
'longitude': fields.Float(),
'floor': fields.Integer(),
'room': fields.String(),
})
MICROLOCATION_PAGINATED = api.clone('MicrolocationPaginated', PAGINATED_MODEL, {
'results': fields.List(fields.Nested(MICROLOCATION))
})
MICROLOCATION_POST = api.clone('MicrolocationPost', MICROLOCATION)
del MICROLOCATION_POST['id']
# Create DAO
class MicrolocationDAO(ServiceDAO):
version_key = 'microlocations_ver'
DAO = MicrolocationDAO(MicrolocationModel, MICROLOCATION_POST)
@api.route('/events/<int:event_id>/microlocations/<int:microlocation_id>')
'id': fields.Integer(required=True),
'title': fields.String(),
})
TRACK = api.model(
'Track', {
'id': fields.Integer(required=True),
'name': fields.String(required=True),
'description': fields.String(),
'color': fields.Color(required=True),
'track_image_url': fields.Upload(),
'location': fields.String(),
'sessions': fields.List(fields.Nested(TRACK_SESSION)),
})
TRACK_PAGINATED = api.clone('TrackPaginated', PAGINATED_MODEL,
{'results': fields.List(fields.Nested(TRACK))})
TRACK_POST = api.clone('TrackPost', TRACK)
del TRACK_POST['id']
del TRACK_POST['sessions']
# Create DAO
class TrackDAO(ServiceDAO):
version_key = 'tracks_ver'
DAO = TrackDAO(TrackModel, TRACK_POST)
@api.route('/events/<int:event_id>/tracks/<int:track_id>')
'id': fields.Integer(required=True),
'title': fields.String(),
})
TRACK = api.model('Track', {
'id': fields.Integer(required=True),
'name': fields.String(required=True),
'description': fields.String(),
'color': fields.Color(required=True),
'track_image_url': fields.Upload(),
'location': fields.String(),
'sessions': fields.List(fields.Nested(TRACK_SESSION)),
})
TRACK_PAGINATED = api.clone('TrackPaginated', PAGINATED_MODEL, {
'results': fields.List(fields.Nested(TRACK))
})
TRACK_POST = api.clone('TrackPost', TRACK)
del TRACK_POST['id']
del TRACK_POST['sessions']
# Create DAO
class TrackDAO(ServiceDAO):
version_key = 'tracks_ver'
DAO = TrackDAO(TrackModel, TRACK_POST)
@api.route('/events/<int:event_id>/tracks/<int:track_id>')
from open_event.models.session import Level as LevelModel
from open_event.models.event import Event as EventModel
from .helpers import get_object_list, get_object_or_404, get_object_in_event,\
get_paginated_list
from utils import PAGINATED_MODEL, PaginatedResourceBase
api = Namespace('levels', description='levels', path='/')
LEVEL = api.model('Level', {
'id': fields.Integer(required=True),
'name': fields.String,
'label_en': fields.String,
})
LEVEL_PAGINATED = api.clone('LevelPaginated', PAGINATED_MODEL, {
'results': fields.List(fields.Nested(LEVEL))
})
@api.route('/events/<int:event_id>/levels/<int:level_id>')
@api.response(404, 'Level not found')
@api.response(400, 'Object does not belong to event')
class Level(Resource):
@api.doc('get_level')
@api.marshal_with(LEVEL)
def get(self, event_id, level_id):
"""Fetch a level given its id"""
return get_object_in_event(LevelModel, level_id, event_id)
@api.route('/events/<int:event_id>/levels')
"twitter": fields.String(),
},
)
USER = api.model(
"User",
{
"id": fields.Integer(),
"email": fields.Email(required=True),
"signup_time": fields.DateTime(),
"last_access_time": fields.DateTime(),
"user_detail": fields.Nested(USER_DETAIL),
},
)
USER_PAGINATED = api.clone("UserPaginated", PAGINATED_MODEL, {"results": fields.List(fields.Nested(USER))})
USER_PUT = api.clone("UserPut", USER)
del USER_PUT["id"]
del USER_PUT["signup_time"]
del USER_PUT["last_access_time"]
USER_POST = api.model("UserPost", {"email": fields.Email(required=True), "password": fields.String(required=True)})
# Responses
USER_POST_RESPONSES = POST_RESPONSES.copy()
del USER_POST_RESPONSES[404]
del USER_POST_RESPONSES[401]
EVENT_VERSION = api.model('EventVersion', {
'event_ver': fields.Integer(),
'sessions_ver': fields.Integer(),
'speakers_ver': fields.Integer(),
'tracks_ver': fields.Integer(),
'sponsors_ver': fields.Integer(),
'microlocations_ver': fields.Integer()
})
SOCIAL_LINK = api.model('SocialLink', {
'id': fields.Integer(),
'name': fields.String(required=True),
'link': fields.String(required=True)
})
SOCIAL_LINK_POST = api.clone('SocialLinkPost', SOCIAL_LINK)
del SOCIAL_LINK_POST['id']
EVENT = api.model('Event', {
'id': fields.Integer(required=True),
'name': fields.String(required=True),
'email': fields.Email(),
'logo': fields.Upload(),
'start_time': fields.DateTime(required=True),
'end_time': fields.DateTime(required=True),
'timezone': fields.String(),
'latitude': fields.Float(),
'longitude': fields.Float(),
'event_url': fields.Uri(),
'background_url': fields.Upload(),
'description': fields.String(),
POST_RESPONSES
from app.api.helpers.utils import Resource
api = Namespace('notifications', description='Notifications', path='/')
NOTIFICATION = api.model('Notification', {
'id': fields.Integer(required=True),
'email': fields.String(required=True),
'title': fields.String(),
'message': fields.String(),
'action': fields.String(),
'received_at': fields.DateTime(),
})
NOTIFICATION_PAGINATED = api.clone('NotificationPaginated', PAGINATED_MODEL, {
'results': fields.List(fields.Nested(NOTIFICATION))
})
NOTIFICATION_POST = api.clone('NotificationPost', NOTIFICATION)
del NOTIFICATION_POST['id']
# Create DAO
class NotificationDAO(ServiceDAO):
version_key = 'notifications_ver'
def create_user_notify(self, payload):
user = DataGetter.get_user_by_email(payload['email'])
DataManager().create_user_notification(user, payload['action'], payload['title'], payload['message'])
return user
from app.api.helpers.utils import Resource, ETAG_HEADER_DEFN
api = Namespace('sponsors', description='Sponsors', path='/')
SPONSOR = api.model(
'Sponsor', {
'id': fields.Integer(required=True),
'name': fields.String(required=True),
'url': fields.Uri(),
'logo': fields.Upload(),
'description': fields.String(),
'level': fields.String(),
'sponsor_type': fields.String(),
})
SPONSOR_PAGINATED = api.clone('SponsorPaginated', PAGINATED_MODEL,
{'results': fields.List(fields.Nested(SPONSOR))})
SPONSOR_POST = api.clone('SponsorPost', SPONSOR)
del SPONSOR_POST['id']
# Create DAO
class SponsorDAO(ServiceDAO):
version_key = 'sponsors_ver'
def list_types(self, event_id):
sponsors = self.list(event_id)
return list(
set(sponsor.sponsor_type for sponsor in sponsors
if sponsor.sponsor_type))
'name': fields.String(),
'organisation': fields.String()
})
SESSION_MICROLOCATION = api.model('SessionMicrolocation', {
'id': fields.Integer(required=True),
'name': fields.String(),
})
SESSION_TYPE_FULL = api.model('SessionTypeFull', {
'id': fields.Integer(required=True),
'name': fields.String(required=True),
'length': fields.Float(required=True)
})
SESSION_TYPE = api.clone('SessionType', SESSION_TYPE_FULL)
del SESSION_TYPE['length']
SESSION = api.model('Session', {
'id': fields.Integer(required=True),
'title': fields.String(required=True),
'subtitle': fields.String(),
'short_abstract': fields.String(),
'long_abstract': fields.String(),
'comments': fields.String(),
'start_time': fields.DateTime(),
'end_time': fields.DateTime(),
'track': fields.Nested(SESSION_TRACK, allow_null=True),
'speakers': fields.List(fields.Nested(SESSION_SPEAKER)),
'language': SessionLanguageField(),
'microlocation': fields.Nested(SESSION_MICROLOCATION, allow_null=True),
'background_url': fields.ImageUri(),
'description': fields.String(),
'location_name': fields.String(),
'organizer_name': fields.String(),
'organizer_description': fields.String(),
'state': fields.String(),
'closing_datetime': fields.DateTime(),
'type': EventTypeField(),
'topic': EventTopicField(),
'privacy': fields.String(),
'ticket_url': fields.Uri(),
'creator': fields.Nested(EVENT_CREATOR, allow_null=True),
'schedule_published_on': fields.DateTime()
})
EVENT_PAGINATED = api.clone('EventPaginated', PAGINATED_MODEL,
{'results': fields.List(fields.Nested(EVENT))})
EVENT_POST = api.clone('EventPost', EVENT)
del EVENT_POST['id']
del EVENT_POST['creator']
class EventDAO(BaseDAO):
"""
Event DAO
"""
def fix_payload(self, data):
"""
Fixes the payload data.
Here converts string time from datetime obj
"""
'long_biography': fields.String(),
'email': fields.Email(),
'mobile': fields.String(),
'website': fields.Uri(),
'twitter':
fields.String(), # not sure for now whether uri or string field
'facebook': fields.String(),
'github': fields.String(),
'linkedin': fields.String(),
'organisation': fields.String(),
'position': fields.String(),
'country': fields.String(),
'sessions': fields.List(fields.Nested(SPEAKER_SESSION)),
})
SPEAKER_PAGINATED = api.clone('SpeakerPaginated', PAGINATED_MODEL,
{'results': fields.List(fields.Nested(SPEAKER))})
SPEAKER_POST = api.clone('SpeakerPost', SPEAKER)
del SPEAKER_POST['id']
del SPEAKER_POST['sessions'] # don't allow adding sessions
# Create DAO
class SpeakerDAO(ServiceDAO):
pass
DAO = SpeakerDAO(SpeakerModel, SPEAKER_POST)
@api.route('/events/<int:event_id>/speakers/<int:speaker_id>')
'id': fields.Integer(required=True),
'title': fields.String,
'subtitle': fields.String,
'abstract': fields.String,
'description': fields.String,
'start_time': fields.DateTime,
'end_time': fields.DateTime,
'track': fields.Nested(SESSION_TRACK),
'speakers': fields.List(fields.Nested(SESSION_SPEAKER)),
'level': fields.Nested(SESSION_LEVEL),
'language': fields.Nested(SESSION_LANGUAGE),
'microlocation': fields.Nested(SESSION_MICROLOCATION),
})
SESSION_PAGINATED = api.clone('SessionPaginated', PAGINATED_MODEL, {
'results': fields.List(fields.Nested(SESSION))
})
@api.route('/events/<int:event_id>/sessions/<int:session_id>')
@api.response(404, 'Session not found')
@api.response(400, 'Object does not belong to event')
class Session(Resource):
@api.doc('get_session')
@api.marshal_with(SESSION)
def get(self, event_id, session_id):
"""Fetch a session given its id"""
return get_object_in_event(SessionModel, session_id, event_id)
@api.route('/events/<int:event_id>/sessions')
'avatar': fields.Upload(),
'contact': fields.String(),
'facebook': fields.String(),
'twitter': fields.String()
})
USER = api.model(
'User', {
'id': fields.Integer(),
'email': fields.Email(required=True),
'signup_time': fields.DateTime(),
'last_access_time': fields.DateTime(),
'user_detail': fields.Nested(USER_DETAIL)
})
USER_PAGINATED = api.clone('UserPaginated', PAGINATED_MODEL,
{'results': fields.List(fields.Nested(USER))})
USER_PUT = api.clone('UserPut', USER)
del USER_PUT['id']
del USER_PUT['signup_time']
del USER_PUT['last_access_time']
USER_POST = api.model('UserPost', {
'email': fields.Email(required=True),
'password': fields.String(required=True)
})
# Responses
USER_POST_RESPONSES = POST_RESPONSES.copy()
del USER_POST_RESPONSES[404]
'event_ver': fields.Integer(),
'sessions_ver': fields.Integer(),
'speakers_ver': fields.Integer(),
'tracks_ver': fields.Integer(),
'sponsors_ver': fields.Integer(),
'microlocations_ver': fields.Integer()
})
SOCIAL_LINK = api.model(
'SocialLink', {
'id': fields.Integer(),
'name': fields.String(required=True),
'link': fields.String(required=True)
})
SOCIAL_LINK_POST = api.clone('SocialLinkPost', SOCIAL_LINK)
del SOCIAL_LINK_POST['id']
EVENT = api.model(
'Event', {
'id':
fields.Integer(required=True),
'identifier':
fields.String(),
'name':
fields.String(required=True),
'event_url':
fields.Uri(),
'email':
fields.Email(),
'logo':
from open_event.models.event import Event as EventModel
from .helpers import get_object_list, get_object_or_404, get_object_in_event,\
get_paginated_list
from utils import PAGINATED_MODEL, PaginatedResourceBase
api = Namespace('sponsors', description='sponsors', path='/')
SPONSOR = api.model('Sponsor', {
'id': fields.Integer(required=True),
'name': fields.String,
'url': fields.String,
'logo': fields.String,
})
SPONSOR_PAGINATED = api.clone('SponsorPaginated', PAGINATED_MODEL, {
'results': fields.List(fields.Nested(SPONSOR))
})
@api.route('/events/<int:event_id>/sponsors/<int:sponsor_id>')
@api.response(404, 'Sponsor not found')
@api.response(400, 'Object does not belong to event')
class Sponsor(Resource):
@api.doc('get_sponsor')
@api.marshal_with(SPONSOR)
def get(self, event_id, sponsor_id):
"""Fetch a sponsor given its id"""
return get_object_in_event(SponsorModel, sponsor_id, event_id)
@api.route('/events/<int:event_id>/sponsors')
'organizer_name': fields.String(),
'organizer_description': fields.String(),
'state': fields.String(),
'closing_datetime': fields.DateTime(),
'type': EventTypeField(),
'topic': EventTopicField(),
'privacy': EventPrivacyField(),
'ticket_url': fields.Uri(),
'creator': fields.Nested(EVENT_CREATOR, allow_null=True),
'schedule_published_on': fields.DateTime(),
'code_of_conduct': fields.String(),
'social_links': fields.List(fields.Nested(EVENT_SOCIAL), attribute='social_link')
})
EVENT_PAGINATED = api.clone('EventPaginated', PAGINATED_MODEL, {
'results': fields.List(fields.Nested(EVENT))
})
EVENT_POST = api.clone('EventPost', EVENT)
SOCIAL_LINK_POST = api.clone('SocialLinkPost', EVENT_SOCIAL)
del EVENT_POST['id']
del EVENT_POST['creator']
del EVENT_POST['social_links']
del SOCIAL_LINK_POST['id']
# ###################
# Data Access Objects
# ###################
