def post(self, key):
presentation_filename = self.request.get('presentation_filename')
speaker = Speaker()
speaker.full_name = self.request.get('full_name')
speaker.designation = self.request.get('designation')
speaker.organization = self.request.get('organization')
speaker.department = self.request.get('department')
speaker.organization_website = self.request.get('organization_website')
speaker.city = self.request.get('city')
speaker.email = self.request.get('email')
speaker.mobile_number = self.request.get('mobile_number')
speaker.research_topic = self.request.get('research_topic')
speaker.bio_sketch = self.request.get('bio_sketch')
if presentation_filename:
speaker.presentation = self.request.get('presentation')
speaker.presentation_filename = self.request.get('presentation_filename')
speaker.presentation_extension = splitext(presentation_filename)[1]
speaker.put()
queue_mail_task(url='/worker/mail/thanks/speaker_nomination/',
params=dict(
full_name=speaker.full_name,
email = speaker.email,
key=str(speaker.key())
),
method='POST'
)
self.response.out.write(speaker.to_json('full_name', 'is_starred', 'is_deleted', 'is_active'))
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/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 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 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."""
# 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)
# 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."""
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 post(self, key):
presentation_filename = self.request.get("presentation_filename")
speaker = Speaker()
speaker.full_name = self.request.get("full_name")
speaker.designation = self.request.get("designation")
speaker.organization = self.request.get("organization")
speaker.department = self.request.get("department")
speaker.organization_website = self.request.get("organization_website")
speaker.city = self.request.get("city")
speaker.email = self.request.get("email")
speaker.mobile_number = self.request.get("mobile_number")
speaker.research_topic = self.request.get("research_topic")
speaker.bio_sketch = self.request.get("bio_sketch")
if presentation_filename:
presentation = Presentation()
presentation.filename = self.request.get("presentation_filename")
presentation.content = db.Blob(self.request.get("presentation"))
presentation.extension = splitext(presentation_filename)[1]
presentation.put()
speaker.presentation_file = presentation
speaker.put()
queue_mail_task(
url="/worker/mail/thanks/speaker_nomination/",
params=dict(full_name=speaker.full_name, email=speaker.email, key=str(speaker.key())),
method="POST",
)
self.response.out.write(speaker.to_json("full_name", "is_starred", "is_deleted", "is_active"))
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 _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 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 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 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 _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 post(self):
from models import Presentation
host_info = get_host_info(self.request)
host_info.put()
presentation_filename = self.request.get('presentation_filename')
presentation = self.request.get('presentation')
speaker = Speaker()
speaker.full_name = self.request.get('full_name')
speaker.designation = self.request.get('designation')
speaker.organization = self.request.get('organization')
speaker.department = self.request.get('department')
speaker.organization_website = self.request.get('organization_website')
speaker.city = self.request.get('city')
speaker.email = self.request.get('email')
speaker.mobile_number = self.request.get('mobile_number')
speaker.research_topic = self.request.get('research_topic')
speaker.bio_sketch = self.request.get('bio_sketch')
speaker.host_info = host_info
#if presentation_filename:
# speaker.presentation = db.Blob(presentation)
# speaker.presentation_filename = presentation_filename
# speaker.presentation_extension = splitext(presentation_filename)[1]
if presentation_filename:
speaker_presentation = Presentation()
speaker_presentation.filename = presentation_filename
speaker_presentation.extension = splitext(presentation_filename)[1]
speaker_presentation.content = db.Blob(presentation)
speaker_presentation.put()
speaker.presentation = speaker_presentation
speaker.put()
queue_mail_task(url='/worker/mail/thanks/speaker_nomination/',
params=dict(
full_name=speaker.full_name,
email = speaker.email,
key=str(speaker.key())
),
method='POST'
)
response = render_template('thank_you.html', message_title='Thank you for nominating a speaker.', message_body='We appreciate your taking the time to nominating a speaker. We will get in touch with you soon')
self.response.out.write(response)
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 _addSpeaker(self, request):
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
c_key = ndb.Key(Speaker, request.speakerEmail)
sp = c_key.get()
if not sp:
sp = Speaker(
key=c_key,
speakerName=request.speakerName,
speakerEmail=request.speakerEmail,
specialization=request.specialization,
currentWorkingPlace=request.currentWorkingPlace,
)
sp.put()
return sp # return 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 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 _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 Speaker and return to user."""
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
data = {field.name: getattr(request, field.name)
for field in request.all_fields()}
# generate Speaker Key based on email
s_key = ndb.Key(Speaker, data['email'])
data['key'] = s_key
spkr = Speaker(**data)
spkr.put()
# return SpeakerForm
return self._copySpeakerToForm(spkr)
def _getSpeaker(self, name, email):
"""Return Speaker from datastore, creating new one if non-existent."""
# get Speaker from datastore
s_key = ndb.Key(Speaker, email)
speaker = s_key.get()
# create new Speaker if not there
if not speaker:
speaker = Speaker(
key = s_key,
name = name,
email= email)
speaker.put()
else:
#check name is the same, else return error
if speaker.name != name:
raise ConflictException(
"A different speaker is already registered with this email %s" % email)
return speaker # return Speaker
def _doSpeaker(self, request):
"""Get, create or update speaker"""
s_key = ndb.Key(Speaker,request.mainEmail)
speaker = s_key.get()
# if speaker exists, process user-modifyable fields
if speaker:
for field in ('displayName', 'bio'):
if hasattr(request, field):
val = getattr(request, field)
if val:
setattr(speaker, field, str(val))
else:
speaker = Speaker(key=s_key, displayName=request.displayName, mainEmail=request.mainEmail, bio=request.bio)
# put the modified speaker to datastore
speaker.put()
# return SpeakerForm
return self._copySpeakerToForm(speaker)
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 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 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):
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
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
sp = Speaker(**data)
sp.put()
return self._copySpeakerToForm(sp)
def _doSpeaker(self, request):
"""Get, create or update speaker"""
sp_key = ndb.Key(Speaker, request.displayName)
speaker = sp_key.get()
# if speaker exists, process user-modifyable fields
if speaker:
for field in ('displayName', 'bio'):
if hasattr(request, field):
val = getattr(request, field)
if val:
setattr(speaker, field, str(val))
# if speaker doesn't exist, create new speaker object
else:
speaker = Speaker(key=sp_key,
displayName=request.displayName,
mainEmail=request.mainEmail,
bio=request.bio,
sessionKeys=[])
# put the modified speaker to datastore
speaker.put()
# return SpeakerForm
return self._copySpeakerToForm(speaker)
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 post(self, confid):
"""Accept proposals via POST requests"""
# get parameters from request
name = self.request.get("name")
surname = self.request.get("surname")
email = self.request.get("email")
bio = self.request.get("bio")
useOld = self.request.get("use-old")
title = self.request.get("title")
abstract = self.request.get("abstract")
duration = int(self.request.get("duration"))
comment = self.request.get("comment")
# timestamp 'now'
now = datetime.now()
# search for conference
conference = Conference.get_by_id(confid)
if not conference:
self.error("Conference not found", 404)
return
# search for speaker?
speakerKey = None
if useOld:
# get speakers for email
speakers = Speaker.query(Speaker.email == email)
# and order by modified-date (reverse) to get the last one
speakers = speakers.order(-Speaker.modified).iter()
if speakers.has_next():
speaker = speakers.next()
speakerKey = speaker.key
if not speakerKey:
# create speaker object
speaker = Speaker(name=name, surname=surname, email=email,
bio=bio, created=now, modified=now)
speakerKey = speaker.put()
# submit proposal
proposal = Proposal(parent=conference.key, speaker=speakerKey,
abstract=abstract, duration=duration,
title=title, comment=comment, created=now,
modified=now)
proposalKey = proposal.put()
if proposalKey:
self.success()
else:
self.error("Error when storing proposal", 500)
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 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 _createSessionObject(self, request):
"""Create or update Session object, returning SessionForm/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(
"Session 'name' field required")
if not request.speaker_name:
raise endpoints.BadRequestException(
"Session 'speaker_name' field required")
if not request.speaker_email:
raise endpoints.BadRequestException(
"Session 'speaker_email' field required")
if not request.date:
raise endpoints.BadRequestException(
"Session 'date' field required")
if not request.start_time:
raise endpoints.BadRequestException(
"Session 'start time' field required")
# Let's get the conference object from the websafe key, as entered by the user
wsck = request.conf_websafekey
conf = ndb.Key(urlsafe=wsck).get()
# Let's get the speaker, as per the email address that user entered
# check if speaker object exists:
print "The email is: ", request.speaker_email
speaker_key = ndb.Key(Speaker, request.speaker_email)
speaker = speaker_key.get()
# if speaker object does not exist, check if the speaker has a user profile already
if not speaker:
print "That speaker doesn't exist, so we will make one."
sp_key = ndb.Key(Profile, request.speaker_email)
speaker_profile = sp_key.get()
# If the speaker doesn't have a user profile yet
if not speaker_profile:
sp_key_urlsafe = ""
else:
sp_key_urlsafe = sp_key.urlsafe()
# Create the speaker object and add to the datastore.
speaker = Speaker(key=speaker_key,
name=request.speaker_name,
email=request.speaker_email,
speciality=request.speaker_speciality,
user_profile_key=sp_key_urlsafe)
speaker.put()
# Get the urlsafe key, which we put in the session object (to id the speaker entity)
speaker_key = speaker.key.urlsafe()
if not conf:
raise endpoints.NotFoundException(
'No conference found with key: %s' % wsck)
# copy SessionForm/ProtoRPC Message into dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
del data['conf_websafekey']
del data['speaker_email']
del data['speaker_name']
del data['speaker_speciality']
# Once we have a speaker, we can put the key into the data dict
data['speaker_key'] = speaker_key
data['type_of_session'] = str(data['type_of_session'])
# 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])
# convert dates from strings to Date objects; set month based on start_date
if data['date']:
data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d")
if data['start_time']:
data['start_time'] = datetime.strptime(data['start_time'][:10],
"%H:%M")
# The following code makes the session a child of the conference
# Get the Key instance form the urlsafe key
c_key = ndb.Key(urlsafe=wsck)
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
sess = Session(**data)
sess.put()
# Let's figure out if this speaker should be featured in the announcements:
# Count how many sessions the speaker is to speak in.
speakers_count = Session.query(ancestor=conf.key).filter(
Session.speaker_key == sess.speaker_key).count()
# Send the speaker name and count to the task to set featured speakers
taskqueue.add(params={
'speaker': speaker.name,
'count': speakers_count
},
url='/tasks/set_featured_speaker')
return self._copySessionToForm(sess, conf)
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 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 _createSessionObject(self, request):
"""Create or update Session object, returning SessionForm/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("Session 'name' field required")
if not request.speaker_name:
raise endpoints.BadRequestException("Session 'speaker_name' field required")
if not request.speaker_email:
raise endpoints.BadRequestException("Session 'speaker_email' field required")
if not request.date:
raise endpoints.BadRequestException("Session 'date' field required")
if not request.start_time:
raise endpoints.BadRequestException("Session 'start time' field required")
# Let's get the conference object from the websafe key, as entered by the user
wsck = request.conf_websafekey
conf = ndb.Key(urlsafe=wsck).get()
# Let's get the speaker, as per the email address that user entered
# check if speaker object exists:
print "The email is: ", request.speaker_email
speaker_key = ndb.Key(Speaker, request.speaker_email)
speaker = speaker_key.get()
# if speaker object does not exist, check if the speaker has a user profile already
if not speaker:
print "That speaker doesn't exist, so we will make one."
sp_key = ndb.Key(Profile, request.speaker_email)
speaker_profile = sp_key.get()
# If the speaker doesn't have a user profile yet
if not speaker_profile:
sp_key_urlsafe = ""
else:
sp_key_urlsafe = sp_key.urlsafe()
# Create the speaker object and add to the datastore.
speaker = Speaker(key=speaker_key,
name=request.speaker_name,
email=request.speaker_email,
speciality=request.speaker_speciality,
user_profile_key=sp_key_urlsafe)
speaker.put()
# Get the urlsafe key, which we put in the session object (to id the speaker entity)
speaker_key = speaker.key.urlsafe()
if not conf:
raise endpoints.NotFoundException(
'No conference found with key: %s' % wsck)
# copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
del data['conf_websafekey']
del data['speaker_email']
del data['speaker_name']
del data['speaker_speciality']
# Once we have a speaker, we can put the key into the data dict
data['speaker_key'] = speaker_key
data['type_of_session'] = str(data['type_of_session'])
# 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])
# convert dates from strings to Date objects; set month based on start_date
if data['date']:
data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d")
if data['start_time']:
data['start_time'] = datetime.strptime(data['start_time'][:10], "%H:%M")
# The following code makes the session a child of the conference
# Get the Key instance form the urlsafe key
c_key = ndb.Key(urlsafe=wsck)
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
sess = Session(**data)
sess.put()
# Let's figure out if this speaker should be featured in the announcements:
# Count how many sessions the speaker is to speak in.
speakers_count = Session.query(ancestor=conf.key).filter(Session.speaker_key == sess.speaker_key).count()
# Send the speaker name and count to the task to set featured speakers
taskqueue.add(params={'speaker': speaker.name, 'count': speakers_count},
url='/tasks/set_featured_speaker')
return self._copySessionToForm(sess, conf)
def _createSessionObject(self, request):
"""Create a new session object, and if necessary, a new 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(
"Session 'name' field required")
# get key of the conference where the session will be held
conf_key = ndb.Key(urlsafe=request.websafeConferenceKey)
conf = conf_key.get()
# check that conference exists
if not conf:
raise endpoints.NotFoundException(
'No conference found with key: %s' %
request.websafeConferenceKey)
# check that user is owner
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
'Only the owner can update the conference.')
# copy SessionForm/ProtoRPC Message into dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
# If session creator has provided a speaker key, check that it is valid and retrieve
# his/her name if possible
# Otherwise create a new speaker (if a speaker name is provided) and assign a a key otherwise continue
# building the session without a speaker
if data['websafeSpeakerKey'] is not None:
try:
speaker_key = ndb.Key(urlsafe=request.websafeSpeakerKey)
speaker = speaker_key.get()
data['speakerName'] = speaker.name
data['speakerEmail'] = speaker.mainEmail
except ProtocolBufferDecodeError:
raise endpoints.NotFoundException(
'No speaker found with websafeSpeakerKey: %s. Create a new speaker or enter the key again'
% data['websafeSpeakerKey'])
else:
# Create a new speaker object if a name is provided in the SessionForm
if data['speakerName'] is not None:
speaker = Speaker(name=data['speakerName'],
mainEmail=data['speakerEmail'])
speaker.put()
data['websafeSpeakerKey'] = speaker.key.urlsafe()
speaker.websafeKey = speaker.key.urlsafe()
# add default values for those missing (both data model & outbound Message)
for df in SESS_DEFAULTS:
if data[df] in (None, []):
data[df] = SESS_DEFAULTS[df]
setattr(request, df, SESS_DEFAULTS[df])
# convert Date from string to Date object
if data['date'] is not None:
data['date'] = datetime.datetime.strptime(data['date'][:10],
"%Y-%m-%d").date()
# convert startTime from string to Time object
if data['startTime'] is not None:
data['startTime'] = datetime.datetime.strptime(
data['startTime'][:], "%H:%M").time()
# websafeKey only used for return messages
del data['websafeKey']
# Assign the new session a conference parent
data['parent'] = conf_key
# Create the sesion and put to the database
sess = Session(**data)
sess_key = sess.put()
# update speaker (if necessary) so that this session key will be added to his list of session keys
if speaker is not None:
speaker.sessionKeys.append(sess_key)
speaker.put()
# Check the speaker's sessions to see if he/she already has a session at the same conference
# If so, set a featured speaker memcache entry to list all of his or her sessions
parent_keys = [
sess_key.parent() for sess_key in speaker.sessionKeys
]
if sess_key.parent() in parent_keys:
featured_sessions = [
sess_key.get() for sess_key in speaker.sessionKeys
]
featured_speaker_string = FEATURED_SPEAKER_TPL % (
speaker.name, ', '.join(sess.name
for sess in featured_sessions))
memcache.set(MEMCACHE_FEATURED_SPEAKER_KEY,
featured_speaker_string)
return self._copySessionToForm(sess)
def _createSpeakerObject(self, request):
speaker = Speaker(name=request.name, mainEmail=request.mainEmail)
speaker.put()
speaker.websafeKey = speaker.key.urlsafe()
speaker.put()
return self._copySpeakerToForm(speaker)
