def test_createSession(self):
     test_url = '/conference/{wcksafe}/session'
     # Ensure default profile is created
     url = '/profile'
     res = urlfetch.fetch(self.urlbase + url, method='GET')
     self.assertEqual(res.status_code, 200)
     # Create conference and get websafe key
     conf = Conference(
         name='Test Conference',
         organizerUserId=json.loads(res.content)['mainEmail']
     )
     wck = conf.put()
     sleep(0.1)
     wcksafe = wck.urlsafe()
     test_url = test_url.format(wcksafe=wcksafe)
     # Ensure no sessions exist yet
     self.assertEqual(0, len(Session.query().fetch(5)))
     # Test endpoint
     params = {
         'name': 'TEST Session',
         'date': '2015-8-10',
         'startTime': '9:10',
         'conferenceKey': wcksafe
     }
     response = urlfetch.fetch(self.urlbase + test_url,
                     payload=json.dumps(params),
                     method=urlfetch.POST,
                     headers={'Content-Type': 'application/json'})
     self.assertEqual(response.status_code, 200)
 def test_getSessionsBySpeaker(self):
     # Create two conferences
     conf = Conference(name='Test Conference A')
     wckA = conf.put()
     wckAsafe = wckA.urlsafe()
     conf = Conference(name='Test Conference B')
     wckB = conf.put()
     wckBsafe = wckB.urlsafe()
     # Add 4 sessions among conferences with three having particular speaker
     propsA = {'name': 'Monkey Business', 'date': date(2015,8,8),
               'parent': wckA, 'conferenceKey': wckAsafe,
               'typeOfSession': 'lecture', 'startTime': time(18,15)}
     propsB = {'name': 'Monkey Business', 'date': date(2015,9,12),
               'parent': wckB, 'conferenceKey': wckBsafe,
               'typeOfSession': 'workshop', 'startTime': time(12,15)}
     # Add two to first created conference
     Session(speaker=['Sarah', 'Frodo'], **propsA).put()
     Session(speaker=['Frodo'], **propsA).put()
     # Add two to second created conference
     Session(speaker=['Saruman'], **propsB).put()
     Session(speaker=['Gollum', 'Frodo'], **propsB).put()
     # Test the endpoint
     url = '/speaker/{0}'.format('Frodo')
     res = urlfetch.fetch(self.urlbase + url)
     self.assertEqual(res.status_code, 200)
     self.assertEqual(len(json.loads(res.content)['items']), 3)
Exemplo n.º 3
0
    def getMarketableConferences(self, request):
        """Find the conferences that is in progress and not yet fully booked"""
        mtoday = datetime.now().date()
        # Get conferences with seats available
        conf_inprogress_seatsavail = set(
            Conference.query().filter(
                Conference.seatsAvailable > 0).fetch(keys_only=True))
        # Get conferences where open end date is more or equal than today
        conf_inprogress_enddate = set(
            Conference.query().filter(Conference.endDate >= mtoday).fetch(
                keys_only=True))
        # Get conferences where open start date is less than or equal to today
        conf_inprogress_startdate = set(
            Conference.query().filter(Conference.startDate <= mtoday).fetch(
                keys_only=True))

        # return a set with conferences common in all queries
        conf_inprogress_keys = conf_inprogress_seatsavail\
                               & conf_inprogress_startdate\
                               & conf_inprogress_enddate
        conf_inprogress = ndb.get_multi(conf_inprogress_keys)

        return MarketableConferenceForms(items=[
            MarketableConferenceForm(name=getattr(data, "name"),
                                     topics=getattr(data, "topics"),
                                     city=getattr(data, "city"),
                                     seatsAvailable=getattr(data,
                                                            "seatsAvailable"),
                                     endDate=str(getattr(data, "endDate")))
            for data in conf_inprogress])
Exemplo n.º 4
0
def match_or_send_to_waiting_room(call, schedule):

    # Refreshing database object
    flush_transaction()
    call.reload()

    if call.matched:
        other = call.conference.call_set.exclude(pk=call.pk)[0]
        data = send_to_conference_room(call, schedule, other, initial=False)

        if data: return data


    matchcall = find_match(schedule, call)
    if matchcall:
        conf = Conference()
        conf.maxcapacity = 2
        conf.datecreated = as_date(schedule)
        conf.save()

        call.conference = conf
        call.matched = True
        call.save()

        matchcall.conference = conf
        matchcall.matched = True
        matchcall.save()

        data = send_to_conference_room(call, schedule, matchcall, initial=True)
        if data: return data

    if call.user.profile.any_match:
        call.user.profile.any_match = False
        call.user.profile.save()

        return render_to_response("twilioresponse.xml", { 'say' :"We are very sorry - We could not find you a match today, but tomorrow we'll do our best to compensate it! We wish you an awesome day!",
                                                          'hangup' : True })
    #Check if we have exceeded the waiting redirect limits
    elif call.retries >= REDIRECT_LIMIT:
        # The user has reached the limit of redials, so hang up
        logger.debug("LIMIT RETRIES - Ask to try to match with any person")
        any_match = "We could not find any matches. If you'd like us to try to match you with Anyone please press any number now."
        goodbye = "We wish you an Amazing day! Good bye!"
        return render_to_response("twilioresponse.xml", { 'any_match' :any_match, 'schedule': schedule, 'hangup': True, 'goodbye' : goodbye })

    call.retries = call.retries + 1
    call.save()

    # Send user to private conference (Conferencename=Username) or send them to the waiting room they were at
    return send_to_waiting_room(  HOLD_LIMIT
                                    , schedule
                                    , call.user.username
                                    , False
                                    , "Please bare with us - we'll find the best match for you!")
