"city": "Default City",

"maxAttendees": 0,

"seatsAvailable": 0,

"topics": [ "Default", "Topic" ],

'EQ': '=',

'GT': '>',

'GTEQ': '>=',

'LT': '<',

'LTEQ': '<=',

'NE': '!='

'CITY': 'city',

'TOPIC': 'topics',

'MONTH': 'month',

'MAX_ATTENDEES': 'maxAttendees',

"""Conference API v0.1"""

# - - - Conference objects - - - - - - - - - - - - - - - - -

def _copyConferenceToForm(self, conf, displayName):

"""Copy relevant fields from Conference to ConferenceForm."""

cf = ConferenceForm()

for field in cf.all_fields():

if hasattr(conf, field.name):

# convert Date to date string; just copy others

if field.name.endswith('Date'):

setattr(cf, field.name, str(getattr(conf, field.name)))

else:

setattr(cf, field.name, getattr(conf, field.name))

elif field.name == "websafeKey":

setattr(cf, field.name, conf.key.urlsafe())

if displayName:

setattr(cf, 'organizerDisplayName', displayName)

cf.check_initialized()

return cf

def _createConferenceObject(self, request):

"""Create or update Conference object, returning ConferenceForm/request."""

# preload necessary data items

user = endpoints.get_current_user()

if not user:

raise endpoints.UnauthorizedException('Authorization required')

user_id = getUserId(user)

if not request.name:

raise endpoints.BadRequestException("Conference 'name' field required")

# copy ConferenceForm/ProtoRPC Message into dict

data = {field.name: getattr(request, field.name) for field in request.all_fields()}

del data['websafeKey']

del data['organizerDisplayName']

# add default values for those missing (both data model & outbound Message)

for df in DEFAULTS:

if data[df] in (None, []):

data[df] = DEFAULTS[df]

setattr(request, df, DEFAULTS[df])

# convert dates from strings to Date objects; set month based on start_date

if data['startDate']:

data['startDate'] = datetime.strptime(data['startDate'][:10], "%Y-%m-%d").date()

data['month'] = data['startDate'].month

else:

data['month'] = 0

if data['endDate']:

data['endDate'] = datetime.strptime(data['endDate'][:10], "%Y-%m-%d").date()

# set seatsAvailable to be same as maxAttendees on creation

if data["maxAttendees"] > 0:

data["seatsAvailable"] = data["maxAttendees"]

# generate Profile Key based on user ID and Conference

# ID based on Profile key get Conference key from ID

p_key = ndb.Key(Profile, user_id)

c_id = Conference.allocate_ids(size=1, parent=p_key)[0]

c_key = ndb.Key(Conference, c_id, parent=p_key)

data['key'] = c_key

data['organizerUserId'] = request.organizerUserId = user_id

# create Conference, send email to organizer confirming

# creation of Conference & return (modified) ConferenceForm

Conference(**data).put()

taskqueue.add(params={'email': user.email(),

'conferenceInfo': repr(request)},

url='/tasks/send_confirmation_email'

)

return request

@ndb.transactional()

def _updateConferenceObject(self, request):

user = endpoints.get_current_user()

if not user:

raise endpoints.UnauthorizedException('Authorization required')

user_id = getUserId(user)

# copy ConferenceForm/ProtoRPC Message into dict

data = {field.name: getattr(request, field.name) for field in request.all_fields()}

# update existing conference

conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()

# check that conference exists

if not conf:

raise endpoints.NotFoundException(

'No conference found with key: %s' % request.websafeConferenceKey)

# check that user is owner

if user_id != conf.organizerUserId:

raise endpoints.ForbiddenException(

'Only the owner can update the conference.')

# Not getting all the fields, so don't create a new object; just

# copy relevant fields from ConferenceForm to Conference object

for field in request.all_fields():

data = getattr(request, field.name)

# only copy fields where we get data

if data not in (None, []):

# special handling for dates (convert string to Date)

