def get_sessions_by_type_and_filters(self, websafe_conference_key,
session_type, filters):
"""Gets a list of sessions with a specific type and arbitrary filters.
Args:
websafe_conference_key (string)
session_type (string)
filters (list)
Returns:
ConferenceSessionForms
"""
if filters:
filter_maker = AppliesFilters(ConferenceSession, {
'datetime': ['dateTime'],
'int': ['duration', 'hour']
}, {
'TITLE': 'title',
'DURATION': 'duration',
'DATE': 'dateTime',
'HOUR': 'hour'
})
sessions = filter_maker.get_query(filters, 'title',
websafe_conference_key).fetch()
else:
sessions = ConferenceSession.query(
ConferenceSession.websafeConferenceKey ==
websafe_conference_key).fetch()
return ConferenceSessionForms(items=[
self.copy_entity_to_form(ConferenceSessionForm(), s)
for s in sessions if s.typeOfSession == unicode(session_type)
])
def test_it_can_get_conference_sessions_by_conference_id(self):
session_service = SessionService()
conf_id = Conference(name="a conference").put().urlsafe()
ConferenceSession(title='This is the title',
dateTime=datetime.datetime(2016, 12, 12, 13, 15),
highlights="blah blah ha",
websafeConferenceKey=conf_id,
duration=12,
typeOfSession='snails').put().urlsafe()
ConferenceSession(title='This is the other title',
dateTime=datetime.datetime(2017, 12, 12, 23, 32),
highlights="blah hahahaha blah ha",
websafeConferenceKey=conf_id,
duration=1,
typeOfSession='snails').put().urlsafe()
sessions = session_service.get_conference_sessions(conf_id)
self.assertEqual(2, len(sessions.items))
def test_it_can_create_sessions(self):
p_key = ndb.Key(Profile, '*****@*****.**')
profile = Profile(mainEmail='*****@*****.**', key=p_key).put()
conf_id = Conference(name="a conference",
organizerUserId='*****@*****.**',
parent=p_key).put().urlsafe()
request = ConferenceSessionForm(title='This is the title',
date="2016-12-12",
highlights="blah blah ha",
startTime="13:15",
websafeConferenceKey=conf_id,
speakerEmails=['*****@*****.**'],
duration=12,
typeOfSession='snails')
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
auth = self.mock_auth('*****@*****.**')
session_service = SessionService(auth=auth)
session_service.create_conference_session(request, profile)
self.assertEqual(1, len(ConferenceSession.query().fetch(2)))
session = ConferenceSession.query(
ConferenceSession.websafeConferenceKey == conf_id).fetch()
self.assertEquals(data['title'], session[0].title)
self.assertEquals(data['highlights'], session[0].highlights)
self.assertEquals(data['typeOfSession'], session[0].typeOfSession)
self.assertEquals(data['duration'], session[0].duration)
self.assertEquals(datetime.datetime(2016, 12, 12, 13, 15),
session[0].dateTime)
speaker = ndb.Key(urlsafe=session[0].speakerKeys[0]).get()
self.assertEquals(speaker.email, '*****@*****.**')
def test_it_can_find_speaker_sessions(self):
# Make two sessions by the same speaker at 2 separate conferences.
websafe_speaker_key = SpeakerService.find_or_create('*****@*****.**')
websafe_speaker_key_2 = SpeakerService.find_or_create(
'*****@*****.**')
conf_id = Conference(name="a conference").put().urlsafe()
ConferenceSession(
title='This is the title',
dateTime=datetime.datetime(2016, 12, 12, 13, 15),
websafeConferenceKey=conf_id,
speakerKeys=[websafe_speaker_key,
websafe_speaker_key_2]).put().urlsafe()
conf_id_2 = Conference(name="another conference").put().urlsafe()
ConferenceSession(title='This is another title',
dateTime=datetime.datetime(2016, 12, 12, 13, 15),
websafeConferenceKey=conf_id_2,
speakerKeys=[websafe_speaker_key]).put().urlsafe()
session_service = SessionService()
sessions = session_service.get_speaker_sessions(websafe_speaker_key)
self.assertEqual(2, len(sessions.items))
sessions = session_service.get_speaker_sessions(websafe_speaker_key_2)
self.assertEqual(1, len(sessions.items))
def get_speaker_sessions(self, websafe_speaker_key):
"""Gets a list of sessions featuring this speaker.
Args:
websafe_speaker_key (string)
Returns:
ConferenceSessionForms
"""
sessions = ConferenceSession.query(
ConferenceSession.speakerKeys == websafe_speaker_key).fetch()
return ConferenceSessionForms(items=[
self.copy_entity_to_form(ConferenceSessionForm(), session)
for session in sessions
])
def get_conference_sessions(self, websafe_conference_key):
"""Gets all the sessions associated with a conference.
Args:
websafe_conference_key (string)
Returns:
ConferenceSessionForms
"""
sessions = ConferenceSession.query(
ConferenceSession.websafeConferenceKey ==
websafe_conference_key).fetch()
return ConferenceSessionForms(items=[
self.copy_entity_to_form(ConferenceSessionForm(), session)
for session in sessions
])
def get_conference_sessions_by_type(self, websafe_conference_key,
session_type):
"""Gets a list of sessions in a conference with a specific type.
Args:
websafe_conference_key (string)
Returns:
ConferenceSessionForms
"""
sessions = ConferenceSession.query(
ndb.AND(
ConferenceSession.websafeConferenceKey ==
websafe_conference_key,
ConferenceSession.typeOfSession == session_type)).fetch()
return ConferenceSessionForms(items=[
self.copy_entity_to_form(ConferenceSessionForm(), session)
for session in sessions
])
def post(self):
"""Checks for featured speakers, and caches one if found."""
keys = self.request.get('speakers').split('|||')
c_key = ndb.Key(urlsafe=self.request.get('websafe_conference_key'))
featured_speakers = []
# Check for multiple keys in speakerKeys
for key in keys:
sessions = ConferenceSession.query(
ConferenceSession.speakerKeys == key, ancestor=c_key).fetch()
if len(sessions) > 1:
featured_speakers.append(key)
if not featured_speakers:
return
featured_key = random.choice(featured_speakers)
memcache.set(MEMCACHE_FEATURED_SPEAKER_KEY, featured_key)
def create_conference_session(self, request, user):
"""Create or update Session object, returning SessionForm/request.
Args:
request (ConferenceSessionForm)
user (User)
Returns:
string
Raises:
endpoints.BadRequestException
"""
if not request.title:
raise endpoints.BadRequestException(
"Session 'title' field required")
if not request.startTime:
raise endpoints.BadRequestException("Session 'startTime' field "
"required")
if not request.date:
raise endpoints.BadRequestException(
"Session 'date' field required")
c_key = ndb.Key(urlsafe=request.websafeConferenceKey)
conf = c_key.get()
# TODO: This should be in the client
self.check_owner(conf, user)
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
if request.speakerEmails:
data['speakerKeys'] = [
SpeakerService.find_or_create(email)
for email in request.speakerEmails
]
taskqueue.add(params={
'speakers':
'|||'.join(data['speakerKeys']),
'websafe_conference_key':
request.websafeConferenceKey
},
url='/tasks/cache_featured_speaker')
del data['speakerEmails']
# TODO: Enable speaker entities to be updated
del data['websafeSessionKey']
# convert dates from strings to Date objects;
# set month based on start_date
data['dateTime'] = datetime.strptime(
data['date'] + ' ' + data['startTime'], "%Y-%m-%d %H:%M")
data['hour'] = data['dateTime'].hour
del data['date']
del data['startTime']
s_id = ConferenceSession.allocate_ids(size=1, parent=c_key)[0]
s_key = ndb.Key(ConferenceSession, s_id, parent=c_key)
data['key'] = s_key
sess = ConferenceSession(**data).put()
return sess.urlsafe()