Exemplo n.º 5
0
    def _createConferenceObject(self, conferenceForm):
        """Create conference object, returns ConferenceForm."""

        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException('Authorization required')

        data = formToDict(conferenceForm, exclude=('websafeKey', 'organizerDisplayName'))
        # add default values for those missing
        for df in DEFAULTS:
            if data[df] in (None, []):
                data[df] = DEFAULTS[df]

        # add organizerUserId before checking the required fields
        data['organizerUserId'] = user_id = getUserId(user)

        # check required fields
        for key in Conference.required_fields_schema:
            if not data[key]:
                raise endpoints.BadRequestException("Conference '%s' field required" % key)

        # convert dates from strings to Date objects; set month based on start_date
        try:
            data['startDate'] = datetime.strptime(data['startDate'][:10], "%Y-%m-%d").date()
            data['endDate'] = datetime.strptime(data['endDate'][:10], "%Y-%m-%d").date()
        except (TypeError, ValueError):
            raise endpoints.BadRequestException("Invalid date format. Please use 'YYYY-MM-DD'")

        if data['startDate'] > data['endDate']:
            raise endpoints.BadRequestException("start date must be before end date")
        data['month'] = data['startDate'].month

        # 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

        # create Conference, send email to organizer confirming
        # creation of Conference & return (modified) ConferenceForm
        conf = Conference(**data)
        conf.put()
        taskqueue.add(
            params={'email': user.email(), 'conferenceInfo': repr(conferenceForm)},
            url='/tasks/send_confirmation_email'
        )
        return conf.toForm()
Exemplo n.º 6
0
    def get(self, conf_handle = None):
	request = self.wsgi_request
	response = self.wsgi_response
	c = self.context

	if conf_handle:
	    conf_id = Conference.get_id_from_url_title(conf_handle)
	    c.conf = Conference.get(conf_id)
	    if c.conf:
		return self.render_stuff('/index.html')	
	
	self.set_body("Please enter a valid conference handle..")
	return self.render()
Exemplo n.º 7
0
    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
        # both for data model & outbound Message
        if data["maxAttendees"] > 0:
            data["seatsAvailable"] = data["maxAttendees"]
            setattr(request, "seatsAvailable", data["maxAttendees"])

        # make Profile Key from user ID
        p_key = ndb.Key(Profile, user_id)
        # allocate new Conference ID with Profile key as parent
        c_id = Conference.allocate_ids(size=1, parent=p_key)[0]
        # make Conference key from ID
        c_key = ndb.Key(Conference, c_id, parent=p_key)
        data['key'] = c_key
        data['organizerUserId'] = request.organizerUserId = user_id

        # create Conference & return (modified) ConferenceForm
        conference = Conference(**data)
        conference.put()

        return request
Exemplo n.º 8
0
    def get(self, id = None):
	request = self.wsgi_request
	response = self.wsgi_response
	c = self.context
	response.headers['content-type'] = 'application/json'

	if id is None:
	    #get all the confs
	    confs = [x.to_json(encode = False) for x in Conference.get_all()]
	    self.set_body(json.dumps(confs))
	else:
	    conf = Conference.get(id)
	    self.set_body(conf.to_json())
	return self.render()
    def getConferencesNotSoldOutInAmsterdam(self, request):
        """ Only show conferences in Amsterdam that are not sold out
        """
        in_amsterdam = Conference.query(
            Conference.city == 'Amsterdam')
        not_sold_out = Conference.query(
            Conference.seatsAvailable > 0)

        confs = self._intersectQueries(in_amsterdam, not_sold_out)
        names = self._getConferenceOrganisers(confs)

        return ConferenceForms(
            items=[self._copyConferenceToForm(
                conf, names[conf.organizerUserId]) for conf in confs])
Exemplo n.º 10
0
 def filterPlayground(self, request):
     """Filter Playground"""
     q = Conference.query()
     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])
Exemplo n.º 11
0
    def queryConferences(self, request):
        """Queries conferences for results."""
        conferences = Conference.query()

        return ConferenceForms(
            items = [self._copyConferenceToForm(conf, "")\
            for conf in conferences])