if field.name in ('startDate', 'endDate'):

data = datetime.strptime(data, "%Y-%m-%d").date()

if field.name == 'startDate':

conf.month = data.month

# write to Conference object

setattr(conf, field.name, data)

conf.put()

prof = ndb.Key(Profile, user_id).get()

return self._copyConferenceToForm(conf, getattr(prof, 'displayName'))

@endpoints.method(ConferenceForm, ConferenceForm, path='conference',

http_method='POST', name='createConference')

def createConference(self, request):

"""Create new conference."""

return self._createConferenceObject(request)

@endpoints.method(CONF_POST_REQUEST, ConferenceForm,

path='conference/{websafeConferenceKey}',

http_method='PUT', name='updateConference')

def updateConference(self, request):

"""Update conference w/provided fields & return w/updated info."""

return self._updateConferenceObject(request)

@endpoints.method(CONF_GET_REQUEST, ConferenceForm,

path='conference/{websafeConferenceKey}',

http_method='GET', name='getConference')

def getConference(self, request):

"""Return requested conference (by websafeConferenceKey)."""

# get Conference object from request; bail if not found

conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()

if not conf:

raise endpoints.NotFoundException(

'No conference found with key: %s' % request.websafeConferenceKey)

prof = conf.key.parent().get()

# return ConferenceForm

return self._copyConferenceToForm(conf, getattr(prof, 'displayName'))

@endpoints.method(message_types.VoidMessage, ConferenceForms,

path='getConferencesCreated',

http_method='POST', name='getConferencesCreated')

def getConferencesCreated(self, request):

"""Return conferences created by user."""

# make sure user is authed

user = endpoints.get_current_user()

if not user:

raise endpoints.UnauthorizedException('Authorization required')

user_id = getUserId(user)

# create ancestor query for all key matches for this user

confs = Conference.query(ancestor=ndb.Key(Profile, user_id))

prof = ndb.Key(Profile, user_id).get()

# return set of ConferenceForm objects per Conference

return ConferenceForms(

items=[self._copyConferenceToForm(conf, getattr(prof, 'displayName')) for conf in confs]

)

def _getQuery(self, request):

"""Return formatted query from the submitted filters."""

q = Conference.query()

inequality_filter, filters = self._formatFilters(request.filters)

# If exists, sort on inequality filter first

if not inequality_filter:

q = q.order(Conference.name)

else:

q = q.order(ndb.GenericProperty(inequality_filter))

q = q.order(Conference.name)

for filtr in filters:

if filtr["field"] in ["month", "maxAttendees"]:

filtr["value"] = int(filtr["value"])

formatted_query = ndb.query.FilterNode(filtr["field"], filtr["operator"], filtr["value"])

q = q.filter(formatted_query)

return q

def _formatFilters(self, filters):

"""Parse, check validity and format user supplied filters."""

formatted_filters = []

inequality_field = None

for f in filters:

filtr = {field.name: getattr(f, field.name) for field in f.all_fields()}

try:

filtr["field"] = FIELDS[filtr["field"]]

filtr["operator"] = OPERATORS[filtr["operator"]]

except KeyError:

raise endpoints.BadRequestException("Filter contains invalid field or operator.")

# Every operation except "=" is an inequality

if filtr["operator"] != "=":

# check if inequality operation has been used in previous filters

# disallow the filter if inequality was performed on a different field before

# track the field on which the inequality operation is performed

if inequality_field and inequality_field != filtr["field"]:

raise endpoints.BadRequestException("Inequality filter is allowed on only one field.")

else:

inequality_field = filtr["field"]

formatted_filters.append(filtr)

return (inequality_field, formatted_filters)

@endpoints.method(ConferenceQueryForms, ConferenceForms,

path='queryConferences',

http_method='POST',

name='queryConferences')

def queryConferences(self, request):

"""Query for conferences."""

conferences = self._getQuery(request)

# need to fetch organiser displayName from profiles

