def post(self):
"""Set FeaturedSpeaker in Memcache."""
# add session to speaker
ConferenceApi._setFeaturedSpeaker(self.request)
# cache featured speaker
ConferenceApi._cacheFeaturedSpeaker()
self.response.set_status(204)
def get(self):
"""Get featured speaker"""
ConferenceApi._cacheFeaturedSpeaker(
# self.request.get('websafeSessionKey')
self.request.get('sessionKey')
)
self.response.set_status(204)
def post(self):
"""Check if speakers in session are featured."""
print "searching Featuring Speaker"
ConferenceApi._cacheFeaturedSpeaker(
self.request.get('websafeConferenceKey'),
self.request.get('sessionId'))
self.response.set_status(204)
def post(self):
"""Set Featured Speaker Announcement in Memcache."""
ConferenceApi._handleFeaturedSpeaker(
self.request.get('websafeConferenceKey'),
self.request.get('websafeSessionKey')
)
self.response.set_status(204)
def post(self):
"""Check Speaker being added in Session & add as featured in memcache if qualifies"""
speakerName = self.request.get('speakerName')
dictSpeaker = SpeakerDict.query(SpeakerDict.identifier == SPEAKER_IDENTIFIER).get()
# no dictionary exists, create one and initialize
if dictSpeaker is None:
dictSpeaker = SpeakerDict()
dictSpeaker.identifier = SPEAKER_IDENTIFIER
dictSpeaker.put()
logging.error('BEFORE dictSpeaker is= %s' % dictSpeaker)
# no dict. entry exists for speaker, initialize to 1
if dictSpeaker.speaker_num.get(speakerName) == None:
dictSpeaker.speaker_num[speakerName] = 1
# increment existing speaker entry by 1 and update memcache w/ new speaker
else:
dictSpeaker.speaker_num[speakerName] += 1
api = ConferenceApi()
api.cacheFeaturedSpeaker(speakerName)
logging.error('After dictSpeaker is= %s' % dictSpeaker)
dictSpeaker.put()
def post(self):
"""Check if a speaker has more than one sessions in the conference.
If so, set the speaker as featured.
"""
ConferenceApi._should_feature_speaker(
self.request.get('websafeSpeakerKey'),
self.request.get('websafeConferenceKey'))
def get(self):
"""Set Featured Speaker in Memcache."""
ConferenceApi._cacheFeaturedSpeaker(
self.request.get('websafeConferenceKey'),
self.request.get('speaker')
)
self.response.set_status(204)
def post(self):
"""Check if speakers in session are featured."""
print "searching Featuring Speaker"
ConferenceApi._cacheFeaturedSpeaker(
self.request.get('websafeConferenceKey'),
self.request.get('sessionId'))
self.response.set_status(204)
def post(self):
"""Set the featured speaker(s) for a conference."""
conf_api = ConferenceApi()
conf_api._cacheConferenceFeaturedSpeaker(
self.request.get('websafeConferenceKey')
)
self.response.set_status(204)
def post(self):
"""Set Featured Speaker in Memcache."""
#TASK4
#set the featured speaker from the task parameter
fspkr = self.request.get('featured_spkr')
ConferenceApi._setCacheFeaturedSpkr(fspkr)
self.response.set_status(204)
def get(self):
"""
Set announcement values in Memcache.
:return:
"""
ConferenceApi.cache_announcement()
self.response.set_status(204)
def post(self):
"""Set Announcement in Memcache."""
# TODO 1
# use _cacheAnnouncement() to set announcement in Memcache
confwebsafekey = self.request.get('confwebsafeKey')
speaker = self.request.get('speaker')
ConferenceApi._cacheFeaturedSpeakersAnnouncement(confwebsafekey, speaker)
def post(self):
"""Set Featured Speaker in Memcache."""
# call the _cacheFeaturedSpeaker method passing in
# required arguments from the request
ConferenceApi._cacheFeaturedSpeaker(
self.request.get('websafeConferenceKey'),
self.request.get('sessionSpeaker'))
def post(self):
"""Set Featured Speaker in Memcache."""
ConferenceApi._cacheFeaturedSpeaker(
self.request.get('websafeConferenceKey'),
self.request.get('speaker')
)
self.response.set_status(204)
def post(self):
"""add a new Memcache entry that features
the speaker and session names.
You can choose the Memcache key.
"""
ConferenceApi._cacheFeaturedSpeakers(self.request.get('websafeSessionKey'))
self.response.set_status(204)
def post(self):
"""Set Featured Speaker in Memcache."""
# call the _cacheFeaturedSpeaker method passing in
# required arguments from the request
ConferenceApi._cacheFeaturedSpeaker(
self.request.get('websafeConferenceKey'),
self.request.get('sessionSpeaker'))
def post(self):
"""Set Speaker Announcement in Memcache.
Switch from get to post when copying the announcment handler"""
speaker = self.request.get('speaker')
conf_key = self.request.get('conf_key')
ConferenceApi._cacheFeaturedSpeaker(speaker, conf_key)
self.response.set_status(204)
def get(self):
"""determine if provided speaker should be feature speaker"""
speaker = self.request.get('speaker')
wsck = self.request.get('wsck')
ConferenceApi._setFeaturedSpeaker(speaker, wsck)
def get(self):
"""Set Featured Speaker in Memcache"""
ConferenceApi._cacheFeaturedSpeaker(
self.request.get('speaker'),
self.request.get('conference_key')
)
self.response.set_status(204)
def post(self):
""" Sets the Featured Speaker. Featured Speaker is defined as
the Speaker that is speaking at the most Sessions in a given
Conference. The Featured Speaker is stored in MemCache for fast
retrieval """
ConferenceApi._setFeaturedSpeaker(self, self.request)
self.response.set_status(204)
def post(self):
""" Set Featured Speaker in Memcache. """
speaker = self.request.get('speaker')
wsck = self.request.get('wsck')
ConferenceApi._cacheFeaturedSpeaker(speaker, wsck)
self.response.set_status(204)
def post(self):
"""Set featured speaker sessions message in memcache."""
# use _cacheFeaturedSpeaker to set announcement in Memcache, passing
# the request objects 'speaker' and 'wsck' (websafeConferenceKey) as args.
ConferenceApi._cacheFeaturedSpeaker(
self.request.get('speaker'), self.request.get('wsck'))
self.response.set_status(204)
def post(self):
"""Set Speaker Announcement in Memcache."""
# TODO 1
# use _cacheAnnouncement() to set announcement in Memcache
ConferenceApi._speakerAnnouncement(
self.request.get('websafeconferenceKey'),
self.request.get('websafespeaker'))
def post(self):
"""Check if speaker has multiple sessions, adding them as featured speaker if so."""
# grab the key of the conference to check
websafeKey = self.request.get("websafeKey")
# grab the speaker to check if featured
speaker = self.request.get("speaker")
ConferenceApi._speakerCheck(websafeKey, speaker)
def post(self):
"""Set Announcement in Memcache."""
session_speaker = self.request.get('session_speaker')
session_name = self.request.get('session_name')
conf_key = self.request.get('conf_key')
ConferenceApi._setFeaturedSpeaker(
session_speaker, session_name, conf_key)
self.response.set_status(204)
def get(self):
"""Set Featured Speaker in Memcache."""
websafeConferenceKey = self.request.get('websafeConferenceKey')
speaker = self.request.get('speaker')
#print "So the Speaker is %s and the key is %s" %(speaker,websafeConferenceKey)
ConferenceApi._cacheFeaturedSpeaker(websafeConferenceKey, speaker)
def post(self):
# WHY DOES THIS NEED TO BE 'POST' AND NOT 'GET'
# AREN'T WE JUST 'CALLING' A URL HERE
"""Set Featured Speaker."""
wsck = self.request.get('confKey')
speaker = self.request.get('speaker')
ConferenceApi._cacheFeaturedSpeaker(wsck, speaker)
self.response.set_status(204)
def post(self):
"""Safe feature speaker"""
# the request properties are defined in _checkFeaturedSpeaker
conference_key = self.request.get('conf_urlsafekey')
sp_name = self.request.get('speaker_name')
sp_prof = self.request.get('speaker_prof')
ConferenceApi._checkFeaturedSpeaker(conference_key, sp_name, sp_prof)
self.response.set_status(204)
def get(self):
"""Set Announcement in Memcache."""
header = self.request.headers.get('X-AppEngine-Cron', None)
#if not header:
# raise ValueError('attempt to access cron handler directly, '
# 'missing custom App Engine header')
ConferenceApi._cacheAnnouncement()
self.response.set_status(204)
def get(self):
"""Set Featured Speaker in Memcache."""
websafeConferenceKey= self.request.get('websafeConferenceKey')
speaker = self.request.get('speaker')
#print "So the Speaker is %s and the key is %s" %(speaker,websafeConferenceKey)
ConferenceApi._cacheFeaturedSpeaker(websafeConferenceKey,speaker)
def post(self):
if ConferenceApi._isNewFeaturedSpeaker(
self.request.get('speaker_email'),
self.request.get('conference_id')):
# set memcache announcement
ConferenceApi._featuredSpeakerAnnouncement(
self.request.get('speaker_email')
)
def post(self):
"""add a new Memcache entry that features
the speaker and session names.
You can choose the Memcache key.
"""
ConferenceApi._cacheFeaturedSpeakers(
self.request.get('websafeSessionKey'))
self.response.set_status(204)
def post(self):
"""Set the featured speaker in the memcache"""
conf_key = self.request.get('conf_key')
speaker_name = self.request.get('speaker_name')
ConferenceApi._setFeaturedSpeaker(
conference_key=conf_key,
speaker_name=speaker_name
)
def post(self):
"""Order top sessions by conference"""
wsck = self.request.get('websafeConferenceKey')
if wsck:
ConferenceApi._rankSessions(wsck)
else:
ConferenceApi._rankSessions()
def post(self):
"""Build List of Featured Speaker by Conference"""
wsck = self.request.get('websafeConferenceKey')
if wsck:
ConferenceApi._featuredSpeakers(wsck)
else:
ConferenceApi._featuredSpeakers()
def post(self):
"""Set Featured Speaker"""
ConferenceApi._setFeaturedSpeaker(self.request.get("speaker_name"),
self.request.get_all("sess_keys"),
self.request.get(
"current_sess_name"),
self.request.get("conf"),
self.request.get("conf_loc"))
def get(self):
"""Set Announcement in Memcache."""
header = self.request.headers.get('X-AppEngine-Cron', None)
if not header:
raise ValueError('attempt to access cron handler directly, '
'missing custom App Engine header')
ConferenceApi._cacheAnnouncement()
self.response.set_status(204)
def post(self):
"""Check if a speaker has more than one sessions in the conference.
If so, set the speaker as featured.
"""
ConferenceApi._should_feature_speaker(
self.request.get('websafeSpeakerKey'),
self.request.get('websafeConferenceKey')
)
def post(self):
"""Set Featured Speaker in Memcache."""
print "In featured handler"
# get session info
sessionKey = self.request.get('sessionKey')
# perform queries and featured speaker logic
ConferenceApi._cacheSpeaker(sessionKey)
self.response.set_status(204)
def post(self):
"""Check and Set Featured Speaker """
C_API = ConferenceApi()
featured_speaker = self.request.get('speaker')
logging.debug(featured_speaker)
print featured_speaker
websafeConferenceKey = self.request.get('websafeConferenceKey')
C_API._setFeaturedSpeaker(featured_speaker, websafeConferenceKey)
def post(self):
"""Update the featured speaker."""
# Wait for eventual consistency to catch up, since new session was
# just added. Since this is running on a task queue thread the wait
# doesn't affect application responsiveness whatsoever.
sleep(3)
# Call the routine that performs the logic for updating the featured
# speaker.
ConferenceApi._updateFeaturedSpeaker(
self.request.get('websafeSpeakerKey'),
self.request.get('websafeConferenceKey'))
def post(self):
wsck = self.request.get('websafeConferenceKey')
speaker = self.request.get('speaker')
# Set new featured speaker in memcache if necessary
sessions = ConferenceApi._cacheFeaturedSpeaker(wsck, speaker)
if sessions.count() >= 2:
memcache.set(key="featuredSpeaker_" + wsck, value=speaker)
def post(self):
"""Set announcement in Memcache for featured speaker and sessions"""
# Assume that speaker names are unique
# otherwise would have to introduce a speaker key
featuredSpeaker = ""
wsck = self.request.get('websafeConferenceKey')
speakerName = self.request.get('speaker')
# Count how many times a speaker is assigned to sessions in a particular conference
speakerCount = Session.query(ancestor=ndb.Key(urlsafe=wsck)).filter(
Session.speaker == speakerName).count()
# Speaker is featured if there is more than one session by speaker in conference
if speakerCount > 1:
featuredSpeaker = speakerName
# Retrieve sessions the speaker is speaking
featuredSpeakerSessions = Session.query(ancestor=ndb.Key(
urlsafe=wsck)).filter(Session.speaker == featuredSpeaker)
# Set announcement for featured speaker and sessions in memcache
ConferenceApi._cacheSpeakerAnnouncement(featuredSpeaker,
featuredSpeakerSessions)
self.response.set_status(204)
def post(self):
"""Set Featured Speaker in Memcache."""
wssk = self.request.get('session')
ConferenceApi._cacheFeaturedSpeaker(wssk)
def get(self):
"""Stores Speaker in Memcache."""
ConferenceApi._storeFeaturedSpeakerInMemCache(self.request.get('speaker'))
self.response.set_status(204)
def post(self):
"""Set Featured Speaker in Memcache."""
websafeConferenceKey = self.request.get('websafeConferenceKey')
speaker = self.request.get('speaker')
ConferenceApi.setFeaturedSpeaker(websafeConferenceKey, speaker)
def post(self):
"""Set Featured Speaker in Memcahce."""
ConferenceApi._cacheSpeaker(self.request.get('speaker'))
self.response.set_status(204)
def post(self):
"""Check to see if the speaker is now the featured speaker and update memcache if so."""
ConferenceApi._cacheFeaturedSpeaker(
self.request.get('websafeConferenceKey'),
self.request.get('speaker'))
def get(self):
"""Set Announcement in Memcache."""
ConferenceApi._cacheAnnouncement()
self.response.set_status(204)
def post(self):
"""Set Featured Speaker in Memcache"""
speaker = self.request.get('speaker')
conference_key = self.request.get('conference_key')
ConferenceApi._cacheFeaturedSpeaker(speaker, conference_key)
self.response.set_status(204)
def get(self):
"""Set Announcement in Memcache."""
# TODO 1
# use _cacheAnnouncement() to set announcement in Memcache
ConferenceApi._cacheAnnouncement()
def get(self):
"""Set Announcement in Memcache."""
ConferenceApi._cacheAnnouncement()
def post(self):
"""Set featured speaker in memcache."""
ConferenceApi._setSpeakerInMemcache(self.request.get('memcacheKey'),
self.request.get('message'))
def post(self):
"""Set Featured Speaker in Memcache."""
ConferenceApi._cacheFeaturedSpeaker(self.request.get("speaker_email"),
self.request.get("wsck"))
def post(self):
"""Set featured speaker in memcache, if speaker is a featured speaker"""
this_speaker = self.request.get('speaker')
this_conf_wsk = self.request.get('conference')
ConferenceApi._createFeaturedSpeakerAd(this_speaker, this_conf_wsk)
def post(self):
"""Set Featured Speaker in Memcache"""
ConferenceApi._cacheFeaturedSpeaker(
self.request.get('websafeConferenceKey'),
self.request.get('websafeSpeakerKey'))
def post(self):
print self.request.get('websafeKey')
ConferenceApi._cacheSpeaker(self.request.get('websafeKey'),
self.request.get('speaker'))
self.response.set_status(204)
def post(self):
speaker = self.request.get('speaker')
url_key = self.request.get('conf_key')
ConferenceApi._addFeaturedSpeaker(url_key, speaker)
self.response.set_status(204)
def post(self):
"""Assign a speaker that speaks in more than one session to memcache"""
ConferenceApi._cacheFeaturedSpeaker(self)
self.response.set_status(204)
def post(self):
"""Check and update featured speaker for a given conference."""
# Get request parameters.
speaker = self.request.get('speaker')
websafeConferenceKey = self.request.get('websafeConferenceKey')
ConferenceApi._checkFeaturedSpeaker(speaker, websafeConferenceKey)