Exemplo n.º 12
0
    def cache_announcement():
        """
        Create Announcement & assign to memcache; used by memcache cron job &
         putAnnouncement().

        :return: announcement string
        """
        confs = Conference.query(ndb.AND(
            Conference.seatsAvailable <= 5,
            Conference.seatsAvailable > 0)
        ).fetch(projection=[Conference.name])

        client = memcache.Client()

        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))
            client.add(MEMCACHE_ANNOUNCEMENTS_KEY, announcement)
        else:
            # If there are no sold out conferences,
            # delete the memcache announcements entry
            announcement = ""
            client.delete(MEMCACHE_ANNOUNCEMENTS_KEY)

        return announcement
Exemplo n.º 13
0
 def getConferencesWithSpace(self, request):
     ''' Get a list of conferences with seats available. '''
     q = Conference.query()
     q = q.filter(Conference.seatsAvailable > 0)
     q = q.order(Conference.seatsAvailable)
     return ConferenceForms(
         items=[self._copyConferenceToForm(conf, "") for conf in q])
Exemplo n.º 14
0
    def filterPlayground(self, request):
        """Return conferences based on query."""

        # define query
        conferences = Conference.query()
        
        # filter by city
        field = "city"
        operator = "="
        value = "London"
        f = ndb.FilterNode(field, operator, value)
        conferences = conferences.filter(f)

        # add another filter, by topic
        field = "topics"
        operator = "="
        value = "Medical Innovations"
        f = ndb.FilterNode(field, operator, value)
        conferences = conferences.filter(f)

        # and filter by month
        conferences = conferences.filter(Conference.maxAttendees > 10)

        # order by conference name
        conferences = conferences.order(Conference.name)

        # return set of ConferenceForm objects per Conference
        return ConferenceForms(
            items=[self._copyConferenceToForm(conf, "") for conf in conferences]
        )
Exemplo n.º 15
0
 def _createConferenceObject(self, request):
     """Create or update Conference object, returning ConferenceForm/request."""
     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")
     data = {field.name: getattr(request, field.name) for field in request.all_fields()}
     del data['websafeKey']
     del data['organizerDisplayName']
     for df in DEFAULTS:
         if data[df] in (None, []):
             data[df] = DEFAULTS[df]
             setattr(request, df, DEFAULTS[df])
     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()
     if data["maxAttendees"] > 0:
         data["seatsAvailable"] = data["maxAttendees"]
     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
     Conference(**data).put()
     taskqueue.add(params={'email': user.email(),
         'conferenceInfo': repr(request)},
         url='/tasks/send_confirmation_email'
     )
     return request
Exemplo n.º 16
0
    def post(self, id = None):
	request = self.wsgi_request
	response = self.wsgi_response
	c = self.context

	param_dict = dict(
		title = request.params.title,
		conf_id = request.params.conf_id,
		desc = request.params.desc,
		venue = request.params.venue,
		talk_type = request.params.talk_type,
		start_date = parse(request.params.start_date),
		end_date = parse(request.params.end_date),
		duration = request.params.duration,
		speaker_title = request.params.speaker_title)
	content = param_dict
	session = Session(**param_dict)
	session = session.save()

	conf = Conference.get(session.conf_id)
	if conf:
	    conf.add_session(session)

	self.set_body(session.to_json())
	response.headers['content-type'] = 'application/json'
	return self.render()
Exemplo n.º 17
0
    def filterPlayground(self, request):
        q = Conference.query()
        # simple filter usage:
        # q = q.filter(Conference.city == "San Francisco")

        # advanced filter building and usage
        field = "city"
        operator = "="
        value = "London"
        field2 = "topics"
        operator2 = "="
        value2 = "Medical Innovations"
        f = ndb.query.FilterNode(field, operator, value)
        g = ndb.query.FilterNode(field2, operator2, value2)
        q = q.filter(f)
        q = q.filter(g)
        q = q.order(Conference.name)
        q = q.filter(Conference.maxAttendees > 30)
        #r = q.filter(g)

        # TODO
        # add 2 filters:
        # 1: city equals to London
        # 2: topic equals "Medical Innovations"

        return ConferenceForms(
            items=[self._copyConferenceToForm(conf, "") for conf in q]
        )
    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)

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

        # copy SessionForm/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_SESSION:
            if data[df] in (None, []):
                data[df] = DEFAULTS_SESSION[df]
                setattr(request, df, DEFAULTS_SESSION[df])

        # Getting a TEMP conference key for the moment
        q = Conference.query()
        cons = q.get()
        c_key = cons.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

        Session(**data).put()

        return request
    def testUnregisterFromConference(self):
        """ TEST: Unregister user for selected conference."""
        self.initDatabase()

        # verify database fixture
        self.login()
        prof = ndb.Key(Profile, self.getUserId()).get()
        conf = Conference.query(Conference.name == 'room #2').get()
        assert conf and conf.seatsAvailable == 1 and len(prof.conferenceKeysToAttend) == 0, \
            "This shouldn't fail. Maybe someone messed with database fixture"

        prof.conferenceKeysToAttend.append(conf.key)
        prof.put()

        container = CONF_GET_REQUEST.combined_message_class(
            websafeConferenceKey=conf.key.urlsafe(),
        )

        # unregister conference
        r = self.api.unregisterFromConference(container)

        # re-fetch profile and conference, then check if user was properly unregistered
        prof = prof.key.get()
        conf = conf.key.get()
        assert r.data, 'Returned an invalid response'
        assert len(prof.conferenceKeysToAttend) == 0, "Failed to remove conference from user's conferenceKeysToAttend"
        assert conf.seatsAvailable == 2, 'Failed to increment available seats'