# get all keys and use get_multi for speed

organisers = [(ndb.Key(Profile, conf.organizerUserId)) for conf in conferences]

profiles = ndb.get_multi(organisers)

# put display names in a dict for easier fetching

names = {}

for profile in profiles:

names[profile.key.id()] = profile.displayName

# return individual ConferenceForm object per Conference

return ConferenceForms(

items=[self._copyConferenceToForm(conf, names[conf.organizerUserId]) for conf in \

conferences]

)

# - - - Profile objects - - - - - - - - - - - - - - - - - - -

def _copyProfileToForm(self, prof):

"""Copy relevant fields from Profile to ProfileForm."""

# copy relevant fields from Profile to ProfileForm

pf = ProfileForm()

for field in pf.all_fields():

if hasattr(prof, field.name):

# convert t-shirt string to Enum; just copy others

if field.name == 'teeShirtSize':

setattr(pf, field.name, getattr(TeeShirtSize, getattr(prof, field.name)))

elif (field.name == 'sessionKeysToAttend' or field.name == 'conferenceKeysToAttend'):

new_list = [item.get().key.urlsafe() for item in getattr(prof, field.name)]

setattr(pf, field.name, new_list)

else:

setattr(pf, field.name, getattr(prof, field.name))

pf.check_initialized()

return pf

def _getProfileFromUser(self):

"""Return user Profile from datastore, creating new one if non-existent."""

# make sure user is authed

user = endpoints.get_current_user()

if not user:

raise endpoints.UnauthorizedException('Authorization required')

# get Profile from datastore

user_id = getUserId(user)

p_key = ndb.Key(Profile, user_id)

profile = p_key.get()

# create new Profile if not there

if not profile:

profile = Profile(

key = p_key,

displayName = user.nickname(),

mainEmail= user.email(),

teeShirtSize = str(TeeShirtSize.NOT_SPECIFIED),

)

profile.put()

return profile # return Profile

def _doProfile(self, save_request=None):

logging.debug("value of my var i")

"""Get user Profile and return to user, possibly updating it first."""

# get user Profile

prof = self._getProfileFromUser()

# if saveProfile(), process user-modifyable fields

if save_request:

for field in ('displayName', 'teeShirtSize'):

if hasattr(save_request, field):

val = getattr(save_request, field)

if val:

setattr(prof, field, str(val))

#if field == 'teeShirtSize':

# setattr(prof, field, str(val).upper())

#else:

# setattr(prof, field, val)

prof.put()

# return ProfileForm

return self._copyProfileToForm(prof)

@endpoints.method(message_types.VoidMessage, ProfileForm,

path='profile', http_method='GET', name='getProfile')

def getProfile(self, request):

"""Return user profile."""

return self._doProfile()

@endpoints.method(ProfileMiniForm, ProfileForm,

path='profile', http_method='POST', name='saveProfile')

def saveProfile(self, request):

"""Update & return user profile."""

return self._doProfile(request)

# - - - Announcements - - - - - - - - - - - - - - - - - - - -

@staticmethod

def _cacheAnnouncement():

"""Create Announcement & assign to memcache; used by

memcache cron job & putAnnouncement().

"""

confs = Conference.query(ndb.AND(

Conference.seatsAvailable <= 5,

Conference.seatsAvailable > 0)

).fetch(projection=[Conference.name])

if confs:

# If there are almost sold out conferences,

# format announcement and set it in memcache

announcement = ANNOUNCEMENT_TPL % (

', '.join(conf.name for conf in confs))

memcache.set(MEMCACHE_ANNOUNCEMENTS_KEY, announcement)

else:

# If there are no sold out conferences,

# delete the memcache announcements entry

announcement = ""

memcache.delete(MEMCACHE_ANNOUNCEMENTS_KEY)

return announcement

@endpoints.method(message_types.VoidMessage, StringMessage,

path='conference/announcement/get',

http_method='GET', name='getAnnouncement')

