Beispiel #1
0
    def _getProfileFromUser(self):
        """Return user Profile from datastore, creating new one if non-existent."""
        ## TODO 2
        ## step 1: make sure user is authed
        ## uncomment the following lines:
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException('Authorization required')

        # get Profile from datastore
        print "***********"
        print user
        logging.info('**1**** %s',user)
        user_id = getUserId(user)
        print "**********"
        print user_id
        logging.info('**2**** %s',user_id)
        p_key = ndb.Key(Profile, user_id)
        print "*********"
        print p_key
        logging.info('***3**** %s',p_key)
        profile = p_key.get()
        print "*********"
        print profile
        logging.info('****4**** %s',profile)


        ## step 2: create a new Profile from logged in user data
        ## you can use user.nickname() to get displayName
        ## and user.email() to get mainEmail
        if not profile:
            profile = Profile(
                # userId = None,
                key = p_key,
                displayName = user.nickname, 
                mainEmail= user.email,
                teeShirtSize = str(TeeShirtSize.NOT_SPECIFIED),
            )
            profile.put()

        return profile      # return Profile
Beispiel #2
0
    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'))
Beispiel #3
0
    def _getAuthorFromUser(self):
        """Return user Author from datastore, creating new one if non-existent."""
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException('Authorization required')

        # get Author from datastore or create new Author if not there
        user_id = getUserId(user)
        a_key = ndb.Key(Author, user_id)
        author = a_key.get()
        # create new Author if not there
        if not author:
            author = Author(
                key=a_key,
                authorID=str(Author.allocate_ids(size=1)[0]),
                displayName=user.nickname(),
                mainEmail=user.email(),
            )
            author.put()

        return author