Exemplo n.º 20
0
    def getSessionsBySpeaker(self, request):
        """Given a speaker, return all sessions given by this particular speaker, across all conferences"""

        # make sure user is logged in
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException("Authorization required")
        user_id = getUserId(user)

        # get speaker value from form request
        sessionSpeakerOfInterest = request.speaker

        # store all session objects across all conferences where this speaker is presenting
        all_sessions = []
        # query for conferences
        conferences = Conference.query()
        for conf in conferences:
            ck = getattr(conf, "key")
            wsck = ck.urlsafe()

            # For each conference, get Sessions for the Conference filtered by Speaker
            sessions = Session.query(Session.websafeConferenceKey == wsck)
            sessions = sessions.filter(Session.speaker == sessionSpeakerOfInterest)

            for session in sessions:
                all_sessions.append(session)

        # return sessions in all conferences
        return SessionForms(items=[self._copySessionToForm(session) for session in all_sessions])
Exemplo n.º 21
0
    def getConferencesByPopularity(self, request):
        """Return conferences by popularity"""
        # fetch conference from key
        conf = Conference.query().fetch()

        # Check that conference exists
        if not conf:
            raise endpoints.NotFoundException("No conference found with this key: %s" % request.websafeConferenceKey)
        conf_list = []

        for c in conf:
            count = Profile.query().filter(Profile.conferenceKeysToAttend == c.key.urlsafe()).count()
            conf_list.append({"conf": c, "count": count})
        conf_list = sorted(conf_list, key=lambda conf: conf["count"], reverse=True)

        # need to fetch organiser displayName from profiles
        # get all keys and use get_multi for speed
        organisers = [(ndb.Key(Profile, c.organizerUserId)) for c in conf]
        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(c["conf"], names[c["conf"].organizerUserId]) for c in conf_list]
        )
Exemplo n.º 22
0
 def filterPlayground(self, request):
     q = Conference.query()
     # simple filter usage:
     # q = q.filter(Conference.city == "London")
 
     # advanced filter building and usage
     # field = "city"
     # operator = "="
     # value = "London"
     # f = ndb.query.FilterNode(field, operator, value)
     # q = q.filter(f)
 
     # TODO
     # add 2 filters:
     # 1: city equals to London
     q = q.filter(Conference.city == "London")
     # 2: topic equals "Medical Innovations"
     q = q.filter(Conference.topics == "Medical Innovations")
     
     q.order(Conference.name)
     
     q = q.filter(Conference.maxAttendees > 8)
 
     return ConferenceForms(
         items=[self._copyConferenceToForm(conf, "") for conf in q]
     )
Exemplo n.º 23
0
    def getSessionsByDateAndCity(self, request):
        """Return all sessions in given city on given date."""
        # Expect date in format YYYY-MM-DD
        try:
            date = datetime.strptime(request.date, '%Y-%m-%d').date()
        except ValueError:
            raise endpoints.BadRequestException('Invalid date - '
                        'must be in YYYY-MM-DD format')

        # get just the keys for conferences in city
        conf_keys = Conference.query(Conference.city==request.city)\
                              .fetch(keys_only=True)

        # get all sessions for conferences in city, filter on date
        # (Guido's advice in http://stackoverflow.com/questions/12440333/
        # ndb-query-on-multiple-parents-given-a-cursor)
        # need to do multiple ancestor queries, do asynchronously
        futures = []
        for c_key in conf_keys:
            futures.append(Session.query(ancestor=c_key)\
                   .filter(Session.date==date)\
                   .fetch_async())
        
        sess = []
        for f in futures:
            sess.extend(f.get_result())
        
        return SessionForms(
            items=[self._copySessionToForm(s) for s in sess]
        )