def getAnnouncement(self, request):

"""Return Announcement from memcache."""

return StringMessage(data=memcache.get(MEMCACHE_ANNOUNCEMENTS_KEY) or "")

# - - - Registration - - - - - - - - - - - - - - - - - - - -

@ndb.transactional(xg=True)

def _conferenceRegistration(self, request, reg=True):

"""Register or unregister user for selected conference."""

retval = None

prof = self._getProfileFromUser() # get user Profile

# check if conf exists given websafeConfKey

# get conference; check that it exists

wsck = request.websafeConferenceKey

conf = ndb.Key(urlsafe=wsck).get()

if not conf:

raise endpoints.NotFoundException(

'No conference found with key: %s' % wsck)

# register

if reg:

# check if user already registered otherwise add

if wsck in prof.conferenceKeysToAttend:

raise ConflictException(

"You have already registered for this conference")

# check if seats avail

if conf.seatsAvailable <= 0:

raise ConflictException(

"There are no seats available.")

# register user, take away one seat

prof.conferenceKeysToAttend.append(wsck)

conf.seatsAvailable -= 1

retval = True

# unregister

else:

# check if user already registered

if wsck in prof.conferenceKeysToAttend:

# unregister user, add back one seat

prof.conferenceKeysToAttend.remove(wsck)

conf.seatsAvailable += 1

retval = True

else:

retval = False

# write things back to the datastore & return

prof.put()

conf.put()

return BooleanMessage(data=retval)

@endpoints.method(message_types.VoidMessage, ConferenceForms,

path='conferences/attending',

http_method='GET', name='getConferencesToAttend')

def getConferencesToAttend(self, request):

"""Get list of conferences that user has registered for."""

prof = self._getProfileFromUser() # get user Profile

conf_keys = [ndb.Key(urlsafe=wsck) for wsck in prof.conferenceKeysToAttend]

conferences = ndb.get_multi(conf_keys)

# get organizers

organisers = [ndb.Key(Profile, conf.organizerUserId) for conf in conferences]

profiles = ndb.get_multi(organisers)

# put display names in a dict for easier fetching

names = {}

for profile in profiles:

names[profile.key.id()] = profile.displayName

# return set of ConferenceForm objects per Conference

return ConferenceForms(items=[self._copyConferenceToForm(conf, names[conf.organizerUserId])\

for conf in conferences]

)

@endpoints.method(CONF_GET_REQUEST, BooleanMessage,

path='conference/{websafeConferenceKey}',

http_method='POST', name='registerForConference')

def registerForConference(self, request):

"""Register user for selected conference."""

return self._conferenceRegistration(request)

@endpoints.method(CONF_GET_REQUEST, BooleanMessage,

path='conference/{websafeConferenceKey}',

http_method='DELETE', name='unregisterFromConference')

def unregisterFromConference(self, request):

"""Unregister user for selected conference."""

return self._conferenceRegistration(request, reg=False)

@endpoints.method(message_types.VoidMessage, ConferenceForms,

path='filterPlayground',

http_method='GET', name='filterPlayground')

def filterPlayground(self, request):

"""Filter Playground"""

q = Conference.query()

# field = "city"

# operator = "="

# value = "London"

# f = ndb.query.FilterNode(field, operator, value)

# q = q.filter(f)

q = q.filter(Conference.city=="London")

q = q.filter(Conference.topics=="Medical Innovations")

q = q.filter(Conference.month==6)

return ConferenceForms(

items=[self._copyConferenceToForm(conf, "") for conf in q]

)

# - - - Session objects - - - - - - - - - - - - - - - - -

def _copySessionToForm(self, session):

"""Copy relevant fields from Conference to ConferenceForm."""

ss = SessionForm()

for field in ss.all_fields():

if hasattr(session, field.name):

# convert Date and Time to date string; just copy others

if field.name.endswith('date'):

setattr(ss, field.name, str(getattr(session, field.name)))

elif field.name.endswith('startTime'):

