def _createSpeakerObject(self, request):
"""Create speaker object, returning speakerForm/request."""
# check the required fields and throw exception is not set
if not request.firstName:
raise endpoints.BadRequestException(
"Session 'firstName' field required")
if not request.familyName:
raise endpoints.BadRequestException(
"Session 'familyName' field required")
# copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name)
for field in request.all_fields()}
del data['websafeKey']
# generate an ndb key for the new Speaker entry
s_id = Speaker.allocate_ids(size=1)[0]
s_key = ndb.Key(Speaker, s_id)
data['key'] = s_key
# create Speaker & return SpeakerForm
Speaker(**data).put()
return request
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 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 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 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 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 _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):
"""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 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 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/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):
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 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 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)
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']
# generate Profile Key based on user ID and Speaker
# ID based on Profile key get Speaker key from ID
s_id = Speaker.allocate_ids(size=1)[0]
s_key = ndb.Key(Speaker, s_id)
data['key'] = s_key
# creation of Speaker & return (modified) SpeakerForm
Speaker(**data).put()
return self._copySpeakerToForm(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 _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 _createSpeakerObject(self, request):
s_id = Speaker.allocate_ids(size=1)[0]
s_key = ndb.Key(Speaker, s_id)
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
if not data["name"]:
raise endpoints.BadRequestException("Speaker 'name' field required")
del data["websafeKey"]
data["key"] = s_key
Speaker(**data).put()
return self._copySpeakerToForm(ndb.Key(Speaker, s_id).get())
def _createSpeaker(self, request):
"""Creates a new Speaker and converts it to a SpeakerForm"""
speaker = {field.name: getattr(request, field.name) for field in request.all_fields()}
del speaker["websafeSpeakerKey"]
# Generate a unique key for the speaker
s_id = Speaker.allocate_ids(size=1)[0]
s_key = ndb.Key(Speaker, s_id)
speaker["key"] = s_key
Speaker(**speaker).put()
return self.toSpeakerForm(request, None, s_key.urlsafe())
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 Speaker object, returning SpeakerForm/request."""
# copy SpeakerForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
del data["websafeKey"]
# allocate new Speaker ID
speakerId = Speaker.allocate_ids(size=1)[0]
# make Speaker key from ID
speakerKey = ndb.Key(Speaker, speakerId)
data["key"] = speakerKey
# create Speaker
Speaker(**data).put()
return self._copySpeakerToForm(speakerKey.get())
def _createSpeakerObject(self, request):
user = endpoints.get_current_user()
# check if user is authrorized and displayName is presented
if not user:
raise endpoints.UnauthorizedException('Authorization required')
if not request.displayName:
raise endpoints.BadRequestException("Speaker 'displayName' field required")
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
del data['websafeKey']
sp_id = Speaker.allocate_ids(size=1)[0]
sp_key = ndb.Key(Speaker, sp_id)
data['key'] = sp_key
# save data
sp = Speaker(**data)
sp.put()
return self._copySpeakerToForm(sp)
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())
def _createSpeakerObject(self, request):
"""Create or update Speaker object, returning SpeakerForms."""
# preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
# confirm required fields
if not request.displayName:
raise endpoints.BadRequestException(
"Speaker 'displayName' field required")
# Check for existing Speaker created by that user
# with the requested displayName
p_key = ndb.Key(Profile, user_id)
exist_speak = Speaker.query(
Speaker.displayName == request.displayName, ancestor=p_key).get()
if exist_speak:
raise endpoints.ConflictException(
"That speaker name already exists.")
# copy SpeakerForm/ProtoRPC Message into dict
data = {field.name: getattr(
request, field.name) for field in request.all_fields()}
del data['websafeKey']
del data['creatorUserId']
# make Profile Key from user ID
p_key = ndb.Key(Profile, user_id)
# allocate new Speaker ID with User key as parent
s_id = Speaker.allocate_ids(size=1, parent=p_key)[0]
# make Speaker key from ID
sp_key = ndb.Key(Speaker, s_id, parent=p_key)
data['key'] = sp_key
# create Speaker, send email to organizer confirming
# creation of Speaker & return (modified) SpeakerForm
Speaker(**data).put()
spk = sp_key.get()
return self._copySpeakerToForm(speak=spk)
def _createSpeakerObject(self, request):
"""Create or update a Speaker object"""
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()}
s_id = Speaker.allocate_ids(size=1)[0]
s_key = ndb.Key(Speaker, s_id)
data['key'] = s_key
Speaker(**data).put()
return request
def createSpeaker(self, request):
"""Create a new spaeker form with provided speaker name and
organization"""
# make sure user is logged in.
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
# copy request data into a dictionary.
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
# get a key for the speaker.
speaker_id = Speaker.allocate_ids(size=1)[0]
speaker_key = ndb.Key(Speaker, speaker_id)
data['key'] = speaker_key
new_speaker = Speaker(**data)
new_speaker.put()
return self._copySpeakerToForm(new_speaker)
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())
def createSpeaker(self, request):
""" Create a speaker """
# Make sure the user is logged in.
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required.')
user_id = getUserId(user)
user_key = ndb.Key(Profile, user_id)
# Create the Speaker object
speaker = Speaker()
# Copy the fields from the request to the Speaker
speaker = message_to_ndb(request, speaker)
# Allocate the Speaker id and set the key with the User as parent
speaker_id = speaker.allocate_ids(size=1, parent=user_key)[0]
speaker.key = ndb.Key(Speaker, speaker_id, parent=user_key)
# Write the speaker to the db
speaker.put()
# Create a SpeakerForm and copy the fields from the request
speaker_form = SpeakerForm()
speaker_form = ndb_to_message(speaker, speaker_form)
# Send back the SpeakerForm including the websafe key
return speaker_form
def _createSpeakerObject(self, request):
"""Create SpeakerObject"""
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException("Authorization required")
if not request.fullName:
raise endpoints.BadRequestException("Speaker's 'fullName' field required")
# copy ConferenceForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
del data["websafeKey"]
sp_id = Speaker.allocate_ids(size=1)[0]
sp_key = ndb.Key(Speaker, sp_id)
data["key"] = sp_key
# create Conference, send email to organizer confirming
# creation of Conference & return (modified) ConferenceForm
Speaker(**data).put()
return self._copySpeakerToForm(request)
def _createSpeakerObject(self, request):
"""Create or update Speaker object, returning Speaker/request."""
if not request.name:
raise endpoints.BadRequestException("Speaker '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"]
# TODO
# add default values for those missing
# for df in DEFAULTS:
# if data[df] in (None, []):
# data[df] = DEFAULTS[df]
# setattr(request, df, DEFAULTS[df])
# ID based on Speaker key
s_id = Speaker.allocate_ids(size=1)[0]
s_key = ndb.Key(Speaker, s_id)
data["key"] = s_key
# create Speaker
Speaker(**data).put()
return request
def addSpeaker(self, request):
"""Add speaker"""
# verify user is authed
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
# generate unique id for speaker
s_id = Speaker.allocate_ids(size=1)[0]
s_key = ndb.Key(Speaker, s_id)
# save into datastore
speaker = Speaker(key=s_key, displayName=request.displayName)
speaker_key = speaker.put()
# get speaker urlsafe string
s_uss = speaker_key.urlsafe()
if not s_uss:
raise endpoints.NotFoundException(
'Unable to get speakerKey from Datastore')
return SpeakerForm(speakerKey=s_uss)
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')
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()}
# generate Speaker Key based on system allocated Speaker ID
speaker_id = Speaker.allocate_ids(size=1)
speaker_key = ndb.Key(Speaker, speaker_id[0])
data['key'] = speaker_key
# creation of Speaker & return (modified) SpeakerForm
Speaker(**data).put()
return request
def addSpeaker(self, request):
"""Add speaker"""
# verify user is authed
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
# generate unique id for speaker
s_id = Speaker.allocate_ids(size=1)[0]
s_key = ndb.Key(Speaker, s_id)
# save into datastore
speaker = Speaker(key=s_key, displayName=request.displayName)
speaker_key = speaker.put()
# get speaker urlsafe string
s_uss = speaker_key.urlsafe()
if not s_uss:
raise endpoints.NotFoundException(
'Unable to get speakerKey from Datastore')
return SpeakerForm(speakerKey=s_uss)
def _createSpeakerObject(self, request):
"""Create or update Speaker object"""
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = _getUserId()
if not request.displayName:
raise endpoints.BadRequestException("Speaker 'diplayName' field required")
# copy SpeakerForm/ProtoRPC Message into dict
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
Speaker(**data).put()
return request
def _createSpeakerObject(self, request):
"""Create or update a Speaker object"""
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()
}
s_id = Speaker.allocate_ids(size=1)[0]
s_key = ndb.Key(Speaker, s_id)
data['key'] = s_key
Speaker(**data).put()
return request
def createSpeaker(self, request):
"""Create a new spaeker form with provided speaker name and
organization"""
# make sure user is logged in.
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
# copy request data into a dictionary.
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
# get a key for the speaker.
speaker_id = Speaker.allocate_ids(size=1)[0]
speaker_key = ndb.Key(Speaker, speaker_id)
data['key'] = speaker_key
new_speaker = Speaker(**data)
new_speaker.put()
return self._copySpeakerToForm(new_speaker)
def _createSessionObject(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(
"Session 'name' field required")
# Check that the current user is the conference organizer
c_key = ndb.Key(urlsafe=request.websafeConferenceKey)
conf = c_key.get()
if user_id != conf.organizerUserId:
raise endpoints.UnauthorizedException(
'Only the conference organizer may add a session')
# copy SessionForm/ProtoRPC Message into dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
del data['websafeConferenceKey'] # elements of form but not session
del data['websafeSessionKey']
del data['conferenceName']
# performing this step once we're done with this data item:
# del data['speakerName']
# convert date from strings to Date objects
if data['date']:
data['date'] = datetime.strptime(data['date'][:10],
"%Y-%m-%d").date()
# convert time from strings to Time objects
if data['startTime']:
data['startTime'] = self._stringToTime(data['startTime'])
# generate Conference Key based on conference ID, and Session
# ID based on Conference key. get Session key from ID
# already obtained the conference key
sess_id = Session.allocate_ids(size=1, parent=c_key)[0]
sess_key = ndb.Key(Session, sess_id, parent=c_key)
data['key'] = sess_key
# set conferenceKey. not assumed it comes in with the request
# this data field no longer part of SessionForm
# data['conferenceKey'] = request.conferenceKey = request.websafeConferenceKey
# create or update speaker with session
speak_q = Speaker.query()
speak_q = speak_q.filter(Speaker.name == data['speakerName'])
speak = speak_q.get()
if not speak:
# create the speaker
speak_id = Speaker.allocate_ids(size=1)[0]
speak_data = {}
speak_data['key'] = ndb.Key(Speaker, speak_id)
speak_data['name'] = data['speakerName']
speak_data['sessionKeysToSpeak'] = [
sess_key
] # DEBUG store key not websafe key
speak = Speaker(**speak_data)
else:
# add the session to the speaker
speak.sessionKeysToSpeak.append(sess_key)
# done with this data item and is not part of Session
del data['speakerName']
# speaker key belongs in Session
data['speakerKey'] = speak.key
# this statement appears later; session should be put first
# speak.put()
# create Session, create memcache entry if speaker
# has > 1 session at Conference & return (copied) SessionForm
sess = Session(**data)
sess.put()
speak.put() # only commit speaker if session successful
# TODO memcache entry as described above
speak_wkey = speak.key.urlsafe()
conf_wkey = request.websafeConferenceKey
taskqueue.add(params={'sess_wkey': sess_key.urlsafe()},
url='/tasks/set_featured_speaker')
return self._copySessionToForm(sess, conf.name,
speak.name) # formerly request
def _createSessionObject(self, request):
"""Create Session object, returning SessionForm/request."""
# user must be logged in to create session
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")
if not request.websafeConferenceKey:
raise endpoints.BadRequestException("websafeConferenceKey required")
conf = ndb.Key(urlsafe = request.websafeConferenceKey).get()
if not conf:
raise endpoints.NotFoundException("No conference exists with websafe key %s"
% request.websafeConferenceKey)
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenExeption("Only conference creator can add sessions")
# copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
del data['websafeConferenceKey']
del data['websafeKey']
speaker = Speaker.query(Speaker.name == request.speaker).get()
check_featured = False
if not speaker:
spkr_id = Speaker.allocate_ids(size = 1)[0]
spkr_key = ndb.Key(Speaker, spkr_id)
data['speaker'] = Speaker(name = request.speaker).put()
else:
data['speaker'] = speaker.key
check_featured = True
# convert dates from strings to Date objects
if data['date']:
data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d").date()
# generate Profile Key based on user ID and Conference
# ID based on Profile key get Conference key from ID
c_key = ndb.Key(urlsafe = request.websafeConferenceKey)
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
# create Session
Session(**data).put()
if check_featured:
# The method that checks whether to feature a speaker uses an ancestor
# query, which should guarantee strong consistency. Adding the push
# task after the put() guarantees the new session will show up in that
# query.
taskqueue.add(params = {'speaker': speaker.key.urlsafe(),
'conf': conf.key.urlsafe()},
url='/tasks/set_featured_speaker')
sess = s_key.get()
return self._copySessionToForm(sess)
def _createSessionObject(self, request):
"""Create or update Session object, returning SessionForm/request."""
# Get the user saved in session
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")
c_key = ndb.Key(urlsafe=request.websafeConfKey)
# Check that the name is unique within the conference
name_check = Session.query(ancestor=c_key)
name_check = name_check.filter(Session.name==request.name).get()
if name_check:
raise endpoints.BadRequestException(
"Entity with name '%s' already exists" % request.name)
# Check that the conference exists
conf = c_key.get()
if not conf:
raise endpoints.NotFoundException(
'No conf with key: %s' % request.websafeConferenceKey)
# Check that the user is the conference organizer
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
'Only the organizer may update the conference')
# Copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name)
for field in request.all_fields()}
# Delete unnecessary fields from the form
del data['displayName']
del data['websafeConfKey']
del data['sessionKey']
# Convert date from string into Date object;
if data['date']:
data['date'] = datetime.strptime(
data['date'][:10], "%Y-%m-%d").date()
# Convert times from string into Time objects
if data['startTime']:
data['startTime'] = datetime.strptime(
data['startTime'][:5], "%H:%M").time()
if data['duration']:
try:
datetime.strptime(
data['duration'][:5], "%H:%M").time()
except:
raise endpoints.BadRequestException("Duration Must be in 'HH:MM' format")
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
if data['speaker']:
print 'In createSession, there is a speaker...'
# Check to see if the speaker already exists
speaker = Speaker.query(Speaker.name == data['speaker']).get()
# If the speaker doesn't exist, create a Speaker entity for them
if not speaker:
speaker_id = Speaker.allocate_ids(size=1)[0]
speaker_key = ndb.Key(Speaker, speaker_id)
speaker = Speaker()
speaker.populate(
key=speaker_key,
name=data['speaker']
)
speaker.put()
else:
speaker_key = speaker.key
# Set the session speaker to the speaker's urlsafe key
data['speaker'] = speaker_key.urlsafe()
#Put the session in the database
Session(**data).put()
# Use the TaskQueue to check whether the new session's
# speaker should be the next featured speaker.
taskqueue.add(
params={'sessionKey': s_key.urlsafe()},
url='/tasks/set_featured_speaker'
)
else:
#Put the session in the database
Session(**data).put()
return request
def _create_session_object(self, request):
"""Create the session object and put into datastore"""
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
c_key = ndb.Key(urlsafe=request.websafeConferenceKey)
conference = c_key.get()
# Do checks
if user_id != conference.organizerUserId:
raise endpoints.BadRequestException("Current user not authorised to add session for this conference")
if not request.name:
raise endpoints.BadRequestException("Session 'name' field required")
if not request.durationMinutes:
raise endpoints.BadRequestException("Session 'durationMinutes' field required")
if not request.date:
raise endpoints.BadRequestException("Session 'date' field required")
if not request.startTime:
raise endpoints.BadRequestException("Session 'startTime' field required")
# copy request into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
del data['websafeConferenceKey']
del data['websafeKey']
s_id = Session.allocate_ids(size=1, parent=c_key)
s_key = ndb.Key(Session, s_id[0], parent=c_key)
data['key'] = s_key
if data['date']:
data['date'] = datetime.strptime(data['date'][:10], '%Y-%m-%d').date()
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'], '%H:%M').time()
# create Session
session = Session(**data).put()
# get the newly created Session so we can pass back the websafeKey
new_session = session.get()
if data['speaker']:
try:
speaker = Speaker.query(Speaker.name == data['speaker']).fetch()[0]
except:
speaker_id = Speaker.allocate_ids(size=1, parent=s_key)
speaker_key = ndb.Key(Speaker, speaker_id[0], parent=s_key)
new_speaker = Speaker(name=data['speaker'], key=speaker_key)
speaker_key = new_speaker.put()
speaker = speaker_key.get()
speaker.sessions.append(new_session.name)
speaker.put()
# Add 'Get Featured Speaker' task to queue
taskqueue.add(url='/tasks/set_featured_speakers', params={'speaker_key': speaker.key.urlsafe()})
return self._copy_session_to_form(new_session)