Exemplo n.º 24
0
    def getNotRegisteredWishlist(self, request):
        """Returns all sesssions on a users wishlist where the user is not
        registered for the conference."""
        prof = self._getProfileFromUser()
        wishlist = prof.wishList
        wishlist_keys = [ndb.Key(urlsafe=wish) for wish in wishlist]

        # Get conferences attending.
        attending_wsk = prof.conferenceKeysToAttend
        attending_keys = [ndb.Key(urlsafe=wsk) for wsk in attending_wsk]

        # Get the parent conferenes of all sessions in the query.
        conf_keys = [session_key.parent() for session_key in wishlist_keys]

        # Query confreences with wishlist session as child.
        q = Conference.query()
        q = q.filter(Conference.key.IN([key for key in conf_keys]))

        # Query conferences that do not include those being attended.
        for key in attending_keys:
            q = q.filter(Conference.key != key)

        return ConferenceForms(
            items=[self._copyConferenceToForm(conference, "")
                for conference in q])
    def testGetAnnouncement(self):
        """ TEST: Return Announcement from memcache."""
        self.initDatabase()

        # Verify database fixture
        confs = Conference.query(ndb.AND(
            Conference.seatsAvailable <= 5,
            Conference.seatsAvailable > 0)
        ).fetch()
        assert len(confs) == 1 and confs[0].name == 'room #2' and None == memcache.get(MEMCACHE_ANNOUNCEMENTS_KEY), \
            "This shouldn't fail. Maybe someone messed with database fixture"

        # Since an announcement was never set `getAnnouncement()` should return an empty StringMessage
        response = self.api.getAnnouncement(message_types.VoidMessage())
        assert response.data == '', 'Expected an empty string since no announcement was set'

        # set announcement
        request = webapp2.Request.blank('/crons/set_announcement')
        response = request.get_response(main.app)
        # validate http status
        assert response.status_int == 204, 'Invalid response expected 204 but got %d' % response.status_int

        # Verify room #2 is listed in the announcement
        response = self.api.getAnnouncement(message_types.VoidMessage())
        assert 'room #2' in response.data, 'Announcement is missing a conference'
Exemplo n.º 26
0
 def get(self, confid, secret):
     """Download all speakers and proposals for a conference"""
     # Super-Reviewers
     committee = []
     if confid == 'droidcon-2016':
         committee = ['*****@*****.**',
                      '*****@*****.**']
     # get conference
     conference = Conference.get_by_id(confid)
     # check if the provided secret is correct
     if conference.secret != secret:
         self.response.http_status_message(403)
         return
     speakers = Speaker.query()
     proposals = Proposal.query(ancestor=conference.key)
     reviews = Review.query()
     speakers_dict = [dict(s.to_dict(), **dict(id=s.key.id()))
                      for s in speakers]
     proposals_dict = []
     # create a fast lookup table - reviews by parent
     reviews_by_parent = {}
     for r in reviews:
         parent = r.key.parent()
         rlist = reviews_by_parent[parent]
         if rlist is None:
             rlist = []
         rlist.append(r)
         reviews_by_parent[parent] = rlist
     # crete a fast lookup table - speaker by key
     speakers_by_id = {}
     for s in speakers:
         speakers_by_key[s.key] = s
     for p in proposals:
         p_dict = p.to_dict()
         p_dict['id'] = p.key.id()
         p_r = {}
         p_sum = 0
         for r in reviews_by_parent[p.key]:
             p_r[r.key.id()] = r.to_dict()
             if r.rating:
                 if r.key.id() in committee:
                     # double the rating!
                     p_sum = p_sum + r.rating
                 p_sum = p_sum + r.rating
         s = speakers_by_key[p.speaker]
         if s is not None:
             p_dict['speaker-email'] = s.email
             p_dict['speaker-name'] = s.name
             p_dict['speaker-surname'] = s.surname
             if s.rating:
                 p_sum = p_sum + s.rating
         p_dict['reviews'] = p_r
         p_dict['rating'] = p_sum
         proposals_dict.append(p_dict)
     self.response.headers['Content-Type'] = 'application/json'
     obj = {
         'speakers': speakers_dict,
         'proposals': proposals_dict,
     }
     self.response.out.write(json.dumps(obj, cls=DatastoreEncoder))
Exemplo n.º 27
0
    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:
            print "We are going to set the announcement"

            # If there are almost sold out conferences,
            # format announcement and set it in memcache
            announcement = '%s %s' % (
                'Last chance to attend! The following conferences '
                'are nearly sold out:',
                ', '.join(conf.name for conf in confs))
            memcache.set(MEMCACHE_ANNOUNCEMENTS_KEY, announcement)

            print "The announcement has been set."
        else:
            print "We are going to delete the announcement from memcache"

            # If there are no sold out conferences,
            # delete the memcache announcements entry
            announcement = ""
            memcache.delete(MEMCACHE_ANNOUNCEMENTS_KEY)

            print "The announcement has been deleted from memcache"

        return announcement
Exemplo n.º 28
0
    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 testGetProfile(self):
        """ TEST: Get user's profile  """
        self.initDatabase()
        try:
            # only logged in users have a profile
            self.api.getProfile(message_types.VoidMessage())
            assert False, 'UnauthorizedException should of been thrown'
        except UnauthorizedException:
            pass

        # login and retrieve the profile
        self.login()
        prof = ndb.Key(Profile, self.getUserId()).get()
        # Add conferences to conferenceKeysToAttend so we can verify the returned keys are web safe
        keys = Conference.query().fetch(keys_only=True)
        prof.conferenceKeysToAttend = keys
        prof.put()

        r = self.api.getProfile(message_types.VoidMessage())
        assert r.mainEmail == '*****@*****.**', 'Returned an invalid user profile'
        assert len(r.conferenceKeysToAttend) > 0, 'Returned an invalid number of conference keys'
        # verify that all keys are urlsafe
        websafeKeys = [key.urlsafe() for key in keys]
        for websafeKey in r.conferenceKeysToAttend:
            assert websafeKey in websafeKeys, 'Returned an invalid key'