setattr(ss, field.name, str(getattr(session, field.name)))

else:

setattr(ss, field.name, getattr(session, field.name))

elif field.name == "sessionWebSafeKey":

setattr(ss, field.name, session.key.urlsafe())

ss.check_initialized()

return ss

def _createSessionObject(self, request):

"""Create or update Session object, returning SessionForm/request."""

user = endpoints.get_current_user()

if not user:

raise endpoints.UnauthorizedException('Authorization required')

user_id = getUserId(user)

# add session to existing conference

# check that conference exists

c_key = ndb.Key(urlsafe=request.websafeConferenceKey)

conf = c_key.get()

if not conf:

raise endpoints.NotFoundException(

'No conference found with key: %s' % request.websafeConferenceKey)

# check that user is owner

if user_id != conf.organizerUserId:

raise endpoints.ForbiddenException(

'Only the owner can add sessions to the conference.')

# copy SessionForm/ProtoRPC Message into dict

data = {field.name: getattr(request, field.name) for field in request.all_fields()}

del data['websafeConferenceKey']

del data['conferenceWebSafeKey']

del data['sessionWebSafeKey']

# add default values for those missing (both data model & outbound Message)

for df in DEFAULTS_SESSION:

if data[df] in (None, []):

data[df] = DEFAULTS_SESSION[df]

setattr(request, df, DEFAULTS_SESSION[df])

# convert dates from strings to Date objects;

if data['date']:

data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d").date()

# convert time from string to Datetime object

if data['startTime']:

data['startTime'] = datetime.strptime(data['startTime'][:10], "%H:%M").time()

# generate Session ID and Key based on parent's conference Key

s_id = Session.allocate_ids(size=1, parent=c_key)[0]

s_key = ndb.Key(Session, s_id, parent=c_key)

data['key'] = s_key

# create Session, add session key to speaker's

# & return (modified) SessionForm

# creation of Session

sess = Session(**data).put()

# Gather all sessions by this speaker

if len(data['speakerEmail']) > 0:

speakerEmail = str(data['speakerEmail'])

speakerSessions = Session.query(ancestor=ndb.Key(urlsafe=request.websafeConferenceKey))

speakerSessions = speakerSessions.filter(Session.speakerEmail == speakerEmail)

#If more than 1 session, then make featured speaker

if speakerSessions.count() > 1:

# Lookup Speaker name

speaker = ndb.Key(Speaker, data['speakerEmail']).get()

# Set the featured speaker and sessions in taskqueue

taskqueue.add(params={'speakerEmail': speakerEmail,

'speakerName': speaker.displayName},

url='/tasks/check_featured_speaker'

)

# add session key to speaker's entity

if data["speakerEmail"]:

speak = ndb.Key(Speaker, data["speakerEmail"]).get()

speak.sessionKeysToAttend.append(str(sess.urlsafe()))

speak.put()

return self._copySessionToForm(s_key.get())

# Create a new session entity endpoint

@endpoints.method(SESSION_POST_REQUEST, SessionForm,

path='conference/{websafeConferenceKey}/session',

http_method='POST', name='createSession')

def createSession(self, request):

"""Create a new session."""

return self._createSessionObject(request)

# Get sessions from a conference endpoint

@endpoints.method(CONF_GET_REQUEST, SessionForms,

path='conference/{websafeConferenceKey}/sessions',

http_method='GET', name='getConferenceSessions')

def getConferenceSessions(self, request):

"""Return requested conference sessions (by websafeConferenceKey)."""

s = Session.query(ancestor=ndb.Key(urlsafe=request.websafeConferenceKey))

# return set of ConferenceForm objects per Conference

return SessionForms(items=[self._copySessionToForm(sess)\

for sess in s]

)

# Get Speakers's sessions endpoint

@endpoints.method(SPEAKER_GET_REQUEST, SessionForms,

path='speaker/{speakerEmail}/sessions',

http_method='GET', name='getSessionsBySpeaker')

