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): """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 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)