Exemplo n.º 30
0
    def filterPlayground(self, request):
        q = Conference.query()

        # advanced filter building and usage
        field = "city"
        operator = "="
        value = "London"
        f = ndb.query.FilterNode(field, operator, value)
        q = q.filter(f)

        # TODO
        # add 2 filters:
        # 1: city equals to London
        # 2: topic equals "Medical Innovations"

        field = "topics"
        operation = "="
        value = "Medical Innovations"
        f = ndb.query.FilterNode(field, operator, value)
        q = q.filter(f)

        q = q.order(Conference.maxAttendees)

        return ConferenceForms(
            items=[self._copyConferenceToForm(conf, "") for conf in q]
        )
    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
        ])
Exemplo n.º 32
0
    def getUpcomingConferences(self, request):
        """Get upcoming conferences"""
        conferences = Conference.query(Conference.startDate >= datetime.today()) \
            .order(Conference.startDate) \
            .fetch(limit=10)  # limit number of conferences to 10

        organizer_keys = [ndb.Key(Profile, conference.organizerUserId) for conference in
                          conferences]
        profiles = ndb.get_multi(organizer_keys)
        organizer_dict = {profile.key.id(): profile.displayName for profile in profiles}

        return ConferenceForms(
            items=[self._copyConferenceToForm(conference,
                                              organizer_dict[conference.organizerUserId])
                   for conference in conferences]
        )
Exemplo n.º 33
0
 def getConferencesCreated(self, requset):
     user = endpoints.get_current_user()
     if not user:
         raise endpoints.UnauthorizedException('Authorization Required')
     #Make Profile Key
     p_key = ndb.Key(Profile, getUserID(user))
     #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
     ])
Exemplo n.º 34
0
 def getNextConference(self, request):
     """Get next conference to start from user's current time"""
     # Query conferences
     q = Conference.query()
     # filter away past conferences
     q = q.filter(Conference.startDate >= datetime.today())
     # order by date
     q = q.order(Conference.startDate)
     # get earliest conference
     conf = q.get()
     if not conf:
         raise endpoints.NotFoundException(
             'No conference found')
     # get organizer profile for display name
     prof = conf.key.parent().get()
     # return ConferenceForm
     return self._copyConferenceToForm(conf, getattr(prof, 'displayName'))
Exemplo n.º 35
0
    def getWebSafeKeys(self, request):
        """Get websafe keys for all conferences"""
        # Query all conferences for their websafe keys
        items = []
        query = Conference.query()
        for conf in query.fetch():
            temp = conf.key.parent().get()
            items.append([conf.name, conf.key.urlsafe(), temp.displayName])

        # Create and send message with all the keys, names, and organizers
        keys = []
        wsk = WebSafeKeys()
        for i in items:
            temp = WebSafeKeyQuery(name=i[0], key=i[1], organizer=i[2])
            keys.append(temp)
        wsk.items = keys
        wsk.check_initialized()
        return wsk
Exemplo n.º 36
0
    def getlowReg(self, request):
        """Return conferences that are less than half full."""
        # create list to stored conferences to be returned and then
        # fetch all conferences
        confsToReturn = []
        confs = Conference.query()
        # loop through all conferences adding matching entries to the list
        for c in confs:
            maxAttendees = c.maxAttendees
            seatsAvailable = c.seatsAvailable
            if seatsAvailable > maxAttendees / 2:
                confsToReturn += [c]

        return ConferenceForms(items=[
            self._copyConferenceToForm(
                conf, getattr(conf.key.parent().get(), 'displayName'))
            for conf in confsToReturn
        ])
Exemplo n.º 37
0
    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
Exemplo n.º 38
0
    def getNoSessions(self, request):
        """Return conferences that have no sessions."""
        # create list to stored conferences to be returned and then
        # fetch all conferences
        confsToReturn = []
        confs = Conference.query()
        # loop through all conferences adding matching conferences
        # with no sessions
        for c in confs:
            sessions = Session.query(ancestor=c.key)
            if sessions.count() == 0:
                confsToReturn += [c]

        return ConferenceForms(items=[
            self._copyConferenceToForm(
                conf, getattr(conf.key.parent().get(), 'displayName'))
            for conf in confsToReturn
        ])
Exemplo n.º 39
0
    def filterPlayground(self, request):
        q = Conference.query()
        # simple filter usage:
        # q = q.filter(Conference.city == "Paris")

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

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

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

        # TODO
        # add 2 filters:
        # 1: city equals to London
        # 2: topic equals "Medical Innovations"

        return ConferenceForms(
            items=[self._copyConferenceToForm(conf, "") for conf in q])
Exemplo n.º 40
0
    def getConferencesCreated(self, request):
        """Return conferences created by user."""
      
        user = endpoints.get_current_user()
        if not user:
            raise endpoints.UnauthorizedException('Authorization required')

     
        p_key = ndb.Key(Profile, getUserId(user))
       
        conferences = Conference.query(ancestor=p_key)
       
        prof = p_key.get()
        displayName = getattr(prof, 'displayName')
    
        return ConferenceForms(
            items=[self._copyConferenceToForm(conf, displayName) for conf in conferences]
        )    