def getSessionsBySpeaker(self, request):

"""Return requested speaker sessions (by speakerEmail)."""

# Start a session entity query

sessions = Session.query()

# Filter session entity by speaker's ID

sessions = sessions.filter(Session.speakerEmail == request.speakerEmail)

# return set of SessionForms objects per Session

return SessionForms(items=[self._copySessionToForm(sess)\

for sess in sessions]

)

# Get Sessions by conference AND typeOfSession endpoint

@endpoints.method(SESSIONQUERY_POST_REQUEST, SessionForms,

path='speaker/{websafeConferenceKey}/sessions/queryType',

http_method='POST',

name='getConferenceSessionsByType')

def getConferenceSessionsByType(self, request):

"""Query for Session filtered by conference and type."""

# Start a session entity query

# Filter session entity by parent conference ID

s = Session.query(ancestor=ndb.Key(urlsafe=request.websafeConferenceKey))

# AND by type of session

s = s.filter(Session.typeOfSession == request.typeOfSession)

# return set of SessionForms objects per Session

return SessionForms(items=[self._copySessionToForm(sess)\

for sess in s]

)

# Get morning (8am to 1pm) sessions endpoint

@endpoints.method(message_types.VoidMessage, SessionForms,

path='/sessions/queryByTime',

http_method='GET',

name='getMorningSessions')

def getMorningSessions(self, request):

"""Query for morning (8am to 1pm) Sessions."""

# Start a session entity query

s = Session.query()

# Filter session entity by startTime (greater than 8am)

s = s.filter(Session.startTime >= datetime.strptime("08:00", "%H:%M").time())

# AND by startTime (smaller than 1pm)

s = s.filter(Session.startTime <= datetime.strptime("13:00", "%H:%M").time())

# return set of SessionForms objects per Session

return SessionForms(items=[self._copySessionToForm(sess)\

for sess in s]

)

# Get short (less than 30 minutes) workshop sessions endpoint

@endpoints.method(message_types.VoidMessage, SessionForms,

path='/sessions/queryByDurationAndType',

http_method='GET',

name='getShortWorkshopSessions')

def getShortWorkshopSessions(self, request):

"""Query for short and workshop Sessions."""

# Start a session entity query

s = Session.query()

# Filter session entity by duration

s = s.filter(Session.duration < 30)

# AND by type of session

s = s.filter(Session.typeOfSession == "Workshop")

# return set of SessionForms objects per Session

return SessionForms(items=[self._copySessionToForm(sess)\

for sess in s]

)

# Get sessions before 7 pm and non-workshop

@endpoints.method(message_types.VoidMessage, SessionForms,

path='/sessions/sfilterPlayground',

http_method='GET', name='filteredSession')

def filteredSession(self, request):

"""Sessions that starts before 7pm and are not a Workshop"""

# Get all sessions starting before 7pm

query = Session.query(Session.startTime <= datetime.strptime('19:00', "%H:%M").time())\

.fetch()

# collect the keys for all NOT of the undesired type

keys = [s.key for s in query if s.typeOfSession != 'Workshop']

# retreieve final list of sessions

sessions = ndb.get_multi(keys)

# return set of SessionForms objects per Session

return SessionForms(items=[self._copySessionToForm(session) \

for session in sessions])

@staticmethod

def _checkFeaturedSpeaker(speakerEmail, speakerName):

""" Add featured speaker to memcache"""

sessions = Session.query(Session.speakerEmail == speakerEmail) \

.fetch(projection=[Session.name])

if sessions:

featuredSpeaker = "Featured speaker: " + speakerName + \

" will talk in sessions " + ", ".join(sess.name for sess in sessions)

memcache.set(MEMCACHE_FEATURED_SPEAKER, featuredSpeaker)

else:

featuredSpeaker = ""

memcache.delete(MEMCACHE_FEATURED_SPEAKER)

return featuredSpeaker