Beispiel #4
0
    def create_user(self, request):
        """ create a new user """
        if User.query(User.name == request.user_name).get():
            raise endpoints.ConflictException(
                'A User with that name already exists!')

        # returns a User, otherwise it returns None.
        g_user = endpoints.get_current_user()
        if not g_user:
            raise endpoints.UnauthorizedException('Authorization required')

        # get email from user
        user_id = getUserId(g_user)

        # create ndb key of kind User from user email
        u_key = ndb.Key(User, user_id)
        user = User(name=request.user_name, email=request.email, key=u_key)
        user.put()

        return StringMessage(
            message='User {} created!'.format(request.user_name))
    def _getInfoFromUser(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 User from datastore
        user_email = user.email()
        current_user = User.query(User.email == user_email).get()
        # create new User if not there
        if not current_user:
            current_user = User(
                name=user.nickname(),
                email=user.email(),
            )
            current_user.put()

        return current_user  # return User
    def addSessionToWishlist(self, request):
        """Add Session to Wishlist"""
        # preload necessary data items
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException('Authorization required')
        user_id = getUserId(user)

        # get Session object from request; bail if not found
        try:
            sess = ndb.Key(urlsafe=request.websafeSessionKey)
            kind = sess.kind()
            sess = sess.get()

            # check if the key is a Session Kind
            if not sess or kind != 'Session':
                raise endpoints.NotFoundException(
                    'No session found with key: %s' % request.websafeSessionKey)
        except Exception, e:
            raise endpoints.NotFoundException(
                'No session found with key: %s' % request.websafeSessionKey)
Beispiel #7
0
    def _getProfileFromUser(self):
        """Return user Profile from datastore, creating new one if non-existent."""
        ## Make sure user is authed
        ## uncomment the following lines:
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException('Authorization required')
        profile = None
        ## Create a new Profile from logged in user data
        ## you can use user.nickname() to get displayName
        ## and user.email() to get mainEmail
        if not profile:
            profile = Profile(
                userId=None,
                key=None,
                displayName=user.nickname(),
                mainEmail=user.email(),
                teeShirtSize=str(TeeShirtSize.NOT_SPECIFIED),
            )

        return profile  # return Profile
Beispiel #8
0
    def _updateSpeakerObject(self, request):
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException('Authorization required')

        # update existing conference
        speaker = ndb.Key(urlsafe=request.websafeSpeakerKey).get()
        # check that conference exists
        if not speaker:
            raise endpoints.NotFoundException('No speaker found with key: %s' %
                                              request.websafeSpeakerKey)

        # Not getting all the fields, so don't create a new object; just
        # copy relevant fields from SpeakerForm to Speaker object
        for field in request.all_fields():
            data = getattr(request, field.name)
            # only copy fields where we get data
            if data is not None:
                setattr(speaker, field.name, data)
        speaker.put()
        return self._copySpeakerToForm(speaker)
Beispiel #9
0
    def _getProfileFromUser(self):
        """Return user Profile from datastore, creating new one if non-existent."""
        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
Beispiel #10
0
    def cancel_game(self, request):
        """Cancel and delete the current game state."""
        game = get_by_urlsafe(request.urlsafe_game_key, Game)

        if game:  # game exits
            # check if user is a player in this game
            if request.user_name not in (game.player1.get().name,
                                         game.player2.get().name):
                raise endpoints.UnauthorizedException(
                    'You are not a player of this game')

            if game.game_over:
                user = game.whose_turn.get()
                message = """This game has ended. It was won by {user_name} and
                    cannot be cancelled""".format(user_name=user.name)
                return StringMessage(message=message)
            else:
                game.key.delete()
                return StringMessage(message='Game cancelled and deleted.')
        else:
            raise endpoints.NotFoundException('No game exists with that key!')
    def deleteSessionInWishList(self, request):
        """Remove requested wishlist by user."""
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException('Authorization required')
        user_id = getUserId(user)

        wishlists = WishList.query(ancestor=ndb.Key(Profile, user_id))
        ws = wishlists.filter(WishList.session_key == request.session_key)

        wrpt = WishListReport()

        if ws.count():
            for w in ws:
                w.key.delete()
            setattr(wrpt, 'rpt', 'OK')
        else:
            setattr(wrpt, 'rpt', 'Not Found')

        wrpt.check_initialized()
        return wrpt
def grant_user_access_from_code(redirect_url, **kwargs):
    """ Untested code. """

    code = kwargs['code']

    login = FacebookLogin(FACEBOOK_APP_ID, FACEBOOK_APP_SECRET, redirect_url)

    try:
        login.retrieve_access_token(code)
    except:
        raise endpoints.UnauthorizedException(
            "Unorthorised access to Facebook.")

    profile = login.get_profile()

    account = models.FacebookAccount.get_by_facebook_id(profile['id'])

    if account is None:
        account = _create_new_user(profile, login.access_token)

    return account
Beispiel #13
0
    def attachments_get(self, request):
        """Retrieve metainfo for a single attachments for a timeline card"""

        current_user = endpoints.get_current_user()
        if current_user is None:
            raise endpoints.UnauthorizedException("Authentication required.")

        card = ndb.Key("TimelineItem", request.itemId).get()

        if card is None or card.user != current_user:
            raise endpoints.NotFoundException("Attachment not found.")

        if card.attachments is not None:
            for att in card.attachments:
                if att.id == request.attachmentId:
                    return AttachmentResponse(id=att.id,
                                              contentType=att.contentType,
                                              contentUrl=att.contentUrl,
                                              isProcessingContent=att.isProcessingContent)

        raise endpoints.NotFoundException("Attachment not found.")
Beispiel #14
0
    def invite_to_group(self, message):
        user = endpoints.get_current_user()
        if user is None:
            raise endpoints.UnauthorizedException()
        entity = ndb.Key(Group, message.group_name).get()
        #print '$', entity.invite
        for obj, r in zip(*split_message(message.child_object, message.role)):
            #print 'sddd'
            #print 'sddd2', entity.invite, entity.ban, entity.joined
            if obj not in entity.invite or obj not in entity.ban or obj not in entity.joined:

                if obj in entity.ask_join:
                    self.put_object_to_group(
                        PutObjectTo(child_object=message.child_object,
                                    group_name=message.group_name,
                                    role=r))
                else:
                    entity.invite[obj] = r
        #print '$', entity.invite
        entity.put()
        return Answer()
Beispiel #15
0
    def _updateSessionWishlist(self, request, add=True):
        """Add or remove session from user wishlist"""
        # make sure user is authed
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException('Authorization required')

        retval = None  # value to return indicating success
        prof = self._getProfileFromUser()  # get user Profile

        # check if session exists given key
        wssk = request.websafeSessionKey
        sess = ndb.Key(urlsafe=wssk).get()
        if not sess:
            raise endpoints.NotFoundException(
                'No sesssion found with key: %s ' % wssk)

        # check if this is to add or remove
        if add:
            # check if user already added session
            if wssk in prof.sessionKeysInWishlist:
                raise ConflictException(
                    "You have already added this session to your wishlist.")
            # add session to user profile
            prof.sessionKeysInWishlist.append(wssk)
            retval = True  # session found and added
            prof.put()
        # remove session from user wishlist
        else:
            # check if session is in wishlist
            if wssk in prof.sessionKeysInWishlist:
                # remove the session from user wishlist
                prof.sessionKeysInWishlist.remove(wssk)
                retval = True  # session found and removed
                prof.put()
            else:
                retval = False  # session not in wishlist; not removed
                # no change. do not put.

        return BooleanMessage(data=retval)
Beispiel #16
0
    def getSessionsInWishlist(self, request):
        """Get list of Sessions that user wish to attend

            1)return a wishlist of sessions for a specific conference if
                with key = {websafeConferenceKey}
            2) return a wishlist of all sessions over all conferences use
                added to a whishlist if {websafeConferenceKey} is None
        """

        # get user Profile
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException('Authorization required')
        prof = self._getProfileFromUser()

        # show all sessions for all conferences to attend
        session_wishlist_keys = [
            ndb.Key(urlsafe=session_key)
            for session_key in prof.sessionKeysInWishlist
        ]
        sessions_wishlist = ndb.get_multi(session_wishlist_keys)

        # if user wants to see selected session for a specific conference
        # use {websafeConferenceKey} to select them
        if request.websafeConferenceKey is not None:
            output = []
            conference_key = ndb.Key(urlsafe=request.websafeConferenceKey)
            for item in session_wishlist_keys:
                if item.parent() == conference_key:
                    print("item.parent: ", item.parent())
                    output.append(item)
            sessions_wishlist = ndb.get_multi(output)
            return SessionForms(items=[
                self._copySessionToForm(sess) for sess in sessions_wishlist
            ])

        # return set of SessionForm objects
        return SessionForms(items=[
            self._copySessionToForm(sess) for sess in sessions_wishlist
        ])
Beispiel #17
0
    def getCurrentGame(self, request):
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException('Authorization required')
            return newGameMSGout(msg='Not Logged In!',
                                 uv='',
                                 game_id=0,
                                 hint_one='',
                                 hint_two='',
                                 hint_three='')

        email = user.email()
        user2 = Users.query(Users.email == email).get()
        user_id = user2.key.id()
        if not user2:
            return newGameMSGout(msg='Account Does Not Exist!',
                                 uv='',
                                 game_id=0,
                                 hint_one='',
                                 hint_two='',
                                 hint_three='')

        checkGame = Games \
        .query(ndb.AND(Games.user_id == user_id, Games.active == True)).get()
        if checkGame:
            game_id = checkGame.key.id()
            return newGameMSGout(msg='Current Game.',
                                 uv=checkGame.uv,
                                 game_id=game_id,
                                 hint_one=checkGame.hint_one,
                                 hint_two=checkGame.hint_two,
                                 hint_three=checkGame.hint_three)

        else:
            return newGameMSGout(msg='No Current Game.',
                                 uv='',
                                 game_id=0,
                                 hint_one='',
                                 hint_two='',
                                 hint_three='')
    def getWishlistBySpeaker(self, request):
        """Get wishlist by speaker."""

        # check auth
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException('Authorization required')
        # get userId
        user_id = getUserId(user)
        # query session, filter by speaker
        q = Session.query().filter(Session.speaker == request.speaker)
        # query wishlist, filter by userId
        p = Wishlist.query().filter(Wishlist.userId == user_id)

        a = []
        for s in q:
            for w in p:
                if s.key == w.sessionKey:
                    a.append(w)

        return WishlistForms(
            items=[self._copyWishlistToForm(wish) for wish in a])
Beispiel #19
0
    def get_created(self, request):
        """
        Return Conferences created by the requesting User
        :param request: Void RPC Message
        :return: ConferenceForms containing user-created ConferenceForm's
        """
        if not isinstance(request, message_types.VoidMessage):
            raise endpoints.BadRequestException()

        # make sure user is auth'd
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException('Authorization required')
        user_id = get_user_id(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=[conf.to_form(getattr(prof, 'displayName')) for conf in confs]
        )
    def getSessionsAfter7NoWorkshop(self, request):
        """Return sessions after 7 pm that are not workshops"""
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException('Authorization is requied')

        sevenPM = '19:00:00'
        timeToFilter = datetime.strptime(sevenPM, '%H:%M:%S').time()

        sessions = Session.query(Session.startTime < timeToFilter)

        #create a list to store properties to complete 2nd part of inequality filter
        filterSessions = []

        #loop over items that are not workshops
        for session in sessions:
            if session.typeOfSession != "WORKSHOP":
                filterSessions.append(session)

        return SessionForms(items=[
            self._copySessionToForm(session) for session in filterSessions
        ])
Beispiel #21
0
    def getSessionsInWishlist(self, request):
        """Get a list of sessions that a user has registered for."""
        user = endpoints.get_current_user()

        #check if logged in
        if not user:
            raise endpoints.UnauthorizedException('Authorization required')

        #get profile from user
        prof = self._getProfileFromUser()

        #grab session keys that a user has registered for
        sess_keys = [
            ndb.Key(urlsafe=wsck) for wsck in prof.sessionsKeysToAttend
        ]

        #turn keys into instances
        sessions = ndb.get_multi(sess_keys)

        #return all sessions on the user's wishlist
        return SessionForms(
            items=[self._copySessionToForm(s) for s in sessions])
Beispiel #22
0
    def compute_nero(self, message):
        user = endpoints.get_current_user()
        if user is None:
            raise endpoints.UnauthorizedException()

    #role=ObjectToGroup.query(ObjectToGroup.key_value==user.email(), ObjectToGroup.group_name==message.group_name).get().role
# itr??
        entity = ndb.Key(ObjectToGroup, message.valued_object, ObjectToGroup,
                         message.group_name).get()
        #print entity
        itr = getattr(entity, message.st_name + '__I')
        evs = NeroStat.query(
            ancestor=ndb.Key(NeroStat, str(itr), NeroStat, message.st_name +
                             '__A', NeroStat, entity.key.urlsafe())).fetch()
        #print " 1", evs
        #T = message.val
        w = []
        A = []
        mult = []
        Q = {}
        ref_profile = []
        for ref in evs:
            #print ref.key, ref.key.id(),w
            ref_profile.append(
                ndb.Key(ObjectToGroup, ref.key.id(), ObjectToGroup,
                        message.group_name).get())
            A.append(ref.val)
            w.append(getattr(ref_profile[-1], message.st_name + '__W'))
            #print getattr(ref_profile[-1], message.st_name+'__W')
        #print '----', A, w, message.teacher_val
        data = compute_nero(A, w, message.teacher_val)
        for i, users in enumerate(ref_profile):
            setattr(users, message.st_name + '__W', data[2][i])
            #print '==', users, data[2]
            users.put()
        setattr(entity, message.st_name,
                '(T:' + str(message.teacher_val) + ' m:' + str(data[1]) + ')')
        entity.put()
        return Answer()
Beispiel #23
0
    def FindSessionByDatewithStartTimeRange(self, request):
        """Find Sessions By Date with Start Time Range"""
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException('Authorization required')
        # user_id = getUserId(user)

        sessions = Session.query()

        theStartTime = datetime.strptime(
                       request.startTimeRangeBeginning, "%H:%M").time()
        theEndTime = datetime.strptime(
                     request.startTimeRangeEnding, "%H:%M").time()
        theDate = datetime.strptime(request.conferenceDate, "%Y-%m-%d").date()

        sessions = sessions.filter(Session.startTime >= theStartTime)
        sessions = sessions.filter(Session.startTime <= theEndTime)
        sessions = sessions.filter(Session.date == theDate)

        return SessionForms(
            items=[self._copySessionToForm(session) for session in sessions]
        )
Beispiel #24
0
    def requestResponse(self, request):
        user = self.get_user_from_token(request.token)
        if not user:
            raise endpoints.UnauthorizedException('UNAUTHORIZED')

        key = ndb.Key(Account, int(request.uid))
        friend = key.get()

        if friend is None:
            raise endpoints.NotFoundException('FRIEND_NOT_FOUND')

        user.requestedFriends.remove(key)
        friend.requestingFriends.remove(user.key)

        if request.action == 'accept':
            user.friends.append(key)
            friend.friends.append(user.key)

        user.put()
        friend.put()

        return message_types.VoidMessage()
Beispiel #25
0
    def getSessionsInWishlist(self, request):
        """Get the sessions that are in the users wishlist, for the given conference key."""
        wsck = request.websafeConferenceKey
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException('Authorization required')

        # Get the profile
        user_id = getUserId(user)
        profile = ndb.Key(Profile, user_id).get()
        sessions = [
            ndb.Key(urlsafe=wssk).get() for wssk in profile.sessionWishlist
        ]

        # If the session's parent key doesn't match the conference key
        # remove it from the list of sessions to display.
        for session in sessions:
            if session.key.parent().urlsafe() != wsck:
                sessions.remove(session)

        return SessionForms(
            sessions=[self._copySessionToForm(sesh) for sesh in sessions])
Beispiel #26
0
    def attachments_list(self, request):
        """Retrieve attachments for a timeline card"""

        current_user = endpoints.get_current_user()
        if current_user is None:
            raise endpoints.UnauthorizedException("Authentication required.")

        card = ndb.Key("TimelineItem", request.itemId).get()

        if card is None or card.user != current_user:
            raise endpoints.NotFoundException("Card not found.")

        attachments = []

        if card.attachments is not None:
            for att in card.attachments:
                attachments.append(AttachmentResponse(id=att.id,
                                                      contentType=att.contentType,
                                                      contentUrl=att.contentUrl,
                                                      isProcessingContent=att.isProcessingContent))

        return AttachmentList(items=attachments)
Beispiel #27
0
    def insert_folder(cls, user, folder_name, kind):
        try:
            credentials = user.google_credentials
            http = credentials.authorize(httplib2.Http(memcache))
            service = build('drive', 'v2', http=http)
            organization = user.organization.get()

            # prepare params to insert
            folder_params = {
                'title': folder_name,
                'mimeType': 'application/vnd.google-apps.folder'
            }  # get the accounts_folder or contacts_folder or ..
            parent_folder = eval('organization.' + FOLDERS[kind])
            if parent_folder:
                folder_params['parents'] = [{'id': parent_folder}]

            # execute files.insert and get resource_id
            created_folder = service.files().insert(body=folder_params,
                                                    fields='id').execute()
        except:
            raise endpoints.UnauthorizedException(cls.INVALID_GRANT)
        return created_folder
    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")

        # create the profile key
        p_key = ndb.Key(Profile, getUserId(user, id_type="oauth"))

        # create ancestor query for this user
        conferences = Conference.query(ancestor=p_key)

        # get the user profile and display name
        prof = p_key.get()
        displayName = getattr(prof, "displayName")

        # return set of ConferenceForm objects per Conference
        return ConferenceForms(items=[
            self._copyConferenceToForm(conf, displayName)
            for conf in conferences
        ])
Beispiel #29
0
    def update_user(self, request):
        if endpoints.get_current_user() is None:
            raise endpoints.UnauthorizedException('Authorization required')
        user_key_id = request.id
        user_key = ndb.Key(urlsafe=str(user_key_id))
        userDb = user_key.get()
        user = None
        if userDb is not None:
            userDb.user_id = str(request.user_id)
            userDb.strava_id = str(request.strava_id)
            userDb.strava_token = str(request.strava_token)
            userDb.put()
            user = User(user_id=userDb.user_id,
                        email=userDb.email,
                        key=str(userDb.key.id()),
                        strava_id=userDb.strava_id,
                        strava_token=userDb.strava_token)
        else:
            message = 'No user with key "%s" exists.' % str(user_key_id)
            raise endpoints.NotFoundException(message)

        return user
Beispiel #30
0
    def _createSessionObject(self, request):
        """Create or update Session object, returning SessionForm/request."""
        user_id = check_auth()
        organizer = Conference.query(
            Conference.organizerUserId == request.organizer_id)
        if not organizer:
            raise endpoints.UnauthorizedException(
                'Must be conference organizer to create session')

        if not request.title:
            raise endpoints.BadRequestException(
                "Session 'title' field required")

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

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

        p_key = ndb.Key(Profile, user_id)
        s_id = Session.allocate_ids(size=1, parent=p_key)[0]
        s_key = ndb.Key(Session, s_id, parent=p_key)
        data['key'] = s_key
        data['organizer_id'] = request.organizer_id = user_id
        data['speaker_id'] = ndb.Key(Speaker, request.speaker_id)
        data['speaker_name'] = ndb.Key(Speaker, request.speaker_id).get().name

        Session(**data).put()
        key = 'speaker_id'
        if self._checkFeaturedSpeaker(request.conference_key, data[key]):
            taskqueue.add(params={
                'speaker_id': request.speaker_id,
                'conf': request.conference_key
            },
                          url='/tasks/set_featured_speaker')
        return request