Exemplo n.º 41
0
    def getConferencesCreated(self, request):
        """Return conferences created by user."""
        
        # Getting and Verifying current user
        user = getUser()

        # get the user_id (email) 
        user_id = getUserId(user)

        # create ancestor query for all key matches for this user
        conferences = Conference.query(ancestor=ndb.Key(Profile, user_id))
        
        prof = ndb.Key(Profile, user_id).get()
        
        # return one or many ConferenceForm objects
        return ConferenceForms(
            items = [self._copyConferenceToForm(
                conf, getattr(prof, 'displayName')) for conf in conferences])
Exemplo n.º 42
0
    def filterPlayground(self, request):
        q = Conference.query()

        # city equals to London
        q = q.filter(Conference.city == "London")

        # order by conference name
        q = q.order(Conference.name)

        # advanced filter building and usage
        # field = "city"
        # operator = "="
        # value = "London"
        # f = ndb.query.FilterNode(field, operator, value)
        # q = q.filter(f)

        return ConferenceForms(
            items=[self._copyConferenceToForm(conf, "") for conf in q])
    def filterPlayground(self, request):
        q = Conference.query()

        # TODO
        # add 2 filters:
        # 1: city equals to London
        q = q.filter(Conference.city == "London")

        # 2: topic equals "Medical Innovations"
        q = q.filter(Conference.topics == "Medical Innovations")

        # 3: order by conference  name
        q = q.order(Conference.name)

        # first for month of June
        q = q.filter(Conference.maxAttendees > 10)

        return ConferenceForms(
            items=[self._copyConferenceToForm(conf, "") for conf in q])
Exemplo n.º 44
0
    def getConferencesByTopic(self, request):
        """Return all conferences on a given topic"""
        confs = Conference.query()
        confs = confs.filter(Conference.topics == request.topic)

        # get organizers
        organisers = [ndb.Key(Profile, conf.organizerUserId) for conf in confs]
        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 confs]
        )
Exemplo n.º 45
0
    def get_conferences_created(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')

        # make profile key
        p_key = ndb.Key(Profile, get_user_id(user))
        # 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._copy_conference_to_form(conf, displayName)
            for conf in conferences
        ])
Exemplo n.º 46
0
    def filterPlayground(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')

#delete everything in users wishlist
        prof = self._getProfileFromUser()  # get user Profile
        #print "******* %s" ,prof.wishListSessionKeys
        prof.wishListSessionKeys[:] = []

        conferences = Conference.query()
        conferences = conferences.filter(Conference.city == "London")

        # return set of ConferenceForm objects per Conference
        return ConferenceForms(items=[
            self._copyConferenceToForm(conf, "") for conf in conferences
        ])
Exemplo n.º 47
0
    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 an instance of a Key for an id(user email) of a kind(Profile) 
        p_key = ndb.Key(Profile, user_id)
        # query conferences with ancestor 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]
        )
Exemplo n.º 48
0
def get_user_id(user, id_type="email"):
    """
    Get user id
    :param user:
    :param id_type:
    :return:
    """
    if id_type == "email":
        return user.email()

    if id_type == "oauth":
        """A workaround implementation for getting userid."""
        auth = os.getenv('HTTP_AUTHORIZATION')
        bearer, token = auth.split()
        token_type = 'id_token'
        if 'OAUTH_USER_ID' in os.environ:
            token_type = 'access_token'
        url = ('https://www.googleapis.com/oauth2/v1/tokeninfo?%s=%s' %
               (token_type, token))
        user = {}
        wait = 1
        for i in range(3):
            resp = urlfetch.fetch(url)
            if resp.status_code == 200:
                user = json.loads(resp.content)
                break
            elif resp.status_code == 400 and 'invalid_token' in resp.content:
                url = ('https://www.googleapis.com/oauth2/v1/tokeninfo?%s=%s' %
                       ('access_token', token))
            else:
                time.sleep(wait)
                wait += i
        return user.get('user_id', '')

    if id_type == "custom":
        # implement your own user_id creation and getting algorythm
        # this is just a sample that queries datastore for an existing profile
        # and generates an id if profile does not exist for an email
        profile = Conference.query(Conference.organizerUserId == user.email())
        if profile:
            return profile.id()
        else:
            return str(uuid.uuid1().get_hex())
Exemplo n.º 49
0
    def getSessionByCity(self, request):
        """Given a city, return all sessions across all conferences in the city."""
        # get all the conferences in the city
        c = Conference.query()
        c = c.filter(Conference.city == request.city)
        conferences = c.fetch()

        logging.debug(conferences)
        # get all the websafeConferenceKeys for the conferences
        confWebKeys = [conf.key.urlsafe() for conf in conferences]

        logging.debug(confWebKeys)
        # find all the sessions matching any of the conferences that matched the city, across all conferences
        sessions = Session.query()
        sessions = sessions.filter(Session.webSafeConfId.IN(confWebKeys))

        # return set of SessionForm objects one per Session
        return SessionForms(
            items=[self._copySessionToForm(sesn) for sesn in sessions])