# - - - Speaker objects - - - - - - - - - - - - - - - - -

def _copySpeakerToForm(self, speaker):

"""Copy relevant fields from Speaker to SpeakerForm."""

sp = SpeakerForm()

for field in sp.all_fields():

if hasattr(speaker, field.name):

setattr(sp, field.name, getattr(speaker, field.name))

sp.check_initialized()

return sp

def _createSpeakerObject(self, request):

user = endpoints.get_current_user()

if not user:

raise endpoints.UnauthorizedException('Authorization required')

# copy SpeakerForm/ProtoRPC Message into dict

data = {field.name: getattr(request, field.name) for field in request.all_fields()}

del data["sessionKeysToAttend"]

data["key"] = ndb.Key(Speaker, data["email"])

# create Speaker entity

# creation of Speaker & return new Speaker form

speaker = Speaker(**data).put()

return self._copySpeakerToForm(speaker.get())

# Create a new speaker's entity endpoint

@endpoints.method(SpeakerForm, SpeakerForm,

path='speaker',

http_method='POST', name='createSpeaker')

def createSpeaker(self, request):

"""Create a new speaker."""

return self._createSpeakerObject(request)

# Get a speaker by its Email endpoint

@endpoints.method(SPEAKER_GET_REQUEST, SpeakerForm,

path='speaker/{speakerEmail}',

http_method='GET', name='getSpeaker')

def getSpeaker(self, request):

"""Return requested speaker (by speakerEmail)."""

# get Speaker object from request; bail if not found

speaker = ndb.Key(Speaker, request.speakerEmail).get()

if not speaker:

raise endpoints.NotFoundException(

'No speaker found with key: %s' % request.speakerEmail)

# return SpeakerForm

return self._copySpeakerToForm(speaker)

# Return a featured speaker from memcache

@endpoints.method(message_types.VoidMessage, StringMessage,

path='featuredspeaker',

http_method='GET', name='getFeaturedSpeaker')

def getFeaturedSpeaker(self, request):

"""Return Featured Speaker from memcache."""

return StringMessage(data=memcache.get(MEMCACHE_FEATURED_SPEAKER) or "")

# - - - Wishlist objects - - - - - - - - - - - - - - - - -

# Add session to user's wishlist endpoint

@endpoints.method(WISH_GET_REQUEST, ProfileForm,

path='session/{websafeSessionKey}/wishlist',

http_method='POST', name='addSessionToWishlist')

def addSessionToWishlist(self, request):

"""Add session to user wishlist."""

user = endpoints.get_current_user()

if not user:

raise endpoints.UnauthorizedException('Authorization required')

# get user Profile

prof = self._getProfileFromUser()

# check if session exists

wssk = request.websafeSessionKey

session_key = ndb.Key(urlsafe=wssk)

session = session_key.get()

if not session:

raise endpoints.NotFoundException(

'No session found with key: %s' % wssk)

conferenceId = session_key.parent().get().key.urlsafe()

# check if user is registered in the session's conference

#if conferenceId not in prof.conferenceKeysToAttend:

# raise endpoints.ForbiddenException(

# "You are not registered for this conference.")

# if user have permission to add session

prof.sessionKeysToAttend.append(session_key)

# update and return user

prof.put()

return self._copyProfileToForm(prof)

# Get user's wishlist endpoint

@endpoints.method(message_types.VoidMessage, SessionForms,

path='profile/wishlist',

http_method='GET', name='getSessionsInWishlist')

def getSessionsInWishlist(self, request):

"""Get sessions in user wishlist."""

user = endpoints.get_current_user()

if not user:

raise endpoints.UnauthorizedException('Authorization required')

# get user's wishlist session ID

prof = self._getProfileFromUser() # get user Profile

sessions = ndb.get_multi(prof.sessionKeysToAttend)

# return set of SessionForms objects from user's wishlist

return SessionForms(items=[self._copySessionToForm(sess)\

for sess in sessions]