def get_by_speaker(self, request):
"""
Given a speaker, return all sessions given by this particular speaker,
across all conferences
:param request:
:return:
"""
if request.name and not request.title:
speakers = Speaker.query(Speaker.name == request.name)
elif not request.name and request.title:
speakers = Speaker.query(Speaker.title == request.title)
else:
speakers = Speaker.query(Speaker.name == request.name) \
.filter(Speaker.title == request.title)
speakers.fetch()
all_sessions = []
if speakers:
for speaker in speakers:
sessions = Session.query(
Session.speakerKeys == speaker.key).fetch()
if sessions:
all_sessions += sessions
return SessionForms(items=self.populate_forms(all_sessions))
def _createSpeakerObject(self, request):
"""Create Speaker object,
returning SpeakerForm/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(
"Speaker 'name' field required")
# copy SpeakerForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) \
for field in request.all_fields()}
del data['websafeKey']
speaker_id = Speaker.allocate_ids(size=1)[0]
speaker_key = ndb.Key(Speaker, speaker_id)
data['key'] = speaker_key
# create Speaker
speaker = Speaker(**data)
speaker.put()
# return the modified SpeakerForm
return self._copySpeakerToForm(speaker)
def _getSpeakerKey(self, request):
""" Returns the key for a requested speaker, when he exists."""
if not request.name:
raise endpoints.BadRequestException("Speaker 'name' field \
required")
# create a new Speaker.key
spk_key = Speaker().key
# query all existing/known speakers
qryKnownSpeakers = Speaker.query()
# write the names of the known speakers in a list
knownSpeakers = []
for ks in qryKnownSpeakers:
knownSpeakers.append(ks.name)
# If speaker doesn't exist, raise an "Not Found"-exception.
if request.name not in knownSpeakers:
raise endpoints.NotFoundException(
'No speaker found with name: %s'
% request.name)
# Else return its key.
# NOTE: For simplification, it is assumed that a name uniquely
# identifies a speaker.
else:
spk_key = Speaker.query(Speaker.name == request.name).get().key
return spk_key
def _createSpeakerObject(self, request):
"""Create Speaker object, returning SpeakerForm/request."""
user = self._getAuthUser()
user_id = getUserId(user)
if not request.name:
raise endpoints.BadRequestException("Speaker 'name' field required")
if not request.email:
raise endpoints.BadRequestException("Speaker 'email' field required")
# copy SpeakerForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
# create Speaker key
sp_id = Speaker.allocate_ids(size=1)[0]
sp_key = ndb.Key(Speaker, sp_id)
# assign the Speaker key
data['key'] = sp_key
del data['websafeKey']
# create Speaker
speaker = Speaker(**data)
speaker.put()
return self._copySpeakerToForm(speaker)
def _createSpeakerObject(self, request):
"""Create Speaker object, returning SpeakerForm."""
# check for auth'ed and valid user
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
# Speaker name must be filled
if not request.name:
raise endpoints.BadRequestException("Field 'name' required")
# copy SpeakerForm/ProtoRPC Message into dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
# allocate new Speaker ID
s_id = Speaker.allocate_ids(size=1)[0]
# make Speaker key from ID
s_key = ndb.Key(Speaker, s_id)
data['key'] = s_key
# create Speaker & return SpeakerForm
speaker = Speaker(**data)
speaker.put()
return self._copySpeakerToForm(speaker)
def _createSpeakerObject(self, request):
"""Create Speaker Object, returning SessionForm/request."""
data = {field.name: getattr(request, field.name)
for field in request.all_fields()}
del data['speakerId']
key = Speaker(**data).put()
return self._copySpeakerToForm(key.get())
def getConferenceSessionsBySpeaker(self, request):
"""Return Conference sessions by Speaker."""
# make sure user is authed
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
# user_id = getUserId(user)
sp_lastName = request.lastName
sp_firstName = request.firstName
if sp_firstName:
# find by first and last name
speaker = Speaker.query(ndb.AND(
Speaker.lastName == sp_lastName,
Speaker.firstName == sp_firstName))
else:
# find by last name only
speaker = Speaker.query(Speaker.lastName == sp_lastName)
speaker_keys = [sp.key for sp in speaker]
# iterate over each key finding all sessions
all_sessions = []
for sp_k in speaker_keys:
sessions = Session.query(Session.speaker == sp_k)
for s in sessions:
all_sessions.append(s)
# return list of sessions that match each of the speaker_keys
return SessionForms(
items=[self._copySessionToForm(sess) for sess in all_sessions]
)
def _createSpeakerObject(self, request):
"""Create or update Speaker object, returning SpeakerForm."""
if not request.name:
raise endpoints.BadRequestException(
"Speaker 'name' field required")
q = Speaker.query()
q = q.filter(Speaker.name == request.name)
if q.count() != 0:
raise endpoints.BadRequestException(
"Speaker already excists")
# copy SpeakerForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name)
for field in request.all_fields()}
# Create session id from parent COnference Key and
# a Session key from that id
s_id = Speaker.allocate_ids(size=1)[0]
s_key = ndb.Key(Speaker, s_id)
data['key'] = s_key
del data['websafeKey']
# Save session and return a SessionForm to the user
Speaker(**data).put()
return self._copySpeakerToForm(s_key.get())
def createSpeaker(self, request):
"""Create Speaker object, returning SpeakerForm/request."""
# preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
if not request.name:
raise endpoints.BadRequestException("Speaker 'name' field required")
if not request.mainEmail:
raise endpoints.BadRequestException("Speaker 'mainEmail' field required")
sp_key = ndb.Key(Speaker, request.mainEmail)
speaker = sp_key.get()
if not speaker:
speaker = Speaker(
key = sp_key,
name = request.name,
mainEmail = request.mainEmail,
)
if request.title:
speaker.title = request.title
if request.bio:
speaker.bio = request.bio
speaker.put()
return request
def _createSpeakerObject(self, request):
"""Create a Speaker object."""
# preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
if not request.firstName:
raise endpoints.BadRequestException(
"Speaker 'firstName' field required")
if not request.lastName:
raise endpoints.BadRequestException(
"Speaker 'lastName' field required")
# copy SpeakerForm Message into dict
data = {field.name: getattr(request, field.name) for field
in request.all_fields()}
# generate Profile Key based on user ID and Speaker
# ID based on Profile key get Speaker key from ID
p_key = ndb.Key(Profile, user_id)
speaker_id = Speaker.allocate_ids(size=1, parent=p_key)[0]
speaker_key = ndb.Key(Speaker, speaker_id, parent=p_key)
data['key'] = speaker_key
del data['speakerWebSafeKey']
# creation Speaker entity
Speaker(**data).put()
return request
def get_by_speaker(self, request):
"""
Given a speaker, return all sessions given by this particular speaker,
across all conferences
:param request:
:return:
"""
if request.name and not request.title:
speakers = Speaker.query(Speaker.name == request.name)
elif not request.name and request.title:
speakers = Speaker.query(Speaker.title == request.title)
else:
speakers = Speaker.query(Speaker.name == request.name) \
.filter(Speaker.title == request.title)
speakers.fetch()
all_sessions = []
if speakers:
for speaker in speakers:
sessions = Session.query(
Session.speakerKeys == speaker.key).fetch()
if sessions:
all_sessions += sessions
return SessionForms(items=self.populate_forms(all_sessions))
def _createSpeakerObject(self, request):
"""Create or update Speaker object, returning SpeakerForm/request."""
# preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
if not request.displayName:
raise endpoints.BadRequestException("Speaker 'displayName' field required")
# copy ConferenceForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
# this is automatically generated for display but should
# be ignored if it is input.
del data['websafeKey']
# Now create the speaker key.
# NOTE: allocate_ids returns a list, so take the first element.
speaker_id = Speaker.allocate_ids(size=1)[0]
speaker_key = ndb.Key(Speaker, speaker_id)
data['key'] = speaker_key
# create Speaker, send email to creator confirming
# creation of Speaker & return (modified) SpeakerForm
Speaker(**data).put()
taskqueue.add(params={'email': user.email(),
'speakerInfo': repr(request)},
url='/tasks/send_speaker_confirmation_email'
)
return request
def _createSpeakerObject(self, request):
"""Create or update Speaker object, returning SpeakerForm."""
if not request.name:
raise endpoints.BadRequestException(
"Speaker 'name' field required")
q = Speaker.query()
q = q.filter(Speaker.name == request.name)
if q.count() != 0:
raise endpoints.BadRequestException("Speaker already excists")
# copy SpeakerForm/ProtoRPC Message into dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
# Create session id from parent COnference Key and
# a Session key from that id
s_id = Speaker.allocate_ids(size=1)[0]
s_key = ndb.Key(Speaker, s_id)
data['key'] = s_key
del data['websafeKey']
# Save session and return a SessionForm to the user
Speaker(**data).put()
return self._copySpeakerToForm(s_key.get())
def _createSpeakerObject(self, request):
user = endpoints.get_current_user()
# Raise an exception if the user is not logged in
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
# Raise an exception if the displayName is not provided
if not request.displayName:
raise endpoints.BadRequestException("dislayName field required")
# Copy SpeakerForm into a dictionary
data = {field.name: getattr(request, field.name)
for field in request.all_fields()}
del data['websafeKey']
# generate Speaker key
sp_id = Speaker.allocate_ids(size=1)[0]
sp_key = ndb.Key(Speaker, sp_id)
data['key'] = sp_key
# Create Speaker and save
sp = Speaker(**data)
sp.put()
return self._copySpeakerToForm(sp)
def _createSpeakerObject(self, request):
"""Create or update Speaker object, returning SpeakerForm/request."""
# preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
# name is a required Speaker field
if not request.name:
raise endpoints.BadRequestException("Speaker 'name' field required")
# copy SpeakerForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) \
for field in request.all_fields()}
del data['websafeKey'] # websafeKey not a Speaker attribute
# allocate Speaker id
s_id = Speaker.allocate_ids(size=1)[0]
s_key = ndb.Key(Speaker, s_id)
data['key'] = s_key
# create Session, send email to organizer confirming
# creation of Session & return (modified) SessionForm
speaker = Speaker(**data)
speaker.put()
return self._copySpeakerToForm(speaker)
def _createSpeakerObject(self, request):
"""Create Speaker object,
returning SpeakerForm/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(
"Speaker 'name' field required")
# copy SpeakerForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) \
for field in request.all_fields()}
del data['websafeKey']
speaker_id = Speaker.allocate_ids(size=1)[0]
speaker_key = ndb.Key(Speaker, speaker_id)
data['key'] = speaker_key
# create Speaker
speaker = Speaker(**data)
speaker.put()
# return the modified SpeakerForm
return self._copySpeakerToForm(speaker)
def _createSpeakerObject(self, request):
"""Create a speaker, returning SpeakerForm/request."""
# Preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = user.email()
if not request.name:
raise endpoints.BadRequestException(
"Speaker 'name' field required")
# Copy SpeakerForm/ProtoRPC Message into dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
del data['websafeKey']
# Add default values for those missing (both data model and
# outbound Message)
for df in SPEAKER_DEFAULTS:
if data[df] in (None, []):
data[df] = SPEAKER_DEFAULTS[df]
# Create Speaker and return SpeakerForm
speaker = Speaker(**data)
speaker.put()
return self._copySpeakerToForm(speaker)
def _getKeyForSpeaker(self, request):
"""
This function gets the key for an existing speaker that has been
requested.
"""
if not request.name:
raise endpoints.BadRequestException("Speaker 'name' field \
required")
# creates new key for Speaker
spkr_key = Speaker().key
# for all noted speakers, make a query
notedSpeakersQuery = Speaker.query()
# lists noted speakers
notedSpeakers = []
for ns in notedSpeakersQuery:
notedSpeakers.append(ns.name)
# When no speaker is found with a name, a NotFoundException is raised.
if request.name not in notedSpeakers:
raise endpoints.NotFoundException(
'No speaker found with name: %s'
% request.name)
# Otherwise, have its key returned.
else:
spkr_key = Speaker.query(Speaker.name == request.name).get().key
return spkr_key
def _createSpeakerObject(self, request):
"""Create Speaker object, returning SpeakerForm/request."""
# preload necessary data items
user = endpoints.get_current_user()
# make sure user is authenticated
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
# make sure session name is entered
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()}
# generate Speaker Key based on Profile key and
# profile ID
p_key = ndb.Key(Profile, user_id)
s_id = Speaker.allocate_ids(size=1, parent=p_key)[0]
s_key = ndb.Key(Speaker, s_id, parent=p_key)
data['key'] = s_key
# save form data to datastore
Speaker(**data).put()
# create Speaker & return (modified) SpeakerForm
return request
def _createSpeakerObject(self, request):
"""Create Speaker object, returning SpeakerForm/request."""
# Need to be logged in to create a speaker entity
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException("Authorization required")
user_id = getUserId(user)
# Speaker name is a required property
if not request.name:
raise endpoints.BadRequestException("Speaker 'name' field required")
# Copy SpeakerForm/ProtoRPC Message into dictionary
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
del data["websafeKey"]
# Make the logged in user the parent of the Speaker object.
p_key = ndb.Key(Profile, user_id)
s_id = Speaker.allocate_ids(size=1, parent=p_key)[0]
s_key = ndb.Key(Speaker, s_id, parent=p_key)
data["key"] = s_key
# Create the Speaker entity in the datastore
new_speaker = Speaker(**data)
new_speaker.put()
return self._copySpeakerToForm(new_speaker)
def _createSpeakerObject(self, request):
"""Create Speaker object, returning SpeakerForm."""
# check for auth'ed and valid user
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
# Speaker name must be filled
if not request.name:
raise endpoints.BadRequestException("Field 'name' required")
# copy SpeakerForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
# allocate new Speaker ID
s_id = Speaker.allocate_ids(size=1)[0]
# make Speaker key from ID
s_key = ndb.Key(Speaker, s_id)
data['key'] = s_key
# create Speaker & return SpeakerForm
speaker = Speaker(**data)
speaker.put()
return self._copySpeakerToForm(speaker)
def addSpeaker(self, request):
"""Get profile from user, take field info for all fields, give key and put into datastore"""
prof=self._getProfileFromUser()
data={field.name:getattr(request, field.name) for field in request.all_fields()}
del data['websafeKey']
speaker=Speaker(**data)
speaker.put()
return self._copySpeakerToForm(speaker)
def _createSessionObject(request, conference):
"""Create or update Session object, returning SessionForm/request."""
# preload necessary data items
if not request.name:
raise endpoints.BadRequestException("Session 'name' field required")
speaker_wskey = None
if not request.speakerWSKey:
if request.speakerName:
speaker = Speaker.query(Speaker.name == request.speakerName).get()
if speaker:
speaker_wskey = speaker.key.urlsafe()
else:
speaker_id = Speaker.allocate_ids(size=1)[0]
speaker_key = ndb.Key(Speaker, speaker_id)
speaker_wskey = speaker_key.urlsafe()
speaker = Speaker(**{'key': speaker_key,'name': request.speakerName})
speaker.put()
else:
raise endpoints.BadRequestException("Session speaker required")
else:
speaker_wskey = request.speakerWSKey
# copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
del data['sessionWSKey']
del data['speakerWSKey']
del data['speakerName']
del data['conferenceWSKey']
del data['startDateHour']
print '1:' + str(data.keys())
# add default values for those missing (both data model & outbound Message)
for df in SESSION_DEFAULTS:
if data[df] in (None, []):
data[df] = SESSION_DEFAULTS[df]
setattr(request, df, SESSION_DEFAULTS[df])
# convert dates from strings to Date objects; set month based on start_date
if data['startDate'] and isinstance(data['startDate'], types.StringType):
data['startDate'] = datetime.strptime(data['startDate'][:10], "%Y-%m-%d").datetime()
session_id = Session.allocate_ids(size=1, parent=conference.key)[0]
session_key = ndb.Key(Session, session_id, parent=conference.key)
data['key'] = session_key
data['speakerKey'] = speaker_wskey
# create Session, send email to organizer confirming creation of Session & return (modified) SessionForm
session = Session(**data)
session.put()
# taskqueue.add(params={'email': user.email(), 'conferenceInfo': repr(request)}, url='/tasks/send_confirmation_email')
return session
def createSpeaker(self, request):
"""Create a speaker."""
if not request.name:
raise endpoints.BadRequestException(
"Speaker 'name' field required")
speaker = Speaker(name=request.name)
key = speaker.put().urlsafe() # for debugging
print(key) # for debugging
return SpeakerForm(name=request.name, websafeKey=key)
def create_speaker(self, request):
"""Create a new speaker."""
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException("Authorization required.")
speaker = Speaker(name=request.name)
speaker.put()
return speaker.to_message()
def _createSpeakerObject(self, data):
"""Create Speaker object, return Speaker key"""
# allocate new Speaker ID
speaker_id = Speaker.allocate_ids(size=1)[0]
# make Speaker key fom ID
speaker_key = ndb.Key(Speaker, speaker_id)
# Create Speaker and return Speaker key
speaker = Speaker(name=data,
key=speaker_key)
speaker.put()
return speaker_key
def _createSpeakerObject(self, request):
"""Create or update a Speaker object, returning SpeakerForm/request.
In this version, any user can create a speaker, this allows speakers
to be reused for different conferences"""
# check for required field
if not request.name:
raise endpoints.BadRequestException("Speaker 'name' field required")
# create Speaker & return SpeakerForm
speaker = Speaker(name=request.name, organisation=request.organisation)
speaker.put()
return self._copySpeakerToForm(speaker)
def _createSpeakerObject(self, request):
speaker_id = request.mainEmail
sp_key = ndb.Key(Speaker, speaker_id)
speaker = Speaker(
key=sp_key,
name=request.name,
mainEmail=request.mainEmail,
phone=request.phone,
)
speaker.put()
return request
def _createSpeakerObject(self, request):
speaker_id = request.mainEmail
sp_key = ndb.Key(Speaker, speaker_id)
speaker = Speaker(
key=sp_key,
name=request.name,
mainEmail=request.mainEmail,
phone=request.phone,
)
speaker.put()
return request
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 speakers speakers = [x.to_json(encode = False) for x in Speaker.get_all()] self.set_body(json.dumps(speakers)) else: speaker = Speaker.get(id) self.set_body(speaker.to_json()) return self.render()
def test_add_talk_to_speaker(self):
s = Speaker(name = 'Jimi Hendrix',
slug = 'jimi-hendrix',
url = 'http://jimi.hendrix.com')
s.save()
t = Talk(title = 'First Talk',
start_time = '15:00')
t.save()
s.talk_set.add(t)
self.assertQuerysetEqual(s.talk_set.all(),
['<Talk: First Talk>'])
self.assertQuerysetEqual(t.speakers.all(),
['<Speaker: Jimi Hendrix>'])
def test_create_speaker(self):
s = Speaker(name = 'Bob Marley',
slug = 'bob-marley',
url = 'http://bobmarley.com')
s.save()
ce = Contact(kind='E', value='*****@*****.**')
cf = Contact(kind='F', value='11-5555-9999')
cp = Contact(kind='P', value='11-5555-8888')
s.contact_set.add(ce)
s.contact_set.add(cf)
s.contact_set.add(cp)
self.assertQuerysetEqual(s.contact_set.all().order_by(),
['<Contact: E, [email protected]>',
'<Contact: F, 11-5555-9999>',
'<Contact: P, 11-5555-8888>'])
def _createSpeakerObject(self, request):
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
# copy SpeakerForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
del data["sessionKeysToAttend"]
data["key"] = ndb.Key(Speaker, data["email"])
# create Speaker entity
# creation of Speaker & return new Speaker form
speaker = Speaker(**data).put()
return self._copySpeakerToForm(speaker.get())
def speakerQuery(self, request):
"""Return speakers by email, name, or query all if no criteria specified."""
# should only return one speaker
if request.email:
speakers = Speaker.query(Speaker.email == request.email)
# can return multiple
elif request.name:
speakers = Speaker.query(Speaker.name == request.name)
# returns all if no email or name specified
else:
speakers = Speaker.query()
# return set of SpeakerForm objects per speaker matched
return SpeakerForms(
items=[self._copySpeakerToForm(speaker) for speaker in speakers]
)
def _copySessionToForm(self, session, name=None):
"""Copy relevant fields from Session to SessionForm."""
sf = SessionForm()
for field in sf.all_fields():
if hasattr(session, field.name):
if field.name == "dateTime":
s_date = getattr(session, field.name)
if s_date:
setattr(sf, 'dateTime', s_date.strftime('%y-%m-%d'))
setattr(sf, 'startTime', s_date.strftime('%H:%M'))
elif field.name == "speaker":
speakerID = getattr(session, field.name)
# get speaker object if there is one assigend
if speakerID == None:
setattr(sf, 'speakerDisplayName', 'NONE ASSIGNED')
else:
speak = Speaker.get_by_id(speakerID)
setattr(sf, 'speakerDisplayName', speak.name)
#set typeOfSession
#if there is no typeOfSession then set it to 'NOT_SPECIFIED'
elif field.name == "typeOfSession":
currentType = getattr(session, field.name)
if currentType:
setattr(sf, field.name,
getattr(SessionType, str(currentType)))
else:
setattr(sf, field.name,
getattr(SessionType, 'NOT_SPECIFIED'))
else:
setattr(sf, field.name, getattr(session, field.name))
sf.check_initialized()
return sf
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))
def _createSpeakerObject(self, request):
"""Create a Speaker object, returning SpeakerForm/request."""
# Ensure that the current user is logged in and get user ID
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
# Verify that a name was provided for the speaker
if not request.name:
raise endpoints.BadRequestException(
"Speaker 'name' field required")
# Copy SpeakerForm/ProtoRPC Message into dict
data = ({
field.name: getattr(request, field.name)
for field in request.all_fields()
})
# Create a key for the Speaker
s_id = Session.allocate_ids(size=1)[0]
s_key = ndb.Key(Speaker, s_id)
# Update stored session with session keys
data['key'] = s_key
# create Session, send email to organizer confirming
# creation of Session & return (modified) SessionForm
Speaker(**data).put()
taskqueue.add(params={
'email': user.email(),
'subject': 'You Added %s as a Speaker!' % data['name'],
'body': 'Here are the details for the added speaker:',
'info': repr(request)
},
url='/tasks/send_confirmation_email')
return request
def _copySessionToForm(self, session, name=None):
"""Copy relevant fields from Session to SessionForm."""
sf = SessionForm()
for field in sf.all_fields():
if hasattr(session, field.name):
if field.name == "dateTime":
s_date = getattr(session,field.name)
if s_date:
setattr(sf, 'dateTime', s_date.strftime('%y-%m-%d'))
setattr(sf, 'startTime', s_date.strftime('%H:%M'))
elif field.name == "speaker":
speakerID = getattr(session,field.name)
# get speaker object if there is one assigend
if speakerID == None:
setattr(sf, 'speakerDisplayName', 'NONE ASSIGNED')
else:
speak = Speaker.get_by_id(speakerID)
setattr(sf, 'speakerDisplayName', speak.name)
#set typeOfSession
#if there is no typeOfSession then set it to 'NOT_SPECIFIED'
elif field.name == "typeOfSession":
currentType = getattr(session,field.name)
if currentType:
setattr(sf, field.name, getattr(SessionType,
str(currentType)))
else:
setattr(sf, field.name, getattr(SessionType,
'NOT_SPECIFIED'))
else:
setattr(sf, field.name, getattr(session,field.name))
sf.check_initialized()
return sf
def _createSpeakerObject(self, request):
"""Create or update Speaker object, returning Speaker/request."""
# preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
if not request.name:
raise endpoints.BadRequestException(
"Speaker 'name' field required")
# copy Speaker/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) \
for field in request.all_fields()}
del data['websafeKey']
# add defaults for missing values (both data model & outbound Message)
for df in DEFAULTS_SPEAKER:
if data.get(df, None) is None:
data[df] = DEFAULTS_SPEAKER[df]
setattr(request, df, DEFAULTS_SPEAKER[df])
# create Speaker and return updated SpeakerForm with websafeKey
request.websafeKey = Speaker(**data).put().urlsafe()
return request
def _createSessionObject(self, 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")
conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
# Check that user trying to Create the Session is the Owner of the Conference.
if conf.organizerUserId != user_id:
raise endpoints.BadRequestException(
"You must be the Owner of the Conference to Create a Session")
# copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name)
for field in request.all_fields()}
del data['websafeConferenceKey']
# convert dates from strings to Date objects;
if data['date']:
data['date'] = datetime.strptime(
data['date'][:10], "%Y-%m-%d").date()
# make Parent Key from Conference ID
parent_key = ndb.Key(Conference, conf.key.id())
# allocate new Session ID with Conference key as parent
s_id = Session.allocate_ids(size=1, parent=parent_key)[0]
# make Session key from ID
s_key = ndb.Key(Session, s_id, parent=parent_key)
data['key'] = s_key
# Check to see if the Speakers email already present in Datastore,
# Then adds this Session key to Speakers list of Sessions to Speak at.
if data['speakersEmail']:
oneSpeaker = Speaker.query(Speaker.mainEmail == data['speakersEmail'])
oneSpeaker = oneSpeaker.get()
oneSpeaker.sessionsToSpeak.append(s_key.urlsafe())
oneSpeaker.put()
del data['speakersEmail']
Session(**data).put()
# Check if there is a speaker, if so run the featuredspeaker task.
if data['speaker']:
taskqueue.add(
params={
'websafeConferenceKey': request.websafeConferenceKey,
'speaker': data['speaker']},
method='GET',
url='/tasks/featuredSpeaker')
return request
def querySpeakers(self, request):
"""Query for Speakers."""
speakers = Speaker.query().fetch()
# return Speakers
return SpeakerForms(
items=[self._copySpeakerToForm(speaker) for speaker in speakers]
)
def _createSpeakerObject(self, request):
"""Create a Speaker object, returning SpeakerForm/request."""
# Getting and Verifying current user
user = getUser()
# Confirm the field is filled out
checkField(request.name, 'name')
# Copy SpeakerForm/ProtoRPC Message into dict
data = ({field.name: getattr(request, field.name)
for field in request.all_fields()})
# Create a key for the Speaker
s_id = Session.allocate_ids(size=1)[0]
s_key = ndb.Key(Speaker, s_id)
# Update stored session with session keys
data['key'] = s_key
# Create and update session and return the form
Speaker(**data).put()
taskqueue.add(
params = {
'email' : user.email(),
'subject' : 'You Added %s as a Speaker!' % data['name'],
'body' : 'Here are the details for the added speaker:',
'info' : repr(request)},
url = '/tasks/send_confirmation_email')
return request
def getSpeakers(self, request):
"""Returns list of speakers"""
speakers = Speaker.query()
# Return set of SpeakerForm objects
return SpeakerForms(
speakers=[self._copySpeakerToForm(s) for s in speakers])
def post(self, id = None): request = self.wsgi_request response = self.wsgi_response c = self.context param_dict = dict( first_name = request.params.first_name, last_name = request.params.last_name, desc = request.params.desc, twitter_handle = request.params.twitter_handle) content = param_dict speaker = Speaker(**param_dict) speaker = speaker.save() self.set_body(speaker.to_json()) response.headers['content-type'] = 'application/json' return self.render()
def _createSpeakerObject(self, name):
"""Create or update Speaker object,\
returning SpeakerForm/request."""
sp_key = ndb.Key(Speaker, name)
speaker = sp_key.get()
if not speaker:
speaker = Speaker(
key=sp_key,
name=name,
details='',
)
speaker.put()
return speaker
def _createSessionObject(self, 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")
conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
# Check that user trying to Create the Session is the Owner of the Conference.
if conf.organizerUserId != user_id:
raise endpoints.BadRequestException(
"You must be the Owner of the Conference to Create a Session")
# copy SessionForm/ProtoRPC Message into dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
del data['websafeConferenceKey']
# convert dates from strings to Date objects;
if data['date']:
data['date'] = datetime.strptime(data['date'][:10],
"%Y-%m-%d").date()
# make Parent Key from Conference ID
parent_key = ndb.Key(Conference, conf.key.id())
# allocate new Session ID with Conference key as parent
s_id = Session.allocate_ids(size=1, parent=parent_key)[0]
# make Session key from ID
s_key = ndb.Key(Session, s_id, parent=parent_key)
data['key'] = s_key
# Check to see if the Speakers email already present in Datastore,
# Then adds this Session key to Speakers list of Sessions to Speak at.
if data['speakersEmail']:
oneSpeaker = Speaker.query(
Speaker.mainEmail == data['speakersEmail'])
oneSpeaker = oneSpeaker.get()
oneSpeaker.sessionsToSpeak.append(s_key.urlsafe())
oneSpeaker.put()
del data['speakersEmail']
Session(**data).put()
# Check if there is a speaker, if so run the featuredspeaker task.
if data['speaker']:
taskqueue.add(params={
'websafeConferenceKey': request.websafeConferenceKey,
'speaker': data['speaker']
},
method='GET',
url='/tasks/featuredSpeaker')
return request
def allSpeakers(self, request):
"""Get all registered speakers"""
speakers = Speaker.query()
return SpeakerForms(
items=[self._copySpeakerToForm(speaker) for speaker in speakers]
)
def getAllSpeakers(self, request):
"""Return all speakers."""
speakers = Speaker.query()
return SpeakerForms(
items=[self._copySpeakerToForm(speaker) for speaker in speakers]
)
def createSpeaker(self, request):
"""Create new speaker"""
# check for required fields
if not request.name:
raise endpoints.BadRequestException(
"Speaker 'name' field required")
# create speaker
speaker = Speaker(
name=request.name.title(
), #store in fixed title case for case-independent string request later
bio=request.bio)
speaker.put()
# return SpeakerForm
return self._copySpeakerToForm(speaker)
def _getSpeaker(self, email):
# Create a new key of kind Speaker from the id.
s_key = ndb.Key(Speaker, email)
# Get the entity from datastore by using get() on the key
speaker = s_key.get()
# If speaker doesn't exist, we create a new one
if not speaker:
speaker = Speaker(
key=s_key,
email=email, # e-mail is enough, no name to store
)
# Save the speaker to datastore
speaker.put()
return speaker # return Speaker
def add_speakers(payload):
body = request.get_json()
new_name = body.get("event", None)
new_expertise = body.get("event_date", None)
if body is None:
abort(400)
try:
speaker = Speaker(name=new_name, expertise=new_expertise)
speaker.insert()
return jsonify({"success": True, "created": speaker})
except Exception:
abort(422)
def getSpeakers(self, request):
"""Create Speaker object, returning SpeakerForm/request."""
speakers = Speaker.query()
# return set of SpeakerForm objects per Speaker
return SpeakerForms(
items=[self._copySpeakerToForm(speaker) for speaker in speakers]
)
def _getSpeakers(self, request, nameFilter=None):
""" Return speakers, with the option to filter on name
"""
speakers = Speaker.query()
if nameFilter:
speakers.filter(Speaker.name == nameFilter)
return SpeakerForms(
items=[self._copySpeakerToForm(speaker) for speaker in speakers])
def getSpeakers(self, request):
"""Return all the speakers."""
# create ancestor query for all key matches for this conference
speakers = Speaker.query()
# return set of ConferenceForm objects per Conference
return SpeakerForms(
items=[self._copySpeakerToForm(speaker) for speaker in speakers]
)
def _createSpeakerObject(self, request):
"""
Creates a Speaker entity in datastore based on the information provided
by client.
Sends a confirmation email after adding the new Speaker
"""
# 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("Speaker 'name' \
field required")
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
del data['websafeSpeakerKey']
# create Speaker & return (modified) SpeakerForm
speaker_key = Speaker(**data).put()
taskqueue.add(params={
'email': user.email(),
'speakerInfo': repr(request)
},
url='/tasks/send_speaker_confirmation_email')
# Return data as SpeakerForm
speakerform = SpeakerForm()
for field in speakerform.all_fields():
if data.has_key(field.name):
setattr(speakerform, field.name, data[field.name])
# Checks if the field is websafeSpeakerKey, then converts it into
# urlsafe key
elif field.name == "websafeSpeakerKey":
setattr(speakerform, field.name, speaker_key.urlsafe())
speakerform.check_initialized()
return speakerform
def __prepare_speaker(speaker_form):
"""
Handle updating Speaker records and their session counts
:param speaker_form: SpeakerForm
:return: Speaker with updates ready to be put()
"""
if not isinstance(speaker_form, SpeakerForm):
raise TypeError('expected %s, but got %s' %
(SpeakerForm, speaker_form))
speaker = Speaker.query(Speaker.name == speaker_form.name) \
.filter(Speaker.title == speaker_form.title) \
.get()
if speaker:
speaker.numSessions += 1
else:
speaker = Speaker.from_form(speaker_form)
speaker.numSessions = 1
return speaker
def querySpeaker(self, request):
"""Queries all speakers with the name and or organization provided."""
q = Speaker.query()
q = q.filter(Speaker.speaker == request.speaker)
# if an organization query is provided, query speaker by organization
if request.organization:
q = q.filter(Speaker.organization == request.organization)
return SpeakerForms(items=[self._copySpeakerToForm(s) for s in q])
def _createSpeakerObject(self, request):
""" Create or update Speaker object, returning SpeakerForm
"""
if not request.name:
raise endpoints.BadRequestException(
"Session 'name' field required")
# copy SpeakerForm/ProtoRPC Message into dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
del data['websafeKey']
s_id = Speaker.allocate_ids(size=1)[0]
s_key = ndb.Key(Speaker, s_id)
data['key'] = s_key
spkr_key = Speaker(**data).put()
return self._copySpeakerToForm(spkr_key.get())