Exemplo n.º 50
0
 def _cacheAnnouncement():
     """Create Announcement & assign to memcache.
     """
     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 = '%s %s' % (
             'Last chance to attend! The following conferences '
             'are nearly sold out:', ', '.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
Exemplo n.º 51
0
 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
Exemplo n.º 52
0
    def filterPlayground(self, request):
        q = Conference.query()
        # simple filter usage:
        q = q.filter(Conference.city == "London")
        q = q.filter(Conference.topics == "Medical Innovations")
        q = q.order(Conference.name)
        # advanced filter building and usage
        # field = "city"
        # operator = "="
        # value = "London"
        # f = ndb.query.FilterNode(field, operator, value)
        # q = q.filter(f)

        # TODO
        # add 2 filters:
        # 1: city equals to London
        # 2: topic equals "Medical Innovations"

        return ConferenceForms(
            items=[self._copyConferenceToForm(conf, "") for conf in q])
Exemplo n.º 53
0
    def getSessionByCity(self, request):
        """Returns all sessions for a given city, across all conferences"""
        # Create a list to hold all of the sessions found.
        results = []
        # Create conference query
        conferences = Conference.query()
        # Filter conferences by city
        conferences = conferences.filter(Conference.city == request.city)
        # Create ancestor query to find session for each conference.
        for conf in conferences:
            # Create an ancestor query to get the sessions for this conference
            sessions = Session.query(ancestor=conf.key)
            # Add each session in the query to the results list
            for s in sessions:
                # print s.name
                results.append(s)

        # Return set of SessionForm objects
        return SessionForms(
            sessions=[self._copySessionToForm(s) for s in results])
Exemplo n.º 54
0
    def filterPlayground(self, request):
        q = Conference.query()

        # simple filter usage:
        # q = q.filter(Conference.city == "Paris")

        # advanced filter building and usage
        # 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.maxAttendees > 10)

        q = q.order(Conference.name)

        return ConferenceForms(
            items=[self._copyConferenceToForm(conf, "") for conf in q])
Exemplo n.º 55
0
    def _cacheAnnouncement():

        confs = Conference.query(
            ndb.AND(Conference.seatsAvailable <= 5,
                    Conference.seatsAvailable > 0)).fetch(
                        projection=[Conference.name])

        if confs:
            #announcement = '%s %s' % (
            #    'Last chance to attend! The following conferences '
            #    'are nearly sold out:',
            #    ', '.join(conf.name for conf in confs))
            #-------------------OR-----------------------
            announcement = ANNOUNCEMENT_TPL % (', '.join(conf.name
                                                         for conf in confs))
            memcache.set(MEMCACHE_ANNOUNCEMENTS_KEY, announcement)
        else:
            announcement = ""
            memcache.delete(MEMCACHE_ANNOUNCEMENTS_KEY)

        return announcement
Exemplo n.º 56
0
    def filterPlayground(self, request):
        q = Conference.query()

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

        # Equivalent through ndb
        # field = "city"
        # operator = "="
        # value = "London"
        # f = ndb.query.FilterNode(field, operator, value)
        # q = q.filter(f)

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

        q = q.order(Conference.name)

        q = q.filter(Conference.maxAttendees > 10)

        return ConferenceForms(
            items=[self._copy_conference_to_form(conf, "") for conf in q])
Exemplo n.º 57
0
    def getRecentConferences(self, request):
        """Query for conferences in future 30 days"""
        today = datetime.now()
        one_month = timedelta(days=30)
        one_month = today - one_month
        c = Conference.query()
        c = c.filter(Conference.startDate >= one_month)

        # 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 c]
        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 c]
        )
Exemplo n.º 58
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]
        )
Exemplo n.º 59
0
    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:
          
            announcement = '%s %s' % (
                'Last chance to attend! The following conferences '
                'are nearly sold out:',
                ', '.join(conf.name for conf in confs))
            memcache.set(MEMCACHE_ANNOUNCEMENTS_KEY, announcement)
        else:
       
            announcement = ""
            memcache.delete(MEMCACHE_ANNOUNCEMENTS_KEY)

        return announcement
Exemplo n.º 60
0
    def getConferenceAndSessionByKeyword(self, request):
        """Get conference and session by keyword."""
        keyword = request.keyword

        # Pass all query, keyword, seleted field to function _keywordFinder()
        # get the result list back. 
        all_c = Conference.query().fetch()
        field_c = ['name', 'description', 'topics']
        c_list = self._keywordFinder(all_c, keyword, *field_c)


        all_s = Session.query().fetch()
        field_s = ['sessionName', 'highlights', 'conferenceBelongTo']
        s_list= self._keywordFinder(all_s, keyword, *field_s)

        return ConferenceFormAndSessionForm(
            c_data=ConferenceForms(
                items=[self._copyConferenceToForm(c) for c in c_list]
                ),
            s_data=SessionForms(
                items=[self._copySessionToForm(s) for s in s_list]
                )
            )